1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "test/unittest/core/base/view_abstract_test_ng.h" 17 18 #include "base/subwindow/subwindow_manager.h" 19 #include "core/components_ng/event/focus_hub.h" 20 #include "core/event/key_event.h" 21 #include "test/mock/base/mock_system_properties.h" 22 23 using namespace testing; 24 using namespace testing::ext; 25 26 namespace OHOS::Ace::NG { 27 /** 28 * @tc.name: ViewAbstractTest031 29 * @tc.desc: Test the operation of View_Abstract 30 * @tc.type: FUNC 31 */ 32 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest031, TestSize.Level1) 33 { 34 /** 35 * @tc.steps: step1.ClearStack. 36 */ 37 auto state = static_cast<VisualState>(INDEX); 38 ViewStackProcessor::GetInstance()->SetVisualState(state); 39 ViewStackProcessor::GetInstance()->ClearStack(); 40 41 /** 42 * @tc.steps: step2. related function is called. 43 */ 44 ViewAbstract::SetFlexShrink(RATIO); 45 ViewAbstract::SetFlexGrow(RATIO); 46 ViewAbstract::SetFlexBasis(WIDTH); 47 ViewAbstract::SetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER), WIDTH); 48 ViewAbstract::SetDisplayIndex(TEN); 49 ViewAbstract::SetZIndex(FOUF); 50 51 Alignment alignment; 52 ViewAbstract::SetAlign(std::move(alignment)); 53 auto visible = static_cast<VisibleType>(INDEX); 54 ViewAbstract::SetVisibility(std::move(visible)); 55 ViewAbstract::SetOpacity(OPACITYS); 56 57 /** 58 * @tc.expected: Return expected results. 59 */ 60 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 61 EXPECT_FALSE(result); 62 } 63 64 /** 65 * @tc.name: ViewAbstractTest032 66 * @tc.desc: Test the operation of View_Abstract 67 * @tc.type: FUNC 68 */ 69 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest032, TestSize.Level1) 70 { 71 /** 72 * @tc.steps: step1.ClearStack. 73 */ 74 auto state = static_cast<VisualState>(INDEX); 75 ViewStackProcessor::GetInstance()->SetVisualState(state); 76 ViewStackProcessor::GetInstance()->ClearStack(); 77 78 /** 79 * @tc.steps: step2. related function is called. 80 */ 81 OffsetT<Dimension> values = { WIDTH, HEIGHT }; 82 ViewAbstract::SetPosition(values); 83 ViewAbstract::SetOffset(values); 84 ViewAbstract::MarkAnchor(values); 85 86 ViewAbstract::SetPadding(NG::CalcLength(WIDTH)); 87 ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH)); 88 ViewAbstract::SetMargin(NG::CalcLength(WIDTH)); 89 ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH)); 90 ViewAbstract::SetBorderRadius(WIDTH); 91 ViewAbstract::SetBorderRadius(nullptr, WIDTH); 92 ViewAbstract::SetBorderColor(BLUE); 93 ViewAbstract::SetBorderColor(nullptr, BLUE); 94 ViewAbstract::SetBorderWidth(WIDTH); 95 ViewAbstract::SetBorderWidth(nullptr, WIDTH); 96 97 auto borderStyle = static_cast<BorderStyle>(INDEX); 98 ViewAbstract::SetBorderStyle(borderStyle); 99 ViewAbstract::SetBorderStyle(nullptr, borderStyle); 100 101 /** 102 * @tc.expected: Return expected results. 103 */ 104 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 105 EXPECT_FALSE(result); 106 } 107 108 /** 109 * @tc.name: ViewAbstractTest033 110 * @tc.desc: Test the operation of View_Abstract 111 * @tc.type: FUNC 112 */ 113 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest033, TestSize.Level1) 114 { 115 /** 116 * @tc.steps: step1.ClearStack. 117 */ 118 auto state = static_cast<VisualState>(INDEX); 119 ViewStackProcessor::GetInstance()->SetVisualState(state); 120 ViewStackProcessor::GetInstance()->ClearStack(); 121 122 /** 123 * @tc.steps: step2. related function is called. 124 */ 125 OffsetT<Dimension> values = { WIDTH, HEIGHT }; 126 ViewAbstract::SetPosition(values); 127 ViewAbstract::SetOffset(values); 128 ViewAbstract::MarkAnchor(values); 129 130 NG::PaddingProperty paddings; 131 ViewAbstract::SetPadding(paddings); 132 ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), paddings); 133 134 NG::MarginProperty margins; 135 ViewAbstract::SetMargin(margins); 136 ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), margins); 137 138 NG::BorderRadiusProperty borderRadius; 139 ViewAbstract::SetBorderRadius(borderRadius); 140 141 NG::BorderColorProperty borderColors; 142 ViewAbstract::SetBorderColor(borderColors); 143 144 NG::BorderWidthProperty borderWidth; 145 ViewAbstract::SetBorderWidth(borderWidth); 146 147 NG::BorderStyleProperty borderStyles; 148 ViewAbstract::SetBorderStyle(borderStyles); 149 ViewAbstract::SetBorderStyle(nullptr, borderStyles); 150 151 /** 152 * @tc.expected: Return expected results. 153 */ 154 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 155 EXPECT_FALSE(result); 156 } 157 158 /** 159 * @tc.name: ViewAbstractTest034 160 * @tc.desc: Test the operation of View_Abstract 161 * @tc.type: FUNC 162 */ 163 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest034, TestSize.Level1) 164 { 165 /** 166 * @tc.steps: step1.ClearStack. 167 */ 168 auto state = static_cast<VisualState>(INDEX); 169 ViewStackProcessor::GetInstance()->SetVisualState(state); 170 ViewStackProcessor::GetInstance()->ClearStack(); 171 172 /** 173 * @tc.steps: step2. related function is called. 174 */ 175 BlurOption blurOption; 176 ViewAbstract::SetBrightness(RADIUS); 177 ViewAbstract::SetGrayScale(RADIUS); 178 ViewAbstract::SetContrast(RADIUS); 179 ViewAbstract::SetContrast(nullptr, RADIUS); 180 ViewAbstract::SetSaturate(RADIUS); 181 ViewAbstract::SetSepia(RADIUS); 182 ViewAbstract::SetInvert(invert); 183 ViewAbstract::SetHueRotate(RATIO); 184 ViewAbstract::SetColorBlend(BLUE); 185 ViewAbstract::SetBackdropBlur(RADIUS, blurOption); 186 ViewAbstract::SetFrontBlur(RADIUS, blurOption); 187 ViewAbstract::SetClipEdge(false); 188 189 /** 190 * @tc.expected: Return expected results. 191 */ 192 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 193 EXPECT_FALSE(result); 194 } 195 196 /** 197 * @tc.name: ViewAbstractTest035 198 * @tc.desc: Test the operation of View_Abstract 199 * @tc.type: FUNC 200 */ 201 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest035, TestSize.Level1) 202 { 203 /** 204 * @tc.steps: step1.ClearStack. 205 */ 206 auto state = static_cast<VisualState>(INDEX); 207 ViewStackProcessor::GetInstance()->SetVisualState(state); 208 ViewStackProcessor::GetInstance()->ClearStack(); 209 210 /** 211 * @tc.steps: step2. related function is called. 212 */ 213 viewAbstractModelNG.SetScale(1.0f, 1.0f, 0.0f); 214 DimensionOffset value = { WIDTH, HEIGHT }; 215 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO); 216 NG::TranslateOptions values; 217 ViewAbstract::SetTranslate(std::move(values)); 218 Vector5F scales(1.0f, 1.0f, 2.0f, 2.0f, 0.0f); 219 ViewAbstract::SetRotate(scales); 220 Matrix4 matrix; 221 ViewAbstract::SetTransformMatrix(std::move(matrix)); 222 223 ShadowStyle style { 1 }; 224 Shadow shadow { RATIO, OFFSET, BLUE, style }; 225 ViewAbstract::SetBackShadow(shadow); 226 NG::Gradient gradient; 227 ViewAbstract::SetLinearGradient(std::move(gradient)); 228 ViewAbstract::SetSweepGradient(std::move(gradient)); 229 ViewAbstract::SetRadialGradient(std::move(gradient)); 230 TransitionOptions options; 231 ViewAbstract::SetTransition(std::move(options)); 232 ViewAbstract::SetTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(options)); 233 RefPtr<BasicShape> basicShape; 234 ViewAbstract::SetClipShape(std::move(basicShape)); 235 ViewAbstract::SetMask(std::move(basicShape)); 236 ViewAbstract::SetMask(nullptr, std::move(basicShape)); 237 238 /** 239 * @tc.expected: Return expected results. 240 */ 241 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 242 EXPECT_FALSE(result); 243 } 244 245 /** 246 * @tc.name: ViewAbstractTest036 247 * @tc.desc: Test the operation of View_Abstract 248 * @tc.type: FUNC 249 */ 250 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest036, TestSize.Level1) 251 { 252 /** 253 * @tc.steps: step1.ClearStack. 254 */ 255 auto state = static_cast<VisualState>(INDEX); 256 ViewStackProcessor::GetInstance()->SetVisualState(state); 257 ViewStackProcessor::GetInstance()->ClearStack(); 258 259 /** 260 * @tc.steps: step2. related function is called. 261 */ 262 ViewAbstract::SetBorderImageSource(srcimages); 263 ViewAbstract::SetBorderImageSource(nullptr, srcimages); 264 ViewAbstract::SetHasBorderImageSlice(false); 265 ViewAbstract::SetHasBorderImageSlice(nullptr, false); 266 ViewAbstract::SetHasBorderImageWidth(false); 267 ViewAbstract::SetHasBorderImageWidth(nullptr, false); 268 ViewAbstract::SetHasBorderImageOutset(false); 269 ViewAbstract::SetHasBorderImageOutset(nullptr, false); 270 ViewAbstract::SetHasBorderImageRepeat(false); 271 ViewAbstract::SetSphericalEffect(RATIO); 272 ViewAbstract::SetSphericalEffect(nullptr, RATIO); 273 ViewAbstract::SetLightUpEffect(RATIO); 274 ViewAbstract::SetLightUpEffect(nullptr, RATIO); 275 ViewAbstract::SetForegroundColor(BLUE); 276 ViewAbstract::SetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER), BLUE); 277 ViewAbstract::ClearWidthOrHeight(true); 278 ViewAbstract::SetRenderGroup(false); 279 ViewAbstract::SetRenderGroup(nullptr, false); 280 ViewAbstract::SetRenderFit(RenderFit::BOTTOM); 281 ViewAbstract::SetRenderFit(nullptr, RenderFit::BOTTOM); 282 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts); 283 ViewAbstract::SetObscured(reasonsVector); 284 285 PixStretchEffectOption option; 286 option.bottom = BOTTOM; 287 option.left = LEFT; 288 option.right = RIGHT; 289 option.top = TOP; 290 ViewAbstract::SetPixelStretchEffect(option); 291 292 /** 293 * @tc.expected: Return expected results. 294 */ 295 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 296 EXPECT_FALSE(result); 297 } 298 299 /** 300 * @tc.name: ViewAbstractTest037 301 * @tc.desc: Test the operation of View_Abstract 302 * @tc.type: FUNC 303 */ 304 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest037, TestSize.Level1) 305 { 306 /** 307 * @tc.steps: step1.ClearStack. 308 */ 309 auto state = static_cast<VisualState>(INDEX); 310 ViewStackProcessor::GetInstance()->SetVisualState(state); 311 ViewStackProcessor::GetInstance()->ClearStack(); 312 313 /** 314 * @tc.steps: step2. related function is called. 315 */ 316 RefPtr<BorderImage> borderImage; 317 ViewAbstract::SetBorderImage(std::move(borderImage)); 318 Gradient gradient; 319 ViewAbstract::SetBorderImageGradient(std::move(gradient)); 320 RefPtr<NG::ChainedTransitionEffect> effect; 321 ViewAbstract::SetChainedTransition(std::move(effect)); 322 ViewAbstract::SetChainedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(effect)); 323 RefPtr<ProgressMaskProperty> progress; 324 ViewAbstract::SetProgressMask(std::move(progress)); 325 ViewAbstract::SetProgressMask(nullptr, std::move(progress)); 326 auto strategy = static_cast<ForegroundColorStrategy>(INDEX); 327 ViewAbstract::SetForegroundColorStrategy(std::move(strategy)); 328 ViewAbstract::SetForegroundColorStrategy(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(strategy)); 329 OverlayOptions overlay; 330 ViewAbstract::SetOverlay(std::move(overlay)); 331 332 /** 333 * @tc.expected: Return expected results. 334 */ 335 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 336 EXPECT_FALSE(result); 337 } 338 339 /** 340 * @tc.name: ViewAbstractTest038 341 * @tc.desc: Test the operation of View_Abstract. 342 * @tc.type: FUNC 343 */ 344 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest038, TestSize.Level1) 345 { 346 /** 347 * @tc.steps: step1. Build a object viewAbstract. 348 */ 349 ViewStackProcessor viewStackProcessor; 350 ViewAbstract viewAbstract; 351 constexpr char TAG_ROOT[] = "root"; 352 constexpr char TAG_CHILD[] = "child"; 353 const auto MOCK_PATTERN_ROOT = AceType::MakeRefPtr<Pattern>(); 354 const auto FRAME_NODE_ROOT = FrameNode::CreateFrameNode(TAG_ROOT, 1, MOCK_PATTERN_ROOT, true); 355 const auto FRAME_NODE_CHILD = FrameNode::CreateFrameNode(TAG_CHILD, 2, MOCK_PATTERN_ROOT, false); 356 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 357 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 358 /** 359 * @tc.steps: step2. callback SetClickEffectLevel.push FrameNode is not null. 360 */ 361 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 362 viewAbstract.SetClickEffectLevel(AceType::RawPtr(FRAME_NODE_REGISTER), ClickEffectLevel::LIGHT, 1.0f); 363 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 364 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 365 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish()); 366 ASSERT_NE(frameNode, nullptr); 367 /** 368 * @tc.expected: step3. Return expected results.. 369 */ 370 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode); 371 ASSERT_NE(Node, nullptr); 372 auto layoutProperty = Node->GetLayoutProperty(); 373 ASSERT_NE(layoutProperty, nullptr); 374 viewStackProcessor.instance = nullptr; 375 } 376 377 /** 378 * @tc.name: ViewAbstractTest039 379 * @tc.desc: Test the operation of View_Abstract 380 * @tc.type: FUNC 381 */ 382 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest039, TestSize.Level1) 383 { 384 /** 385 * @tc.steps: step1. Build a object viewAbstract. 386 */ 387 ViewStackProcessor viewStackProcessor; 388 ViewAbstract viewAbstract; 389 int32_t index = 1; 390 auto state = static_cast<VisualState>(index); 391 viewStackProcessor.GetInstance()->SetVisualState(state); 392 /** 393 * @tc.steps: step2.ClearStack and callback SetScale. 394 */ 395 viewStackProcessor.GetInstance()->ClearStack(); 396 /** 397 * @tc.expected: step2. Return expected results.. 398 */ 399 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 400 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 401 ViewAbstract::ResetMinSize(true); 402 EXPECT_FALSE(result); 403 /** 404 * @tc.steps: step3. visualState_ is null. 405 * @tc.expected: result is true. 406 */ 407 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 408 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 409 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 410 ViewAbstract::ResetMinSize(true); 411 EXPECT_TRUE(result); 412 } 413 414 /** 415 * @tc.name: ViewAbstractTest040 416 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG 417 * @tc.type: FUNC 418 */ 419 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest040, TestSize.Level1) 420 { 421 /** 422 * @tc.steps: step1. create and put mainNode, then build some necessary params. 423 */ 424 const RefPtr<FrameNode> mainNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 425 ViewStackProcessor::GetInstance()->Push(mainNode); 426 427 auto container = Container::Current(); 428 ASSERT_NE(container, nullptr); 429 auto pipelineContext = container->GetPipelineContext(); 430 ASSERT_NE(pipelineContext, nullptr); 431 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 432 ASSERT_NE(context, nullptr); 433 auto overlayManager = context->GetOverlayManager(); 434 ASSERT_NE(overlayManager, nullptr); 435 436 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anond0af9a040102() 437 std::function<void()> flagFunc = []() { flag++; }; 438 std::vector<NG::OptionParam> params = {}; 439 std::function<void()> buildFunc; 440 MenuParam menuParam; 441 std::function<void()> previewBuildFunc = nullptr; 442 /** 443 * @tc.steps: step2. call Bind and BindContextMenu multiple times with unless parameters 444 * @tc.expected: The show or hide method will not call flagFunc. 445 */ 446 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); __anond0af9a040202() 447 buildFunc = []() {}; 448 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 449 params.push_back(OptionParam()); 450 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 451 menuParam.type = MenuType::CONTEXT_MENU; 452 viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc); 453 EXPECT_EQ(flag, 0); 454 /** 455 * @tc.steps: step3. set appear and disappear and recall BindMenu and BindContextMenu; 456 * @tc.expected: The flagFunc call times meet expectations. 457 */ 458 menuParam.onAppear = flagFunc; 459 menuParam.onDisappear = flagFunc; 460 menuParam.type = MenuType::MENU; 461 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 462 menuParam.type = MenuType::CONTEXT_MENU; 463 viewAbstractModelNG.BindContextMenu(ResponseType::RIGHT_CLICK, buildFunc, menuParam, previewBuildFunc); 464 menuParam.contextMenuRegisterType = ContextMenuRegisterType::CUSTOM_TYPE; 465 menuParam.isShow = true; 466 viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc); 467 EXPECT_EQ(flag, 0); 468 auto subwindow = SubwindowManager::GetInstance()->GetSubwindow(container); 469 EXPECT_EQ(subwindow, nullptr); 470 471 /** 472 * @tc.steps: step4. create mouseInfo, set some useless params and call onMouseCallback_; 473 * @tc.expected: StopPropagation in mouseInfo is false. 474 */ 475 auto inputHub = mainNode->GetOrCreateInputEventHub(); 476 ASSERT_NE(inputHub, nullptr); __anond0af9a040302(MouseInfo& info)477 auto mouseCallback = [](MouseInfo& info){}; 478 inputHub->showMenu_ = AceType::MakeRefPtr<InputEvent>(mouseCallback); 479 ASSERT_NE(inputHub->showMenu_, nullptr); 480 MouseInfo mouseInfo; 481 mouseInfo.SetButton(MouseButton::LEFT_BUTTON); 482 mouseInfo.SetAction(MouseAction::NONE); 483 inputHub->showMenu_->onMouseCallback_(mouseInfo); 484 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON); 485 mouseInfo.SetAction(MouseAction::NONE); 486 inputHub->showMenu_->onMouseCallback_(mouseInfo); 487 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 488 /** 489 * @tc.steps: step4. create mouseInfo, set right param and call onMouseCallback_; 490 * @tc.expected: StopPropagation in mouseInfo is false. 491 */ 492 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON); 493 mouseInfo.SetAction(MouseAction::RELEASE); 494 inputHub->showMenu_->onMouseCallback_(mouseInfo); 495 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 496 497 /** 498 * @tc.steps: step5. create mouseInfo, set right param and call BindMenuWithCustomNode; 499 * @tc.expected: StopPropagation in mouseInfo is true. 500 */ 501 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 502 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 503 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 504 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 505 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 506 const RefPtr<FrameNode> targetNode = 507 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 508 std::vector<OptionParam> param; 509 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam); 510 menuParam.type = MenuType::MULTI_MENU; 511 ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam, 512 std::move(previewBuildFunc)); 513 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 514 param.push_back(OptionParam()); 515 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam); 516 menuParam.type = MenuType::CONTEXT_MENU; 517 ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam, 518 std::move(previewBuildFunc)); 519 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 520 } 521 522 /** 523 * @tc.name: ViewAbstractTest041 524 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG 525 * @tc.type: FUNC 526 */ 527 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest041, TestSize.Level1) 528 { 529 /** 530 * @tc.steps: step1. creat frameNode and other creat. 531 */ 532 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 533 const RefPtr<FrameNode> frameNode = 534 FrameNode::CreateFrameNode("frameNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 535 536 auto layoutProperty = frameNode->GetLayoutProperty(); 537 CalcSize idealSize = { CalcLength(ZERO), CalcLength(ZERO) }; 538 layoutProperty->calcLayoutConstraint_ = std::make_unique<MeasureProperty>(); 539 layoutProperty->calcLayoutConstraint_->minSize = idealSize; 540 layoutProperty->calcLayoutConstraint_->maxSize = idealSize; 541 EffectOption option; 542 Color color = Color::TRANSPARENT; 543 option.color = color; 544 545 std::vector<std::pair<float, float>> fractionStops; 546 fractionStops.push_back(std::pair<float, float>(0.0f, 1.0f)); 547 CalcDimension dimensionRadius(0.0); 548 LinearGradientBlurPara blurPara(dimensionRadius, fractionStops, GradientDirection::LEFT); 549 /** 550 * @tc.steps: step2. ResetMinSize test, IsCurrentVisualStateProcess() == false 551 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_ not change 552 */ 553 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::DISABLED); 554 ViewAbstract::ResetMinSize(true); 555 ViewAbstract::ResetMinSize(AceType::RawPtr(FRAME_NODE_REGISTER), true); 556 ViewAbstract::ResetMaxSize(true); 557 ViewAbstract::ResetMaxSize(AceType::RawPtr(FRAME_NODE_REGISTER), true); 558 ViewAbstract::SetBackgroundAlign(Alignment::TOP_LEFT); 559 ViewAbstract::SetBackgroundEffect(option); 560 ViewAbstract::SetBackgroundEffect(AceType::RawPtr(FRAME_NODE_REGISTER), option); 561 ViewAbstract::SetDynamicLightUp(0, 0); 562 ViewAbstract::SetDynamicLightUp(AceType::RawPtr(FRAME_NODE_REGISTER), 0, 0); 563 ViewAbstract::SetLinearGradientBlur(blurPara); 564 ViewAbstract::SetLinearGradientBlur(nullptr, blurPara); 565 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.has_value()); 566 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.has_value()); 567 568 /** 569 * @tc.steps: step3. ResetMinSize test, IsCurrentVisualStateProcess() == true 570 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_->minSize.Width not change 571 */ 572 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 573 ViewAbstract::ResetMinSize(true); 574 ViewAbstract::ResetMaxSize(true); 575 ViewAbstract::SetBackgroundAlign(Alignment::BOTTOM_RIGHT); 576 ViewAbstract::SetBackgroundEffect(option); 577 ViewAbstract::SetDynamicLightUp(0, 0); 578 ViewAbstract::SetLinearGradientBlur(blurPara); 579 ViewAbstract::DisableOnAppear(); 580 ViewAbstract::DisableOnAreaChange(); 581 ViewAbstract::DisableOnDisAppear(); 582 std::vector<DimensionRect> responseRegion; 583 DimensionRect responseRect(Dimension(0), Dimension(0), DimensionOffset(OFFSETF)); 584 responseRegion.emplace_back(responseRect); 585 ViewAbstract::SetMouseResponseRegion(responseRegion); 586 ViewAbstract::SetMouseResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), responseRegion); 587 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.value().Width().has_value()); 588 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.value().Width().has_value()); 589 } 590 591 /** 592 * @tc.name: ViewAbstractTest042 593 * @tc.desc: Test the SetKeyboardShortcut of View_Abstract for tab/Up arrow/Down arrow/Left arrow/Right arrow key. 594 * @tc.type: FUNC 595 */ 596 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest042, TestSize.Level1) 597 { 598 /** 599 * @tc.steps: step1. Create a FrameNode and get eventManager. 600 */ 601 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 602 ViewStackProcessor::GetInstance()->Push(targetNode); 603 auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager(); 604 /** 605 * @tc.steps: step2. call SetKeyboardShortcut with tab and ModifierKey. 606 * @tc.expected: add fail 607 */ 608 std::vector<ModifierKey> keys; 609 keys.push_back(ModifierKey::SHIFT); 610 ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback); 611 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 612 keys.clear(); 613 614 /** 615 * @tc.steps: step3. call SetKeyboardShortcut with up arrow. 616 * @tc.expected: add success 617 */ 618 ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback); 619 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 620 keys.clear(); 621 622 /** 623 * @tc.steps: step4. call SetKeyboardShortcut with up arrow and ModifierKey. 624 * @tc.expected: add success 625 */ 626 keys.push_back(ModifierKey::ALT); 627 ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback); 628 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 629 keys.clear(); 630 631 /** 632 * @tc.steps: step5. call SetKeyboardShortcut with tab. 633 * @tc.expected: add success 634 */ 635 636 ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback); 637 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 638 } 639 640 /** 641 * @tc.name: ViewAbstractBackground001 642 * @tc.desc: Test the background of View_Abstract. 643 * @tc.type: FUNC 644 */ 645 HWTEST_F(ViewAbstractTestNg, ViewAbstractBackground001, TestSize.Level1) 646 { 647 /** 648 * @tc.steps: step1. Create a FrameNode. 649 */ 650 const RefPtr<FrameNode> node = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 651 auto instance = ViewStackProcessor::GetInstance(); 652 instance->Push(node); 653 auto renderContext = node->GetRenderContext(); 654 ASSERT_NE(renderContext, nullptr); 655 auto pattern = node->GetPattern<Pattern>(); 656 ASSERT_TRUE(pattern); 657 pattern->resourceMgr_ = AceType::MakeRefPtr<PatternResourceManager>(); 658 ASSERT_TRUE(pattern->resourceMgr_); 659 instance->ClearVisualState(); 660 EXPECT_TRUE(instance->IsCurrentVisualStateProcess()); 661 /** 662 * @tc.steps: step2. Set background options. 663 * @tc.expected: Options are set successfully. 664 */ 665 Alignment align = Alignment::TOP_CENTER; 666 ViewAbstract::SetBackgroundAlign(node.GetRawPtr(), align); 667 auto backgroundAlign = renderContext->GetBackgroundAlign().value_or(Alignment::BOTTOM_CENTER); 668 EXPECT_EQ(backgroundAlign, align); 669 670 Color color = Color::RED; 671 ViewAbstract::SetBackgroundColor(node.GetRawPtr(), color); 672 EXPECT_EQ(renderContext->GetBackgroundColor().value_or(Color::TRANSPARENT), color); 673 674 auto resourceObject = AceType::MakeRefPtr<ResourceObject>(); 675 ViewAbstract::SetCustomBackgroundColorWithResourceObj(node.GetRawPtr(), BLUE, resourceObject); 676 EXPECT_TRUE(pattern->resourceMgr_->resMap_.find("customBackgroundColor") != pattern->resourceMgr_->resMap_.end()); 677 678 LayoutSafeAreaEdge edge = LAYOUT_SAFE_AREA_EDGE_START; 679 ViewAbstract::SetBackgroundIgnoresLayoutSafeAreaEdges(node.GetRawPtr(), edge); 680 ASSERT_NE(node->GetLayoutProperty(), nullptr); 681 EXPECT_EQ(node->GetLayoutProperty()->GetBackgroundIgnoresLayoutSafeAreaEdges(), edge); 682 683 ViewAbstract::SetIsTransitionBackground(node.GetRawPtr(), true); 684 EXPECT_TRUE(renderContext->GetIsTransitionBackground().value_or(false)); 685 686 ViewAbstract::SetIsBuilderBackground(node.GetRawPtr(), true); 687 EXPECT_TRUE(renderContext->GetBuilderBackgroundFlag().value_or(false)); 688 } 689 690 691 /** 692 * @tc.name: ViewAbstractOffsetEdges001 693 * @tc.desc: test offset attribute, use Edges type. 694 * @tc.type: FUNC 695 */ 696 HWTEST_F(ViewAbstractTestNg, ViewAbstractOffset001, TestSize.Level1) 697 { 698 /** 699 * @tc.steps: step1. create and put mainNode, then build some necessary params. 700 */ 701 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 702 703 /** 704 * @tc.steps: step2. get node in ViewStackProcessor. 705 * @tc.expected: node is not null. 706 */ 707 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 708 EXPECT_NE(rootFrameNode, nullptr); 709 710 /** 711 * @tc.steps: step3. use ViewAbstract::SetOffsetEdges. 712 * @tc.expected: success set render property offsetEdges value. 713 */ 714 EdgesParam edges; 715 CalcDimension top(30, DimensionUnit::VP); 716 CalcDimension left(20, DimensionUnit::VP); 717 edges.SetTop(top); 718 edges.SetLeft(left); 719 ViewAbstract::SetOffsetEdges(edges); 720 721 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 722 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 723 ->GetOffsetEdgesValue(EdgesParam {}).top.value_or(Dimension {}).ConvertToVp(), 30.0f); 724 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 725 ->GetOffsetEdgesValue(EdgesParam {}).left.value_or(Dimension {}).ConvertToVp(), 20.0f); 726 727 /** 728 * @tc.steps: step5. finish view stack. 729 */ 730 ViewStackProcessor::GetInstance()->Finish(); 731 } 732 733 /** 734 * @tc.name: ViewAbstractPositionEdges001 735 * @tc.desc: test position attribute, use Edges type. 736 * @tc.type: FUNC 737 */ 738 HWTEST_F(ViewAbstractTestNg, ViewAbstractPositionEdges001, TestSize.Level1) 739 { 740 /** 741 * @tc.steps: step1. create and put mainNode, then build some necessary params. 742 */ 743 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 744 745 /** 746 * @tc.steps: step2. get node in ViewStackProcessor. 747 * @tc.expected: node is not null. 748 */ 749 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 750 EXPECT_NE(rootFrameNode, nullptr); 751 752 /** 753 * @tc.steps: step3. use ViewAbstract::SetPositionEdges. 754 * @tc.expected: success set render property PositionEdges value. 755 */ 756 EdgesParam edges; 757 CalcDimension bottom(30, DimensionUnit::VP); 758 CalcDimension right(20, DimensionUnit::VP); 759 edges.SetBottom(bottom); 760 edges.SetRight(right); 761 ViewAbstract::SetPositionEdges(edges); 762 763 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 764 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 765 ->GetPositionEdgesValue(EdgesParam {}).bottom.value_or(Dimension {}).ConvertToVp(), 30.0f); 766 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 767 ->GetPositionEdgesValue(EdgesParam {}).right.value_or(Dimension {}).ConvertToVp(), 20.0f); 768 769 /** 770 * @tc.steps: step5. finish view stack. 771 */ 772 ViewStackProcessor::GetInstance()->Finish(); 773 } 774 775 /** 776 * @tc.name: ViewAbstractDisableClickTest 777 * @tc.desc: Test the operation of View_Abstract. 778 * @tc.type: FUNC 779 */ 780 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickTest, TestSize.Level1) 781 { 782 /** 783 * @tc.steps: step1. create framenode and check callback; 784 * @tc.expected: callback is not null. 785 */ 786 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 787 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 788 GestureEventFunc tapEventFunc; 789 ViewAbstract::SetOnClick(std::move(tapEventFunc)); 790 791 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 792 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 793 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 794 ASSERT_NE(frameNode, nullptr); 795 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 796 ASSERT_NE(node, nullptr); 797 auto gestureHub = node->GetOrCreateGestureEventHub(); 798 auto& callback = gestureHub->clickEventActuator_->userCallback_; 799 EXPECT_NE(callback, nullptr); 800 801 /** 802 * @tc.steps: step2. Disable callback. 803 * @tc.expected: callback is null. 804 */ 805 ViewAbstract::DisableOnClick(); 806 EXPECT_EQ(callback, nullptr); 807 808 /** 809 * @tc.steps: step3. Add callback again. 810 * @tc.expected: callback is not null. 811 */ 812 GestureEventFunc tapEventFunc2; 813 ViewAbstract::SetOnClick(std::move(tapEventFunc2)); 814 EXPECT_NE(callback, nullptr); 815 ViewStackProcessor::GetInstance()->instance = nullptr; 816 } 817 818 /** 819 * @tc.name: ViewAbstractDisableTouchTest 820 * @tc.desc: Test the operation of View_Abstract. 821 * @tc.type: FUNC 822 */ 823 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchTest, TestSize.Level1) 824 { 825 /** 826 * @tc.steps: step1. create framenode and check callback; 827 * @tc.expected: callback is not null. 828 */ 829 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 830 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 831 TouchEventFunc touchEventFunc; 832 ViewAbstract::SetOnTouch(std::move(touchEventFunc)); 833 834 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 835 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 836 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 837 ASSERT_NE(frameNode, nullptr); 838 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 839 ASSERT_NE(node, nullptr); 840 auto gestureHub = node->GetOrCreateGestureEventHub(); 841 auto& callback = gestureHub->touchEventActuator_->userCallback_; 842 EXPECT_NE(callback, nullptr); 843 844 /** 845 * @tc.steps: step2. Disable callback. 846 * @tc.expected: callback is null. 847 */ 848 ViewAbstract::DisableOnTouch(); 849 EXPECT_EQ(callback, nullptr); 850 851 /** 852 * @tc.steps: step3. Add callback again. 853 * @tc.expected: callback is not null. 854 */ 855 TouchEventFunc touchEventFunc2; 856 ViewAbstract::SetOnTouch(std::move(touchEventFunc2)); 857 EXPECT_NE(callback, nullptr); 858 ViewStackProcessor::GetInstance()->instance = nullptr; 859 } 860 861 /** 862 * @tc.name: ViewAbstractDisableMouseTest 863 * @tc.desc: Test the operation of View_Abstract. 864 * @tc.type: FUNC 865 */ 866 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseTest, TestSize.Level1) 867 { 868 /** 869 * @tc.steps: step1. create framenode and check callback; 870 * @tc.expected: callback is not null. 871 */ 872 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 873 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 874 OnMouseEventFunc onMouseEventFunc; 875 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc)); 876 877 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 878 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 879 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 880 ASSERT_NE(frameNode, nullptr); 881 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 882 ASSERT_NE(node, nullptr); 883 auto eventHub = node->GetOrCreateInputEventHub(); 884 auto& callback = eventHub->mouseEventActuator_->userCallback_; 885 EXPECT_NE(callback, nullptr); 886 887 /** 888 * @tc.steps: step2. Disable callback. 889 * @tc.expected: callback is null. 890 */ 891 ViewAbstract::DisableOnMouse(); 892 EXPECT_EQ(callback, nullptr); 893 894 /** 895 * @tc.steps: step3. Add callback again. 896 * @tc.expected: callback is not null. 897 */ 898 OnMouseEventFunc onMouseEventFunc2; 899 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc2)); 900 ViewAbstract::SetJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onMouseEventFunc2)); 901 ViewAbstract::ClearJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER)); 902 EXPECT_NE(callback, nullptr); 903 ViewStackProcessor::GetInstance()->instance = nullptr; 904 } 905 906 /** 907 * @tc.name: ViewAbstractDisableAxis 908 * @tc.desc: Test the operation of View_Abstract. 909 * @tc.type: FUNC 910 */ 911 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableAxisTest, TestSize.Level1) 912 { 913 /** 914 * @tc.steps: step1. create framenode and check callback; 915 * @tc.expected: callback is not null. 916 */ 917 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 918 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 919 OnAxisEventFunc onAxisEventFunc; 920 ViewAbstract::SetOnAxisEvent(std::move(onAxisEventFunc)); 921 922 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 923 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 924 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 925 ASSERT_NE(frameNode, nullptr); 926 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 927 ASSERT_NE(node, nullptr); 928 auto eventHub = node->GetOrCreateInputEventHub(); 929 auto& callback = eventHub->axisEventActuator_->userCallback_; 930 EXPECT_NE(callback, nullptr); 931 932 /** 933 * @tc.steps: step2. Disable callback. 934 * @tc.expected: callback is null. 935 */ 936 ViewAbstract::DisableOnAxisEvent(); 937 EXPECT_EQ(callback, nullptr); 938 939 /** 940 * @tc.steps: step3. Add callback again. 941 * @tc.expected: callback is not null. 942 */ 943 OnAxisEventFunc onAxisEventFunc2; 944 ViewAbstract::SetOnAxisEvent(std::move(onAxisEventFunc2)); 945 EXPECT_NE(callback, nullptr); 946 ViewStackProcessor::GetInstance()->instance = nullptr; 947 } 948 949 /** 950 * @tc.name: ViewAbstractDisableHoverTest 951 * @tc.desc: Test the operation of View_Abstract. 952 * @tc.type: FUNC 953 */ 954 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverTest, TestSize.Level1) 955 { 956 /** 957 * @tc.steps: step1. create framenode and check callback; 958 * @tc.expected: callback is not null. 959 */ 960 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 961 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 962 OnHoverFunc onHoverEventFunc; 963 ViewAbstract::SetOnHover(std::move(onHoverEventFunc)); 964 965 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 966 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 967 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 968 ASSERT_NE(frameNode, nullptr); 969 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 970 ASSERT_NE(node, nullptr); 971 auto eventHub = node->GetOrCreateInputEventHub(); 972 auto& callback = eventHub->hoverEventActuator_->userCallback_; 973 EXPECT_NE(callback, nullptr); 974 975 /** 976 * @tc.steps: step2. Disable callback. 977 * @tc.expected: callback is null. 978 */ 979 ViewAbstract::DisableOnHover(); 980 EXPECT_EQ(callback, nullptr); 981 982 /** 983 * @tc.steps: step3. Add callback again. 984 * @tc.expected: callback is not null. 985 */ 986 OnHoverFunc onHoverEventFunc2; 987 ViewAbstract::SetOnHover(std::move(onHoverEventFunc2)); 988 EXPECT_NE(callback, nullptr); 989 ViewStackProcessor::GetInstance()->instance = nullptr; 990 } 991 992 /** 993 * @tc.name: ViewAbstractDisableKeyTest 994 * @tc.desc: Test the operation of View_Abstract. 995 * @tc.type: FUNC 996 */ 997 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyTest, TestSize.Level1) 998 { 999 /** 1000 * @tc.steps: step1. create framenode and check callback; 1001 * @tc.expected: callback is not null. 1002 */ 1003 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1004 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anond0af9a040402(KeyEventInfo& info) 1005 OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& info) -> bool { return false; }; 1006 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback)); 1007 1008 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1009 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1010 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1011 ASSERT_NE(frameNode, nullptr); 1012 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1013 ASSERT_NE(node, nullptr); 1014 auto focusHub = node->GetOrCreateFocusHub(); 1015 auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_; 1016 EXPECT_TRUE(callback); 1017 1018 /** 1019 * @tc.steps: step2. Disable callback. 1020 * @tc.expected: callback is null. 1021 */ 1022 ViewAbstract::DisableOnKeyEvent(); 1023 EXPECT_FALSE(callback); 1024 1025 /** 1026 * @tc.steps: step3. Add callback again. 1027 * @tc.expected: callback is not null. 1028 */ __anond0af9a040502(KeyEventInfo& info) 1029 OnKeyConsumeFunc onKeyCallback2 = [](KeyEventInfo& info) -> bool { return false; }; 1030 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback2)); 1031 EXPECT_TRUE(callback); 1032 ViewStackProcessor::GetInstance()->instance = nullptr; 1033 } 1034 1035 /** 1036 * @tc.name: ViewAbstractDisableFocusTest 1037 * @tc.desc: Test the operation of View_Abstract. 1038 * @tc.type: FUNC 1039 */ 1040 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusTest, TestSize.Level1) 1041 { 1042 /** 1043 * @tc.steps: step1. create framenode and check callback; 1044 * @tc.expected: callback is not null. 1045 */ 1046 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1047 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anond0af9a040602() 1048 OnFocusFunc onFocusCallback = []() {}; 1049 ViewAbstract::SetOnFocus(std::move(onFocusCallback)); 1050 ViewAbstract::SetOnFocus(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback)); 1051 ViewAbstract::SetJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback)); 1052 ViewAbstract::ClearJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER)); 1053 1054 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1055 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1056 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1057 ASSERT_NE(frameNode, nullptr); 1058 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1059 ASSERT_NE(node, nullptr); 1060 auto focusHub = node->GetOrCreateFocusHub(); 1061 auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_; 1062 EXPECT_NE(callback, nullptr); 1063 1064 /** 1065 * @tc.steps: step2. Disable callback. 1066 * @tc.expected: callback is null. 1067 */ 1068 ViewAbstract::DisableOnFocus(); 1069 EXPECT_EQ(callback, nullptr); 1070 1071 /** 1072 * @tc.steps: step3. Add callback again. 1073 * @tc.expected: callback is not null. 1074 */ __anond0af9a040702() 1075 OnFocusFunc onFocusCallback2 = []() {}; 1076 ViewAbstract::SetOnFocus(std::move(onFocusCallback2)); 1077 EXPECT_NE(callback, nullptr); 1078 ViewStackProcessor::GetInstance()->instance = nullptr; 1079 } 1080 1081 /** 1082 * @tc.name: ViewAbstractDisableBlurTest 1083 * @tc.desc: Test the operation of View_Abstract. 1084 * @tc.type: FUNC 1085 */ 1086 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurTest, TestSize.Level1) 1087 { 1088 /** 1089 * @tc.steps: step1. create framenode and check callback; 1090 * @tc.expected: callback is not null. 1091 */ 1092 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1093 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anond0af9a040802() 1094 OnBlurFunc onBlurCallback = []() {}; 1095 ViewAbstract::SetOnFocus(std::move(onBlurCallback)); 1096 ViewAbstract::SetJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback)); 1097 ViewAbstract::ClearJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER)); 1098 1099 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1100 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1101 auto frameNodeOne = static_cast<FrameNode*>(ViewAbstract::GetFrameNode()); 1102 EXPECT_EQ(strcmp(frameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1103 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1104 ASSERT_NE(frameNode, nullptr); 1105 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1106 ASSERT_NE(node, nullptr); 1107 auto focusHub = node->GetOrCreateFocusHub(); 1108 auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_; 1109 EXPECT_FALSE(callback); 1110 1111 /** 1112 * @tc.steps: step2. Disable callback. 1113 * @tc.expected: callback is null. 1114 */ 1115 ViewAbstract::DisableOnBlur(); 1116 EXPECT_FALSE(callback); 1117 1118 /** 1119 * @tc.steps: step3. Add callback again. 1120 * @tc.expected: callback is not null. 1121 */ __anond0af9a040902() 1122 OnBlurFunc onBlurCallback2 = []() {}; 1123 ViewAbstract::SetOnBlur(std::move(onBlurCallback2)); 1124 ViewAbstract::SetOnBlur(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback2)); 1125 EXPECT_TRUE(callback); 1126 ViewStackProcessor::GetInstance()->instance = nullptr; 1127 } 1128 1129 /** 1130 * @tc.name: ViewAbstractMonopolizeEvent001 1131 * @tc.desc: View_Abstract set MonopolizeEvent true test 1132 * @tc.type: FUNC 1133 */ 1134 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent001, TestSize.Level1) 1135 { 1136 /** 1137 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1138 */ 1139 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1140 1141 /** 1142 * @tc.steps: step2. set monopolize 1143 */ 1144 ViewAbstract::SetMonopolizeEvents(true); 1145 ViewAbstract::SetMonopolizeEvents(AceType::RawPtr(FRAME_NODE_REGISTER), true); 1146 1147 /** 1148 * @tc.steps: step3. get node in ViewStackProcessor. 1149 * @tc.expected: node is not null. 1150 */ 1151 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1152 EXPECT_NE(rootFrameNode, nullptr); 1153 1154 /** 1155 * @tc.steps: step4. get monopolizeEvents value of the node. 1156 * @tc.expected: value is equal to true. 1157 */ 1158 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), true); 1159 1160 /** 1161 * @tc.steps: step5. finish view stack. 1162 */ 1163 ViewStackProcessor::GetInstance()->Finish(); 1164 } 1165 1166 /** 1167 * @tc.name: ViewAbstractMonopolizeEvent002 1168 * @tc.desc: View_Abstract set MonopolizeEvent false test 1169 * @tc.type: FUNC 1170 */ 1171 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent002, TestSize.Level1) 1172 { 1173 /** 1174 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1175 */ 1176 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1177 1178 /** 1179 * @tc.steps: step2. set monopolize 1180 */ 1181 ViewAbstract::SetMonopolizeEvents(false); 1182 1183 /** 1184 * @tc.steps: step3. get node in ViewStackProcessor. 1185 * @tc.expected: node is not null. 1186 */ 1187 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1188 EXPECT_NE(rootFrameNode, nullptr); 1189 1190 /** 1191 * @tc.steps: step4. get monopolizeEvents value of the node. 1192 * @tc.expected: value is equal to true. 1193 */ 1194 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false); 1195 1196 /** 1197 * @tc.steps: step5. finish view stack. 1198 */ 1199 ViewStackProcessor::GetInstance()->Finish(); 1200 } 1201 1202 /** 1203 * @tc.name: ViewAbstractMonopolizeEvent003 1204 * @tc.desc: View_Abstract not set MonopolizeEvent test (use default) 1205 * @tc.type: FUNC 1206 */ 1207 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent003, TestSize.Level1) 1208 { 1209 /** 1210 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1211 */ 1212 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1213 1214 /** 1215 * @tc.steps: step2. get node in ViewStackProcessor. 1216 * @tc.expected: node is not null. 1217 */ 1218 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1219 EXPECT_NE(rootFrameNode, nullptr); 1220 1221 /** 1222 * @tc.steps: step3. get monopolizeEvents value of the node. 1223 * @tc.expected: value is equal to true. 1224 */ 1225 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false); 1226 1227 /** 1228 * @tc.steps: step5. finish view stack. 1229 */ 1230 ViewStackProcessor::GetInstance()->Finish(); 1231 } 1232 1233 /** 1234 * @tc.name: ViewAbstractMenuTransition001 1235 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use dafault) 1236 * @tc.type: FUNC 1237 */ 1238 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition001, TestSize.Level1) 1239 { 1240 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1241 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1242 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1243 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1244 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1245 const RefPtr<FrameNode> mainNode = 1246 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1247 ViewStackProcessor::GetInstance()->Push(mainNode); 1248 auto container = Container::Current(); 1249 ASSERT_NE(container, nullptr); 1250 auto pipelineContext = container->GetPipelineContext(); 1251 ASSERT_NE(pipelineContext, nullptr); 1252 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1253 ASSERT_NE(context, nullptr); 1254 auto overlayManager = context->GetOverlayManager(); 1255 ASSERT_NE(overlayManager, nullptr); 1256 1257 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anond0af9a040a02() 1258 std::function<void()> flagFunc = []() { flag++; }; 1259 std::vector<NG::OptionParam> params = {}; 1260 std::function<void()> buildFunc; 1261 MenuParam menuParam; 1262 std::function<void()> previewBuildFunc = nullptr; 1263 1264 menuParam.type = MenuType::MENU; 1265 menuParam.isShow = true; 1266 1267 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1268 ASSERT_NE(targetNode, nullptr); __anond0af9a040b02null1269 std::function<void()> action = [] {}; 1270 params.emplace_back("MenuItem1", "", action); 1271 params.emplace_back("MenuItem2", "", action); 1272 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1273 auto targetId = targetNode->GetId(); 1274 1275 auto menu = 1276 FrameNode::CreateFrameNode("targetNode", targetId, AceType::MakeRefPtr<MenuWrapperPattern>(targetId), false); 1277 overlayManager->menuMap_[targetId] = menu; 1278 auto menuNode = overlayManager->GetMenuNode(targetId); 1279 ASSERT_NE(menuNode, nullptr); 1280 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1281 ASSERT_NE(wrapperPattern, nullptr); 1282 EXPECT_EQ(wrapperPattern->HasTransitionEffect(), false); 1283 EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), false); 1284 } 1285 1286 /** 1287 * @tc.name: ViewAbstractMenuTransition002 1288 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true) 1289 * @tc.type: FUNC 1290 */ 1291 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition002, TestSize.Level1) 1292 { 1293 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1294 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1295 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1296 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1297 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1298 const RefPtr<FrameNode> mainNode = 1299 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1300 ViewStackProcessor::GetInstance()->Push(mainNode); 1301 auto container = Container::Current(); 1302 ASSERT_NE(container, nullptr); 1303 auto pipelineContext = container->GetPipelineContext(); 1304 ASSERT_NE(pipelineContext, nullptr); 1305 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1306 ASSERT_NE(context, nullptr); 1307 auto overlayManager = context->GetOverlayManager(); 1308 ASSERT_NE(overlayManager, nullptr); 1309 1310 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anond0af9a040c02() 1311 std::function<void()> flagFunc = []() { flag++; }; 1312 std::vector<NG::OptionParam> params = {}; 1313 std::function<void()> buildFunc; 1314 MenuParam menuParam; 1315 std::function<void()> previewBuildFunc = nullptr; 1316 1317 NG::RotateOptions rotate(0.0f, 0.0f, 0.0f, 0.0f, 0.5_pct, 0.5_pct); 1318 1319 menuParam.hasTransitionEffect = true; 1320 menuParam.hasPreviewTransitionEffect = true; 1321 menuParam.transition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate); 1322 menuParam.previewTransition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate); 1323 menuParam.type = MenuType::MENU; 1324 menuParam.isShow = true; 1325 1326 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1327 ASSERT_NE(targetNode, nullptr); __anond0af9a040d02null1328 std::function<void()> action = [] {}; 1329 params.emplace_back("MenuItem1", "", action); 1330 params.emplace_back("MenuItem2", "", action); 1331 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1332 auto targetId = targetNode->GetId(); 1333 1334 auto menu = 1335 FrameNode::CreateFrameNode("targetNode", targetId, AceType::MakeRefPtr<MenuWrapperPattern>(targetId), false); 1336 overlayManager->menuMap_[targetId] = menu; 1337 auto menuNode = overlayManager->GetMenuNode(targetId); 1338 ASSERT_NE(menuNode, nullptr); 1339 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1340 ASSERT_NE(wrapperPattern, nullptr); 1341 EXPECT_EQ(wrapperPattern->HasTransitionEffect(), false); 1342 EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), false); 1343 } 1344 1345 /** 1346 * @tc.name: ViewAbstractMenuBorderRadius001 1347 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true) 1348 * @tc.type: FUNC 1349 */ 1350 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuBorderRadius001, TestSize.Level1) 1351 { 1352 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1353 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1354 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1355 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1356 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1357 const RefPtr<FrameNode> mainNode = 1358 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1359 ViewStackProcessor::GetInstance()->Push(mainNode); 1360 auto container = Container::Current(); 1361 ASSERT_NE(container, nullptr); 1362 auto pipelineContext = container->GetPipelineContext(); 1363 ASSERT_NE(pipelineContext, nullptr); 1364 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1365 ASSERT_NE(context, nullptr); 1366 auto overlayManager = context->GetOverlayManager(); 1367 ASSERT_NE(overlayManager, nullptr); 1368 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); 1369 std::vector<NG::OptionParam> params = {}; 1370 std::function<void()> buildFunc; 1371 MenuParam menuParam; 1372 1373 menuParam.type = MenuType::MENU; 1374 menuParam.isShow = true; 1375 BorderRadiusProperty borderRadius; 1376 borderRadius.SetRadius(Dimension(16)); 1377 menuParam.borderRadius = borderRadius; 1378 1379 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1380 ASSERT_NE(targetNode, nullptr); __anond0af9a040e02null1381 std::function<void()> action = [] {}; 1382 params.emplace_back("MenuItem1", "", action); 1383 params.emplace_back("MenuItem2", "", action); 1384 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1385 auto targetId = targetNode->GetId(); 1386 1387 auto menu = 1388 FrameNode::CreateFrameNode("targetNode", targetId, AceType::MakeRefPtr<MenuWrapperPattern>(targetId), false); 1389 overlayManager->menuMap_[targetId] = menu; 1390 auto menuNode = overlayManager->GetMenuNode(targetId); 1391 ASSERT_NE(menuNode, nullptr); 1392 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1393 ASSERT_NE(wrapperPattern, nullptr); 1394 EXPECT_EQ(wrapperPattern->GetHasCustomRadius(), false); 1395 } 1396 1397 /** 1398 * @tc.name: ViewAbstractDisableClickByFrameNodeTest 1399 * @tc.desc: Test the operation of View_Abstract. 1400 * @tc.type: FUNC 1401 */ 1402 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickByFrameNodeTest, TestSize.Level1) 1403 { 1404 /** 1405 * @tc.steps: step1. create framenode and check callback; 1406 * @tc.expected: callback is not null. 1407 */ 1408 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1409 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1410 1411 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1412 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1413 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1414 ASSERT_NE(frameNode, nullptr); 1415 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1416 ASSERT_NE(node, nullptr); 1417 GestureEventFunc tapEventFunc; 1418 ViewAbstract::SetOnClick(AceType::RawPtr(node), std::move(tapEventFunc)); 1419 auto gestureHub = node->GetOrCreateGestureEventHub(); 1420 auto& callback = gestureHub->clickEventActuator_->userCallback_; 1421 EXPECT_NE(callback, nullptr); 1422 1423 /** 1424 * @tc.steps: step2. Disable callback. 1425 * @tc.expected: callback is null. 1426 */ 1427 ViewAbstract::DisableOnClick(AceType::RawPtr(node)); 1428 EXPECT_EQ(callback, nullptr); 1429 } 1430 1431 /** 1432 * @tc.name: ViewAbstractDisableTouchByFrameNodeTest 1433 * @tc.desc: Test the operation of View_Abstract. 1434 * @tc.type: FUNC 1435 */ 1436 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchByFrameNodeTest, TestSize.Level1) 1437 { 1438 /** 1439 * @tc.steps: step1. create framenode and check callback; 1440 * @tc.expected: callback is not null. 1441 */ 1442 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1443 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1444 1445 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1446 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1447 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1448 ASSERT_NE(frameNode, nullptr); 1449 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1450 ASSERT_NE(node, nullptr); 1451 TouchEventFunc touchEventFunc; 1452 ViewAbstract::SetOnTouch(AceType::RawPtr(node), std::move(touchEventFunc)); 1453 auto gestureHub = node->GetOrCreateGestureEventHub(); 1454 auto& callback = gestureHub->touchEventActuator_->userCallback_; 1455 EXPECT_NE(callback, nullptr); 1456 1457 /** 1458 * @tc.steps: step2. Disable callback. 1459 * @tc.expected: callback is null. 1460 */ 1461 ViewAbstract::DisableOnTouch(AceType::RawPtr(node)); 1462 EXPECT_EQ(callback, nullptr); 1463 } 1464 1465 /** 1466 * @tc.name: ViewAbstractDisableMouseByFrameNodeTest 1467 * @tc.desc: Test the operation of View_Abstract. 1468 * @tc.type: FUNC 1469 */ 1470 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseByFrameNodeTest, TestSize.Level1) 1471 { 1472 /** 1473 * @tc.steps: step1. create framenode and check callback; 1474 * @tc.expected: callback is not null. 1475 */ 1476 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1477 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1478 1479 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1480 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1481 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1482 ASSERT_NE(frameNode, nullptr); 1483 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1484 ASSERT_NE(node, nullptr); 1485 OnMouseEventFunc onMouseEventFunc; 1486 ViewAbstract::SetOnMouse(AceType::RawPtr(node), std::move(onMouseEventFunc)); 1487 auto eventHub = node->GetOrCreateInputEventHub(); 1488 auto& callback = eventHub->mouseEventActuator_->userCallback_; 1489 EXPECT_NE(callback, nullptr); 1490 1491 /** 1492 * @tc.steps: step2. Disable callback. 1493 * @tc.expected: callback is null. 1494 */ 1495 ViewAbstract::DisableOnMouse(AceType::RawPtr(node)); 1496 EXPECT_EQ(callback, nullptr); 1497 } 1498 1499 /** 1500 * @tc.name: ViewAbstractDisableAxisByFrameNodeTest 1501 * @tc.desc: Test the operation of View_Abstract. 1502 * @tc.type: FUNC 1503 */ 1504 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableAxisByFrameNodeTest, TestSize.Level1) 1505 { 1506 /** 1507 * @tc.steps: step1. create framenode and check callback; 1508 * @tc.expected: callback is not null. 1509 */ 1510 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1511 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1512 1513 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1514 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1515 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1516 ASSERT_NE(frameNode, nullptr); 1517 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1518 ASSERT_NE(node, nullptr); 1519 OnAxisEventFunc onAxisEventFunc; 1520 ViewAbstract::SetOnAxisEvent(AceType::RawPtr(node), std::move(onAxisEventFunc)); 1521 auto eventHub = node->GetOrCreateInputEventHub(); 1522 auto& callback = eventHub->axisEventActuator_->userCallback_; 1523 EXPECT_NE(callback, nullptr); 1524 1525 /** 1526 * @tc.steps: step2. Disable callback. 1527 * @tc.expected: callback is null. 1528 */ 1529 ViewAbstract::DisableOnAxisEvent(AceType::RawPtr(node)); 1530 EXPECT_EQ(callback, nullptr); 1531 } 1532 1533 /** 1534 * @tc.name: ViewAbstractDisableHoverByFrameNodeTest 1535 * @tc.desc: Test the operation of View_Abstract. 1536 * @tc.type: FUNC 1537 */ 1538 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverByFrameNodeTest, TestSize.Level1) 1539 { 1540 /** 1541 * @tc.steps: step1. create framenode and check callback; 1542 * @tc.expected: callback is not null. 1543 */ 1544 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1545 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1546 1547 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1548 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1549 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1550 ASSERT_NE(frameNode, nullptr); 1551 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1552 ASSERT_NE(node, nullptr); 1553 OnHoverFunc onHoverEventFunc; 1554 ViewAbstract::SetOnHover(AceType::RawPtr(node), std::move(onHoverEventFunc)); 1555 auto eventHub = node->GetOrCreateInputEventHub(); 1556 auto& callback = eventHub->hoverEventActuator_->userCallback_; 1557 EXPECT_NE(callback, nullptr); 1558 1559 /** 1560 * @tc.steps: step2. Disable callback. 1561 * @tc.expected: callback is null. 1562 */ 1563 ViewAbstract::DisableOnHover(AceType::RawPtr(node)); 1564 EXPECT_EQ(callback, nullptr); 1565 } 1566 1567 /** 1568 * @tc.name: ViewAbstractDisableKeyByFrameNodeTest 1569 * @tc.desc: Test the operation of View_Abstract. 1570 * @tc.type: FUNC 1571 */ 1572 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyByFrameNodeTest, TestSize.Level1) 1573 { 1574 /** 1575 * @tc.steps: step1. create framenode and check callback; 1576 * @tc.expected: callback is not null. 1577 */ 1578 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1579 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1580 1581 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1582 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1583 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1584 ASSERT_NE(frameNode, nullptr); 1585 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1586 ASSERT_NE(node, nullptr); __anond0af9a040f02(KeyEventInfo& info) 1587 OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& info) -> bool { return false; }; 1588 ViewAbstract::SetOnKeyEvent(AceType::RawPtr(node), std::move(onKeyCallback)); 1589 auto focusHub = node->GetOrCreateFocusHub(); 1590 auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_; 1591 EXPECT_TRUE(callback); 1592 1593 /** 1594 * @tc.steps: step2. Disable callback. 1595 * @tc.expected: callback is null. 1596 */ 1597 ViewAbstract::DisableOnKeyEvent(AceType::RawPtr(node)); 1598 EXPECT_FALSE(callback); 1599 } 1600 1601 /** 1602 * @tc.name: ViewAbstractDisableFocusByFrameNodeTest 1603 * @tc.desc: Test the operation of View_Abstract. 1604 * @tc.type: FUNC 1605 */ 1606 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusByFrameNodeTest, TestSize.Level1) 1607 { 1608 /** 1609 * @tc.steps: step1. create framenode and check callback; 1610 * @tc.expected: callback is not null. 1611 */ 1612 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1613 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1614 1615 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1616 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1617 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1618 ASSERT_NE(frameNode, nullptr); 1619 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1620 ASSERT_NE(node, nullptr); __anond0af9a041002() 1621 OnFocusFunc onFocusCallback = []() {}; 1622 ViewAbstract::SetOnFocus(AceType::RawPtr(node), std::move(onFocusCallback)); 1623 auto focusHub = node->GetOrCreateFocusHub(); 1624 auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_; 1625 EXPECT_NE(callback, nullptr); 1626 1627 /** 1628 * @tc.steps: step2. Disable callback. 1629 * @tc.expected: callback is null. 1630 */ 1631 ViewAbstract::DisableOnFocus(AceType::RawPtr(node)); 1632 EXPECT_EQ(callback, nullptr); 1633 } 1634 1635 /** 1636 * @tc.name: ViewAbstractDisableBlurByFrameNodeTest 1637 * @tc.desc: Test the operation of View_Abstract. 1638 * @tc.type: FUNC 1639 */ 1640 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurByFrameNodeTest, TestSize.Level1) 1641 { 1642 /** 1643 * @tc.steps: step1. create framenode and check callback; 1644 * @tc.expected: callback is not null. 1645 */ 1646 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1647 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1648 1649 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1650 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1651 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1652 ASSERT_NE(frameNode, nullptr); 1653 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1654 ASSERT_NE(node, nullptr); __anond0af9a041102() 1655 OnBlurFunc onBlurCallback = []() {}; 1656 ViewAbstract::SetOnBlur(AceType::RawPtr(node), std::move(onBlurCallback)); 1657 auto focusHub = node->GetOrCreateFocusHub(); 1658 auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_; 1659 EXPECT_TRUE(callback); 1660 1661 /** 1662 * @tc.steps: step2. Disable callback. 1663 * @tc.expected: callback is null. 1664 */ 1665 ViewAbstract::DisableOnBlur(AceType::RawPtr(node)); 1666 EXPECT_FALSE(callback); 1667 } 1668 1669 /** 1670 * @tc.name: ViewAbstractDisableOnAppearByFrameNodeTest 1671 * @tc.desc: Test the operation of View_Abstract. 1672 * @tc.type: FUNC 1673 */ 1674 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAppearByFrameNodeTest, TestSize.Level1) 1675 { 1676 /** 1677 * @tc.steps: step1. create framenode and check callback; 1678 * @tc.expected: callback is not null. 1679 */ 1680 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1681 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1682 1683 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1684 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1685 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1686 ASSERT_NE(frameNode, nullptr); 1687 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1688 ASSERT_NE(node, nullptr); __anond0af9a041202() 1689 std::function<void()> onAppearCallback = []() {}; 1690 ViewAbstract::SetOnAppear(AceType::RawPtr(node), std::move(onAppearCallback)); 1691 auto eventHub = node->GetOrCreateEventHub<EventHub>(); 1692 auto& callback = eventHub->onAppear_; 1693 EXPECT_NE(callback, nullptr); 1694 1695 /** 1696 * @tc.steps: step2. Disable callback. 1697 * @tc.expected: callback is null. 1698 */ 1699 ViewAbstract::DisableOnAppear(AceType::RawPtr(node)); 1700 EXPECT_EQ(callback, nullptr); 1701 } 1702 1703 /** 1704 * @tc.name: ViewAbstractDisableOnDisAppearByFrameNodeTest 1705 * @tc.desc: Test the operation of View_Abstract. 1706 * @tc.type: FUNC 1707 */ 1708 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnDisAppearByFrameNodeTest, TestSize.Level1) 1709 { 1710 /** 1711 * @tc.steps: step1. create framenode and check callback; 1712 * @tc.expected: callback is not null. 1713 */ 1714 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1715 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1716 1717 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1718 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1719 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1720 ASSERT_NE(frameNode, nullptr); 1721 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1722 ASSERT_NE(node, nullptr); __anond0af9a041302() 1723 std::function<void()> onDiaAppearCallback = []() {}; 1724 ViewAbstract::SetOnDisappear(AceType::RawPtr(node), std::move(onDiaAppearCallback)); 1725 auto eventHub = node->GetOrCreateEventHub<EventHub>(); 1726 auto& callback = eventHub->onDisappear_; 1727 EXPECT_NE(callback, nullptr); 1728 1729 /** 1730 * @tc.steps: step2. Disable callback. 1731 * @tc.expected: callback is null. 1732 */ 1733 ViewAbstract::DisableOnDisappear(AceType::RawPtr(node)); 1734 EXPECT_EQ(callback, nullptr); 1735 } 1736 1737 /** 1738 * @tc.name: ViewAbstractDisableOnAreaChangeByFrameNodeTest 1739 * @tc.desc: Test the operation of View_Abstract. 1740 * @tc.type: FUNC 1741 */ 1742 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAreaChangeByFrameNodeTest, TestSize.Level1) 1743 { 1744 /** 1745 * @tc.steps: step1. create framenode and check callback; 1746 * @tc.expected: callback is not null. 1747 */ 1748 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1749 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1750 1751 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1752 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1753 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1754 ASSERT_NE(frameNode, nullptr); 1755 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1756 ASSERT_NE(node, nullptr); 1757 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)> 1758 onAreaChangeCallback = __anond0af9a041402(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1759 [](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {}; 1760 ViewAbstract::SetOnAreaChanged(AceType::RawPtr(node), std::move(onAreaChangeCallback)); 1761 auto eventHub = node->GetOrCreateEventHub<EventHub>(); 1762 auto& callback = eventHub->onAreaChanged_; 1763 EXPECT_NE(callback, nullptr); 1764 1765 /** 1766 * @tc.steps: step2. Disable callback. 1767 * @tc.expected: callback is null. 1768 */ 1769 ViewAbstract::DisableOnAreaChange(AceType::RawPtr(node)); 1770 EXPECT_EQ(callback, nullptr); 1771 } 1772 1773 /** 1774 * @tc.name: ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest 1775 * @tc.desc: Test the operation of View_Abstract. 1776 * @tc.type: FUNC 1777 */ 1778 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest, TestSize.Level1) 1779 { 1780 /** 1781 * @tc.steps: step1. create framenode and check callback; 1782 * @tc.expected: callback is not null. 1783 */ 1784 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1785 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1786 1787 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1788 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1789 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1790 ASSERT_NE(frameNode, nullptr); 1791 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1792 ASSERT_NE(node, nullptr); 1793 GestureJudgeFunc onGestureJudgeCallback = [](const RefPtr<GestureInfo>& gestureInfo, __anond0af9a041502(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1794 const std::shared_ptr<BaseGestureEvent>& info) { 1795 return GestureJudgeResult::REJECT; 1796 }; 1797 ViewAbstract::SetOnGestureJudgeBegin(AceType::RawPtr(node), std::move(onGestureJudgeCallback)); 1798 auto gestureHub = node->GetOrCreateGestureEventHub(); 1799 auto& callback = gestureHub->gestureJudgeFunc_; 1800 EXPECT_NE(callback, nullptr); 1801 } 1802 1803 /** 1804 * @tc.name: ViewAbstractSetOnSizeChangeByFrameNodeTest 1805 * @tc.desc: Test the operation of View_Abstract. 1806 * @tc.type: FUNC 1807 */ 1808 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnSizeChangeByFrameNodeTest, TestSize.Level1) 1809 { 1810 /** 1811 * @tc.steps: step1. create framenode and check callback; 1812 * @tc.expected: callback is not null. 1813 */ 1814 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1815 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1816 1817 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1818 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1819 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1820 ASSERT_NE(frameNode, nullptr); 1821 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1822 ASSERT_NE(node, nullptr); 1823 std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChangeCallback = [](const RectF& oldRect, __anond0af9a041602(const RectF& oldRect, const RectF& rect) 1824 const RectF& rect) {}; 1825 ViewAbstract::SetOnSizeChanged(AceType::RawPtr(node), std::move(onSizeChangeCallback)); 1826 auto eventHub = node->GetOrCreateEventHub<EventHub>(); 1827 auto& callback = eventHub->onSizeChanged_; 1828 EXPECT_NE(callback, nullptr); 1829 } 1830 1831 /** 1832 * @tc.name: MotionBlur001 1833 * @tc.desc: SetMotionBlur. 1834 * @tc.type: FUNC 1835 */ 1836 HWTEST_F(ViewAbstractTestNg, MotionBlur001, TestSize.Level1) 1837 { 1838 /** 1839 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1840 */ 1841 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1842 1843 /** 1844 * @tc.steps: step2. get node in ViewStackProcessor. 1845 * @tc.expected: node is not null. 1846 */ 1847 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1848 EXPECT_NE(rootFrameNode, nullptr); 1849 1850 /** 1851 * @tc.steps: step3. use ViewAbstract::SetMotionBlur. 1852 * @tc.expected: success set render property motionBlur value. 1853 */ 1854 MotionBlurOption motionBlurOption; 1855 motionBlurOption.radius = 5; 1856 motionBlurOption.anchor.x = 0.5; 1857 motionBlurOption.anchor.y = 0.5; 1858 ViewAbstract::SetMotionBlur(motionBlurOption); 1859 /** 1860 * @tc.steps: step4. get propMotionBlur value of the node. 1861 * @tc.expected: anchor.x = 0.5, anchor.y = 0.5, radius = 5. 1862 */ 1863 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 1864 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1865 ->GetOrCreateForeground()->propMotionBlur->anchor.x, 0.5); 1866 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1867 ->GetOrCreateForeground()->propMotionBlur->anchor.y, 0.5); 1868 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1869 ->GetOrCreateForeground()->propMotionBlur->radius, 5); 1870 1871 /** 1872 * @tc.steps: step5. finish view stack. 1873 */ 1874 ViewStackProcessor::GetInstance()->Finish(); 1875 } 1876 1877 /** 1878 * @tc.name: SetForegroundEffectTest 1879 * @tc.desc: Test the operation of setting foreground effect with different conditions. 1880 * @tc.type: FUNC 1881 */ 1882 HWTEST_F(ViewAbstractTestNg, SetForegroundEffectTest, TestSize.Level1) 1883 { 1884 /** 1885 * @tc.steps: Build a object viewAbstract and set visual state. 1886 */ 1887 ViewStackProcessor viewStackProcessor; 1888 int32_t index = 1; 1889 auto state = static_cast<VisualState>(index); 1890 viewStackProcessor.GetInstance()->SetVisualState(state); 1891 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1892 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1893 ASSERT_NE(frameNode, nullptr); 1894 1895 /** 1896 * @tc.steps: Build a object viewAbstract and set visual state. 1897 * @tc.expected: The foreground effect is not changed. 1898 */ 1899 auto originValue = frameNode->GetRenderContext()->GetForegroundEffect(); 1900 ViewAbstract::SetForegroundEffect(1.1f); 1901 ASSERT_NE(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f); 1902 ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), originValue); 1903 1904 /** 1905 * @tc.steps: Set visual state to null and check the current visual state process 1906 * @tc.expected: The foreground effect is changed as expected. 1907 */ 1908 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 1909 ViewAbstract::SetForegroundEffect(1.1f); 1910 ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f); 1911 } 1912 1913 /** 1914 * @tc.name: ViewAbstractTest045 1915 * @tc.desc: Test SetNeedFocus of View_Abstract 1916 * @tc.type: FUNC 1917 */ 1918 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest045, TestSize.Level1) 1919 { 1920 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, 1921 AceType::MakeRefPtr<Pattern>()); 1922 frameNode->GetOrCreateFocusHub(); 1923 1924 RefPtr<EventHub> eventHub = AceType::MakeRefPtr<EventHub>(); 1925 eventHub->AttachHost(frameNode); 1926 auto focusHub = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1927 focusHub->currentFocus_ = true; 1928 1929 /** 1930 * @tc.steps: Set frameNode attached context null 1931 * @tc.expected: do not set scop instanceId and excute lost focus to view root. 1932 */ 1933 frameNode->DetachContext(true); 1934 ViewAbstract::SetNeedFocus(AceType::RawPtr(frameNode), false); 1935 EXPECT_EQ(ContainerScope::CurrentId(), -1); 1936 } 1937 1938 /** 1939 * @tc.name: RemoveResObj 1940 * @tc.desc: Test RemoveResObj of View_Abstract 1941 * @tc.type: FUNC 1942 */ 1943 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest046, TestSize.Level1) 1944 { 1945 auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1946 ASSERT_NE(frameNode, nullptr); 1947 auto pattern = frameNode->GetPattern<Pattern>(); 1948 ASSERT_NE(pattern, nullptr); 1949 g_isConfigChangePerform = true; 1950 std::string key = "clipShape"; 1951 ViewAbstractModelNG::RemoveResObj(frameNode, key); 1952 g_isConfigChangePerform = false; 1953 ViewAbstractModelNG::RemoveResObj(frameNode, key); 1954 } 1955 1956 /** 1957 * @tc.name: ViewAbstractDisableOnKeyEventDispatchTest 1958 * @tc.desc: Test the operation of View_Abstract. 1959 * @tc.type: FUNC 1960 */ 1961 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnKeyEventDispatchTest, TestSize.Level1) 1962 { 1963 /** 1964 * @tc.steps: step1. create framenode and check callback; 1965 * @tc.expected: callback is not null. 1966 */ 1967 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1968 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anond0af9a041702(KeyEventInfo& info) 1969 OnKeyConsumeFunc onKeyCallback = [](KeyEventInfo& info) -> bool { return false; }; 1970 ViewAbstract::SetOnKeyEventDispatch(std::move(onKeyCallback)); 1971 1972 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1973 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1974 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1975 ASSERT_NE(frameNode, nullptr); 1976 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1977 ASSERT_NE(node, nullptr); 1978 auto focusHub = node->GetOrCreateFocusHub(); 1979 auto& callback = focusHub->focusCallbackEvents_->onKeyEventDispatchCallback_; 1980 EXPECT_TRUE(callback); 1981 1982 /** 1983 * @tc.steps: step2. Disable callback. 1984 * @tc.expected: callback is null. 1985 */ 1986 ViewAbstract::DisableOnKeyEventDispatch(); 1987 EXPECT_FALSE(callback); 1988 1989 /** 1990 * @tc.steps: step3. Add callback again. 1991 * @tc.expected: callback is not null. 1992 */ __anond0af9a041802(KeyEventInfo& info) 1993 OnKeyConsumeFunc onKeyCallback2 = [](KeyEventInfo& info) -> bool { return false; }; 1994 ViewAbstract::SetOnKeyEventDispatch(std::move(onKeyCallback2)); 1995 EXPECT_TRUE(callback); 1996 ViewStackProcessor::GetInstance()->instance = nullptr; 1997 } 1998 1999 /** 2000 * @tc.name: DispatchKeyEvent001 2001 * @tc.desc: Test DispatchKeyEvent 2002 * @tc.type: FUNC 2003 */ 2004 HWTEST_F(ViewAbstractTestNg, DispatchKeyEvent001, TestSize.Level1) 2005 { 2006 /** 2007 * @tc.steps: step1. Create frameNode. 2008 */ 2009 std::string tag = "uiNode1"; 2010 int32_t nodeId = 1; 2011 FrameNode frameNode(tag, nodeId, AceType::MakeRefPtr<Pattern>()); 2012 int32_t repeatTime = 0; 2013 int64_t timeStamp = 0; 2014 int64_t deviceId = 0; 2015 2016 /** 2017 * @tc.steps: step2. Create keyEvent. 2018 */ 2019 KeyEvent keyEvent(KeyCode::KEY_UNKNOWN, KeyAction::UNKNOWN, repeatTime, timeStamp, deviceId, SourceType::KEYBOARD); 2020 ViewAbstract::DispatchKeyEvent(&frameNode, keyEvent); 2021 EXPECT_NE(&frameNode, nullptr); 2022 } 2023 2024 #ifdef SUPPORT_DIGITAL_CROWN 2025 /** 2026 * @tc.name: ViewAbstract 2027 * @tc.desc: Test DisableOnCrownEvent001 of View_Abstract 2028 * @tc.type: FUNC 2029 */ 2030 HWTEST_F(ViewAbstractTestNg, DisableOnCrownEvent001, TestSize.Level1) 2031 { 2032 /** 2033 * @tc.steps1: create and put frameNode 2034 * @tc.expected: frameNode is't nullptr. 2035 */ 2036 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 2037 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 2038 ASSERT_NE(frameNode, nullptr); 2039 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 2040 ASSERT_NE(node, nullptr); 2041 2042 /** 2043 * @tc.steps2: Call the function SetOnCrownEvent and DisableOnCrownEvent 2044 */ __anond0af9a041902(CrownEventInfo& info) 2045 OnCrownCallbackFunc onCrownCallback = [](CrownEventInfo& info) {}; 2046 ViewAbstract::SetOnCrownEvent(AceType::RawPtr(node), std::move(onCrownCallback)); 2047 ViewAbstract::DisableOnCrownEvent(AceType::RawPtr(node)); 2048 EXPECT_NE(onCrownCallback, nullptr); 2049 } 2050 2051 /** 2052 * @tc.name: ViewAbstract 2053 * @tc.desc: Test DisableOnCrownEvent002 of View_Abstract 2054 * @tc.type: FUNC 2055 */ 2056 HWTEST_F(ViewAbstractTestNg, DisableOnCrownEvent002, TestSize.Level1) 2057 { 2058 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, 2059 AceType::MakeRefPtr<Pattern>()); 2060 frameNode->GetOrCreateFocusHub(); 2061 2062 auto eventHub = AceType::MakeRefPtr<EventHub>(); 2063 eventHub->AttachHost(frameNode); 2064 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub); 2065 focusHub->currentFocus_ = true; 2066 2067 /** 2068 * @tc.steps: Call the function SetOnCrownEvent and DisableOnCrownEvent 2069 */ __anond0af9a041a02(CrownEventInfo& info) 2070 OnCrownCallbackFunc onCrownCallback = [](CrownEventInfo& info) {}; 2071 ViewAbstract::SetOnCrownEvent(std::move(onCrownCallback)); 2072 ViewAbstract::DisableOnCrownEvent(); 2073 EXPECT_EQ(ContainerScope::CurrentId(), -1); 2074 } 2075 2076 /** 2077 * @tc.name: ViewAbstract 2078 * @tc.desc: Test DisableOnCrownEvent003 of View_Abstract 2079 * @tc.type: FUNC 2080 */ 2081 HWTEST_F(ViewAbstractTestNg, DisableOnCrownEvent003, TestSize.Level1) 2082 { 2083 /** 2084 * @tc.steps: Call the function SetOnCrownEvent, node is nullptr 2085 */ 2086 auto node = AceType::DynamicCast<NG::FrameNode>((AceType*)nullptr); __anond0af9a041b02(CrownEventInfo& info) 2087 OnCrownCallbackFunc onCrownCallback = [](CrownEventInfo& info) {}; 2088 2089 ViewAbstract::SetOnCrownEvent(node, std::move(onCrownCallback)); 2090 EXPECT_NE(onCrownCallback, nullptr); 2091 } 2092 #endif 2093 2094 /** 2095 * @tc.name: CheckLocalizedMarginOrPadding001 2096 * @tc.desc: Test CheckLocalizedMarginOrPadding when start,top,bottom,left have values 2097 * @tc.type: FUNC 2098 */ 2099 HWTEST_F(ViewAbstractTestNg, CheckLocalizedMarginOrPadding001, TestSize.Level1) 2100 { 2101 PaddingProperty paddingProperty; 2102 paddingProperty.start = std::make_optional<CalcLength>(5.0); 2103 paddingProperty.top = std::make_optional<CalcLength>(6.0); 2104 paddingProperty.bottom = std::make_optional<CalcLength>(7.0); 2105 paddingProperty.left = std::make_optional<CalcLength>(8.0); 2106 2107 auto textDirection = TextDirection::LTR; 2108 ViewAbstract::CheckLocalizedMarginOrPadding(paddingProperty, textDirection); 2109 EXPECT_EQ(paddingProperty.left.value(), CalcLength(5.0)); 2110 2111 textDirection = TextDirection::RTL; 2112 ViewAbstract::CheckLocalizedMarginOrPadding(paddingProperty, textDirection); 2113 EXPECT_EQ(paddingProperty.right.value(), CalcLength(5.0)); 2114 } 2115 2116 /** 2117 * @tc.name: CheckLocalizedMarginOrPadding002 2118 * @tc.desc: Test CheckLocalizedMarginOrPadding when end,right have values 2119 * @tc.type: FUNC 2120 */ 2121 HWTEST_F(ViewAbstractTestNg, CheckLocalizedMarginOrPadding002, TestSize.Level1) 2122 { 2123 PaddingProperty paddingProperty; 2124 paddingProperty.end = std::make_optional<CalcLength>(5.0); 2125 paddingProperty.right = std::make_optional<CalcLength>(6.0); 2126 2127 auto textDirection = TextDirection::LTR; 2128 ViewAbstract::CheckLocalizedMarginOrPadding(paddingProperty, textDirection); 2129 EXPECT_EQ(paddingProperty.right.value(), CalcLength(5.0)); 2130 2131 textDirection = TextDirection::RTL; 2132 ViewAbstract::CheckLocalizedMarginOrPadding(paddingProperty, textDirection); 2133 EXPECT_EQ(paddingProperty.left.value(), CalcLength(5.0)); 2134 } 2135 2136 /** 2137 * @tc.name: CheckLocalizedMarginOrPadding003 2138 * @tc.desc: Test CheckLocalizedMarginOrPadding When neither start nor end has a value 2139 * @tc.type: FUNC 2140 */ 2141 HWTEST_F(ViewAbstractTestNg, CheckLocalizedMarginOrPadding003, TestSize.Level1) 2142 { 2143 PaddingProperty paddingProperty; 2144 2145 auto textDirection = TextDirection::LTR; 2146 ViewAbstract::CheckLocalizedMarginOrPadding(paddingProperty, textDirection); 2147 EXPECT_FALSE(paddingProperty.right.has_value()); 2148 EXPECT_FALSE(paddingProperty.left.has_value()); 2149 } 2150 2151 /** 2152 * @tc.name: CheckPositionOrOffsetLocalizedEdges001 2153 * @tc.desc: Test CheckPositionOrOffsetLocalizedEdges 2154 * @tc.type: FUNC 2155 */ 2156 HWTEST_F(ViewAbstractTestNg, CheckPositionOrOffsetLocalizedEdges001, TestSize.Level1) 2157 { 2158 auto top = CalcDimension(1.0); 2159 auto bottom = CalcDimension(2.0); 2160 auto start = CalcDimension(3.0); 2161 auto end = CalcDimension(4.0); 2162 2163 EdgesParam edges; 2164 edges.SetTop(top); 2165 edges.SetBottom(bottom); 2166 edges.start = start; 2167 edges.end = end; 2168 2169 auto textDirection = TextDirection::LTR; 2170 ViewAbstract::CheckPositionOrOffsetLocalizedEdges(edges, textDirection); 2171 EXPECT_EQ(edges.left.value(), start); 2172 2173 textDirection = TextDirection::RTL; 2174 ViewAbstract::CheckPositionOrOffsetLocalizedEdges(edges, textDirection); 2175 EXPECT_EQ(edges.left.value(), end); 2176 } 2177 2178 /** 2179 * @tc.name: CheckPositionOrOffsetLocalizedEdges002 2180 * @tc.desc: Test CheckPositionOrOffsetLocalizedEdges 2181 * @tc.type: FUNC 2182 */ 2183 HWTEST_F(ViewAbstractTestNg, CheckPositionOrOffsetLocalizedEdges002, TestSize.Level1) 2184 { 2185 EdgesParam edges; 2186 2187 auto textDirection = TextDirection::LTR; 2188 ViewAbstract::CheckPositionOrOffsetLocalizedEdges(edges, textDirection); 2189 EXPECT_FALSE(edges.left.has_value()); 2190 EXPECT_FALSE(edges.right.has_value()); 2191 } 2192 } // namespace OHOS::Ace::NG