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 using namespace testing; 19 using namespace testing::ext; 20 21 namespace OHOS::Ace::NG { 22 /** 23 * @tc.name: ViewAbstractTest031 24 * @tc.desc: Test the operation of View_Abstract 25 * @tc.type: FUNC 26 */ 27 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest031, TestSize.Level1) 28 { 29 /** 30 * @tc.steps: step1.ClearStack. 31 */ 32 auto state = static_cast<VisualState>(INDEX); 33 ViewStackProcessor::GetInstance()->SetVisualState(state); 34 ViewStackProcessor::GetInstance()->ClearStack(); 35 36 /** 37 * @tc.steps: step2. related function is called. 38 */ 39 ViewAbstract::SetFlexShrink(RATIO); 40 ViewAbstract::SetFlexGrow(RATIO); 41 ViewAbstract::SetFlexBasis(WIDTH); 42 ViewAbstract::SetFlexBasis(AceType::RawPtr(FRAME_NODE_REGISTER), WIDTH); 43 ViewAbstract::SetDisplayIndex(TEN); 44 ViewAbstract::SetZIndex(FOUF); 45 46 Alignment alignment; 47 ViewAbstract::SetAlign(std::move(alignment)); 48 auto visible = static_cast<VisibleType>(INDEX); 49 ViewAbstract::SetVisibility(std::move(visible)); 50 ViewAbstract::SetOpacity(OPACITYS); 51 52 /** 53 * @tc.expected: Return expected results. 54 */ 55 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 56 EXPECT_FALSE(result); 57 } 58 59 /** 60 * @tc.name: ViewAbstractTest032 61 * @tc.desc: Test the operation of View_Abstract 62 * @tc.type: FUNC 63 */ 64 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest032, TestSize.Level1) 65 { 66 /** 67 * @tc.steps: step1.ClearStack. 68 */ 69 auto state = static_cast<VisualState>(INDEX); 70 ViewStackProcessor::GetInstance()->SetVisualState(state); 71 ViewStackProcessor::GetInstance()->ClearStack(); 72 73 /** 74 * @tc.steps: step2. related function is called. 75 */ 76 OffsetT<Dimension> values = { WIDTH, HEIGHT }; 77 ViewAbstract::SetPosition(values); 78 ViewAbstract::SetOffset(values); 79 ViewAbstract::MarkAnchor(values); 80 81 ViewAbstract::SetPadding(NG::CalcLength(WIDTH)); 82 ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH)); 83 ViewAbstract::SetMargin(NG::CalcLength(WIDTH)); 84 ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), NG::CalcLength(WIDTH)); 85 ViewAbstract::SetBorderRadius(WIDTH); 86 ViewAbstract::SetBorderRadius(nullptr, WIDTH); 87 ViewAbstract::SetBorderColor(BLUE); 88 ViewAbstract::SetBorderColor(nullptr, BLUE); 89 ViewAbstract::SetBorderWidth(WIDTH); 90 ViewAbstract::SetBorderWidth(nullptr, WIDTH); 91 92 auto borderStyle = static_cast<BorderStyle>(INDEX); 93 ViewAbstract::SetBorderStyle(borderStyle); 94 ViewAbstract::SetBorderStyle(nullptr, borderStyle); 95 96 /** 97 * @tc.expected: Return expected results. 98 */ 99 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 100 EXPECT_FALSE(result); 101 } 102 103 /** 104 * @tc.name: ViewAbstractTest033 105 * @tc.desc: Test the operation of View_Abstract 106 * @tc.type: FUNC 107 */ 108 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest033, TestSize.Level1) 109 { 110 /** 111 * @tc.steps: step1.ClearStack. 112 */ 113 auto state = static_cast<VisualState>(INDEX); 114 ViewStackProcessor::GetInstance()->SetVisualState(state); 115 ViewStackProcessor::GetInstance()->ClearStack(); 116 117 /** 118 * @tc.steps: step2. related function is called. 119 */ 120 OffsetT<Dimension> values = { WIDTH, HEIGHT }; 121 ViewAbstract::SetPosition(values); 122 ViewAbstract::SetOffset(values); 123 ViewAbstract::MarkAnchor(values); 124 125 NG::PaddingProperty paddings; 126 ViewAbstract::SetPadding(paddings); 127 ViewAbstract::SetPadding(AceType::RawPtr(FRAME_NODE_REGISTER), paddings); 128 129 NG::MarginProperty margins; 130 ViewAbstract::SetMargin(margins); 131 ViewAbstract::SetMargin(AceType::RawPtr(FRAME_NODE_REGISTER), margins); 132 133 NG::BorderRadiusProperty borderRadius; 134 ViewAbstract::SetBorderRadius(borderRadius); 135 136 NG::BorderColorProperty borderColors; 137 ViewAbstract::SetBorderColor(borderColors); 138 139 NG::BorderWidthProperty borderWidth; 140 ViewAbstract::SetBorderWidth(borderWidth); 141 142 NG::BorderStyleProperty borderStyles; 143 ViewAbstract::SetBorderStyle(borderStyles); 144 ViewAbstract::SetBorderStyle(nullptr, borderStyles); 145 146 /** 147 * @tc.expected: Return expected results. 148 */ 149 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 150 EXPECT_FALSE(result); 151 } 152 153 /** 154 * @tc.name: ViewAbstractTest034 155 * @tc.desc: Test the operation of View_Abstract 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest034, TestSize.Level1) 159 { 160 /** 161 * @tc.steps: step1.ClearStack. 162 */ 163 auto state = static_cast<VisualState>(INDEX); 164 ViewStackProcessor::GetInstance()->SetVisualState(state); 165 ViewStackProcessor::GetInstance()->ClearStack(); 166 167 /** 168 * @tc.steps: step2. related function is called. 169 */ 170 BlurOption blurOption; 171 ViewAbstract::SetBrightness(RADIUS); 172 ViewAbstract::SetGrayScale(RADIUS); 173 ViewAbstract::SetContrast(RADIUS); 174 ViewAbstract::SetContrast(nullptr, RADIUS); 175 ViewAbstract::SetSaturate(RADIUS); 176 ViewAbstract::SetSepia(RADIUS); 177 ViewAbstract::SetInvert(invert); 178 ViewAbstract::SetHueRotate(RATIO); 179 ViewAbstract::SetColorBlend(BLUE); 180 ViewAbstract::SetBackdropBlur(RADIUS, blurOption); 181 ViewAbstract::SetFrontBlur(RADIUS, blurOption); 182 ViewAbstract::SetClipEdge(false); 183 184 /** 185 * @tc.expected: Return expected results. 186 */ 187 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 188 EXPECT_FALSE(result); 189 } 190 191 /** 192 * @tc.name: ViewAbstractTest035 193 * @tc.desc: Test the operation of View_Abstract 194 * @tc.type: FUNC 195 */ 196 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest035, TestSize.Level1) 197 { 198 /** 199 * @tc.steps: step1.ClearStack. 200 */ 201 auto state = static_cast<VisualState>(INDEX); 202 ViewStackProcessor::GetInstance()->SetVisualState(state); 203 ViewStackProcessor::GetInstance()->ClearStack(); 204 205 /** 206 * @tc.steps: step2. related function is called. 207 */ 208 viewAbstractModelNG.SetScale(1.0f, 1.0f, 0.0f); 209 DimensionOffset value = { WIDTH, HEIGHT }; 210 viewAbstractModelNG.SetPivot(WIDTH, HEIGHT, ZERO); 211 NG::TranslateOptions values; 212 ViewAbstract::SetTranslate(std::move(values)); 213 Vector5F scales(1.0f, 1.0f, 2.0f, 2.0f, 0.0f); 214 ViewAbstract::SetRotate(scales); 215 Matrix4 matrix; 216 ViewAbstract::SetTransformMatrix(std::move(matrix)); 217 218 ShadowStyle style { 1 }; 219 Shadow shadow { RATIO, OFFSET, BLUE, style }; 220 ViewAbstract::SetBackShadow(shadow); 221 NG::Gradient gradient; 222 ViewAbstract::SetLinearGradient(std::move(gradient)); 223 ViewAbstract::SetSweepGradient(std::move(gradient)); 224 ViewAbstract::SetRadialGradient(std::move(gradient)); 225 TransitionOptions options; 226 ViewAbstract::SetTransition(std::move(options)); 227 ViewAbstract::SetTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(options)); 228 RefPtr<BasicShape> basicShape; 229 ViewAbstract::SetClipShape(std::move(basicShape)); 230 ViewAbstract::SetMask(std::move(basicShape)); 231 ViewAbstract::SetMask(nullptr, std::move(basicShape)); 232 233 /** 234 * @tc.expected: Return expected results. 235 */ 236 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 237 EXPECT_FALSE(result); 238 } 239 240 /** 241 * @tc.name: ViewAbstractTest036 242 * @tc.desc: Test the operation of View_Abstract 243 * @tc.type: FUNC 244 */ 245 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest036, TestSize.Level1) 246 { 247 /** 248 * @tc.steps: step1.ClearStack. 249 */ 250 auto state = static_cast<VisualState>(INDEX); 251 ViewStackProcessor::GetInstance()->SetVisualState(state); 252 ViewStackProcessor::GetInstance()->ClearStack(); 253 254 /** 255 * @tc.steps: step2. related function is called. 256 */ 257 ViewAbstract::SetBorderImageSource(srcimages); 258 ViewAbstract::SetBorderImageSource(nullptr, srcimages); 259 ViewAbstract::SetHasBorderImageSlice(false); 260 ViewAbstract::SetHasBorderImageSlice(nullptr, false); 261 ViewAbstract::SetHasBorderImageWidth(false); 262 ViewAbstract::SetHasBorderImageWidth(nullptr, false); 263 ViewAbstract::SetHasBorderImageOutset(false); 264 ViewAbstract::SetHasBorderImageOutset(nullptr, false); 265 ViewAbstract::SetHasBorderImageRepeat(false); 266 ViewAbstract::SetSphericalEffect(RATIO); 267 ViewAbstract::SetSphericalEffect(nullptr, RATIO); 268 ViewAbstract::SetLightUpEffect(RATIO); 269 ViewAbstract::SetLightUpEffect(nullptr, RATIO); 270 ViewAbstract::SetForegroundColor(BLUE); 271 ViewAbstract::SetForegroundColor(AceType::RawPtr(FRAME_NODE_REGISTER), BLUE); 272 ViewAbstract::ClearWidthOrHeight(true); 273 ViewAbstract::SetUseEffect(false); 274 ViewAbstract::SetUseEffect(nullptr, false); 275 ViewAbstract::SetRenderGroup(false); 276 ViewAbstract::SetRenderGroup(nullptr, false); 277 ViewAbstract::SetRenderFit(RenderFit::BOTTOM); 278 ViewAbstract::SetRenderFit(nullptr, RenderFit::BOTTOM); 279 ViewAbstract::UpdateSafeAreaExpandOpts(safeAreaExpandOpts); 280 ViewAbstract::SetObscured(reasonsVector); 281 282 PixStretchEffectOption option; 283 option.bottom = BOTTOM; 284 option.left = LEFT; 285 option.right = RIGHT; 286 option.top = TOP; 287 ViewAbstract::SetPixelStretchEffect(option); 288 289 /** 290 * @tc.expected: Return expected results. 291 */ 292 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 293 EXPECT_FALSE(result); 294 } 295 296 /** 297 * @tc.name: ViewAbstractTest037 298 * @tc.desc: Test the operation of View_Abstract 299 * @tc.type: FUNC 300 */ 301 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest037, TestSize.Level1) 302 { 303 /** 304 * @tc.steps: step1.ClearStack. 305 */ 306 auto state = static_cast<VisualState>(INDEX); 307 ViewStackProcessor::GetInstance()->SetVisualState(state); 308 ViewStackProcessor::GetInstance()->ClearStack(); 309 310 /** 311 * @tc.steps: step2. related function is called. 312 */ 313 RefPtr<BorderImage> borderImage; 314 ViewAbstract::SetBorderImage(std::move(borderImage)); 315 Gradient gradient; 316 ViewAbstract::SetBorderImageGradient(std::move(gradient)); 317 RefPtr<NG::ChainedTransitionEffect> effect; 318 ViewAbstract::SetChainedTransition(std::move(effect)); 319 ViewAbstract::SetChainedTransition(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(effect)); 320 RefPtr<ProgressMaskProperty> progress; 321 ViewAbstract::SetProgressMask(std::move(progress)); 322 ViewAbstract::SetProgressMask(nullptr, std::move(progress)); 323 auto strategy = static_cast<ForegroundColorStrategy>(INDEX); 324 ViewAbstract::SetForegroundColorStrategy(std::move(strategy)); 325 ViewAbstract::SetForegroundColorStrategy(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(strategy)); 326 OverlayOptions overlay; 327 ViewAbstract::SetOverlay(std::move(overlay)); 328 329 /** 330 * @tc.expected: Return expected results. 331 */ 332 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 333 EXPECT_FALSE(result); 334 } 335 336 /** 337 * @tc.name: ViewAbstractTest038 338 * @tc.desc: Test the operation of View_Abstract. 339 * @tc.type: FUNC 340 */ 341 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest038, TestSize.Level1) 342 { 343 /** 344 * @tc.steps: step1. Build a object viewAbstract. 345 */ 346 ViewStackProcessor viewStackProcessor; 347 ViewAbstract viewAbstract; 348 constexpr char TAG_ROOT[] = "root"; 349 constexpr char TAG_CHILD[] = "child"; 350 const auto MOCK_PATTERN_ROOT = AceType::MakeRefPtr<Pattern>(); 351 const auto FRAME_NODE_ROOT = FrameNode::CreateFrameNode(TAG_ROOT, 1, MOCK_PATTERN_ROOT, true); 352 const auto FRAME_NODE_CHILD = FrameNode::CreateFrameNode(TAG_CHILD, 2, MOCK_PATTERN_ROOT, false); 353 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 354 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 355 /** 356 * @tc.steps: step2. callback SetClickEffectLevel.push FrameNode is not null. 357 */ 358 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 359 viewAbstract.SetClickEffectLevel(AceType::RawPtr(FRAME_NODE_REGISTER), ClickEffectLevel::LIGHT, 1.0f); 360 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 361 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 362 auto frameNode = AceType::DynamicCast<FrameNode>(ViewStackProcessor::GetInstance()->Finish()); 363 ASSERT_NE(frameNode, nullptr); 364 /** 365 * @tc.expected: step3. Return expected results.. 366 */ 367 auto Node = AceType::DynamicCast<NG::FrameNode>(frameNode); 368 ASSERT_NE(Node, nullptr); 369 auto layoutProperty = Node->GetLayoutProperty(); 370 ASSERT_NE(layoutProperty, nullptr); 371 viewStackProcessor.instance = nullptr; 372 } 373 374 /** 375 * @tc.name: ViewAbstractTest039 376 * @tc.desc: Test the operation of View_Abstract 377 * @tc.type: FUNC 378 */ 379 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest039, TestSize.Level1) 380 { 381 /** 382 * @tc.steps: step1. Build a object viewAbstract. 383 */ 384 ViewStackProcessor viewStackProcessor; 385 ViewAbstract viewAbstract; 386 int32_t index = 1; 387 auto state = static_cast<VisualState>(index); 388 viewStackProcessor.GetInstance()->SetVisualState(state); 389 /** 390 * @tc.steps: step2.ClearStack and callback SetScale. 391 */ 392 viewStackProcessor.GetInstance()->ClearStack(); 393 /** 394 * @tc.expected: step2. Return expected results.. 395 */ 396 bool result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 397 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 398 ViewAbstract::ResetMinSize(true); 399 EXPECT_FALSE(result); 400 /** 401 * @tc.steps: step3. visualState_ is null. 402 * @tc.expected: result is true. 403 */ 404 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 405 result = ViewStackProcessor::GetInstance()->IsCurrentVisualStateProcess(); 406 viewAbstract.SetClickEffectLevel(ClickEffectLevel::LIGHT, 1.0f); 407 ViewAbstract::ResetMinSize(true); 408 EXPECT_TRUE(result); 409 } 410 411 /** 412 * @tc.name: ViewAbstractTest040 413 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG 414 * @tc.type: FUNC 415 */ 416 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest040, TestSize.Level1) 417 { 418 /** 419 * @tc.steps: step1. create and put mainNode, then build some necessary params. 420 */ 421 const RefPtr<FrameNode> mainNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 422 ViewStackProcessor::GetInstance()->Push(mainNode); 423 424 auto container = Container::Current(); 425 ASSERT_NE(container, nullptr); 426 auto pipelineContext = container->GetPipelineContext(); 427 ASSERT_NE(pipelineContext, nullptr); 428 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 429 ASSERT_NE(context, nullptr); 430 auto overlayManager = context->GetOverlayManager(); 431 ASSERT_NE(overlayManager, nullptr); 432 433 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anonc7b1b4a20102() 434 std::function<void()> flagFunc = []() { flag++; }; 435 std::vector<NG::OptionParam> params = {}; 436 std::function<void()> buildFunc; 437 MenuParam menuParam; 438 std::function<void()> previewBuildFunc = nullptr; 439 /** 440 * @tc.steps: step2. call Bind and BindContextMenu multiple times with unless parameters 441 * @tc.expected: The show or hide method will not call flagFunc. 442 */ 443 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); __anonc7b1b4a20202() 444 buildFunc = []() {}; 445 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 446 params.push_back(OptionParam()); 447 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 448 menuParam.type = MenuType::CONTEXT_MENU; 449 viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc); 450 EXPECT_EQ(flag, 0); 451 /** 452 * @tc.steps: step3. set appear and disappear and recall BindMenu and BindContextMenu; 453 * @tc.expected: The flagFunc call times meet expectations. 454 */ 455 menuParam.onAppear = flagFunc; 456 menuParam.onDisappear = flagFunc; 457 menuParam.type = MenuType::MENU; 458 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 459 menuParam.type = MenuType::CONTEXT_MENU; 460 viewAbstractModelNG.BindContextMenu(ResponseType::RIGHT_CLICK, buildFunc, menuParam, previewBuildFunc); 461 menuParam.contextMenuRegisterType = ContextMenuRegisterType::CUSTOM_TYPE; 462 menuParam.isShow = true; 463 viewAbstractModelNG.BindContextMenu(ResponseType::LONG_PRESS, buildFunc, menuParam, previewBuildFunc); 464 EXPECT_EQ(flag, 0); 465 auto subwindow = SubwindowManager::GetInstance()->GetSubwindow(container); 466 EXPECT_EQ(subwindow, nullptr); 467 468 /** 469 * @tc.steps: step4. create mouseInfo, set some useless params and call onMouseCallback_; 470 * @tc.expected: StopPropagation in mouseInfo is false. 471 */ 472 auto inputHub = mainNode->GetOrCreateInputEventHub(); 473 ASSERT_NE(inputHub, nullptr); __anonc7b1b4a20302(MouseInfo& info)474 auto mouseCallback = [](MouseInfo& info){}; 475 inputHub->showMenu_ = AceType::MakeRefPtr<InputEvent>(mouseCallback); 476 ASSERT_NE(inputHub->showMenu_, nullptr); 477 MouseInfo mouseInfo; 478 mouseInfo.SetButton(MouseButton::LEFT_BUTTON); 479 mouseInfo.SetAction(MouseAction::NONE); 480 inputHub->showMenu_->onMouseCallback_(mouseInfo); 481 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON); 482 mouseInfo.SetAction(MouseAction::NONE); 483 inputHub->showMenu_->onMouseCallback_(mouseInfo); 484 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 485 /** 486 * @tc.steps: step4. create mouseInfo, set right param and call onMouseCallback_; 487 * @tc.expected: StopPropagation in mouseInfo is false. 488 */ 489 mouseInfo.SetButton(MouseButton::RIGHT_BUTTON); 490 mouseInfo.SetAction(MouseAction::RELEASE); 491 inputHub->showMenu_->onMouseCallback_(mouseInfo); 492 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 493 494 /** 495 * @tc.steps: step5. create mouseInfo, set right param and call BindMenuWithCustomNode; 496 * @tc.expected: StopPropagation in mouseInfo is true. 497 */ 498 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 499 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 500 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 501 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 502 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 503 const RefPtr<FrameNode> targetNode = 504 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 505 std::vector<OptionParam> param; 506 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam); 507 menuParam.type = MenuType::MULTI_MENU; 508 ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam, 509 std::move(previewBuildFunc)); 510 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 511 param.push_back(OptionParam()); 512 ViewAbstract::BindMenuWithItems(std::move(param), targetNode, OFFSETF, menuParam); 513 menuParam.type = MenuType::CONTEXT_MENU; 514 ViewAbstract::BindMenuWithCustomNode(std::move(buildFunc), targetNode, OFFSETF, menuParam, 515 std::move(previewBuildFunc)); 516 EXPECT_FALSE(mouseInfo.IsStopPropagation()); 517 } 518 519 /** 520 * @tc.name: ViewAbstractTest041 521 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG 522 * @tc.type: FUNC 523 */ 524 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest041, TestSize.Level1) 525 { 526 /** 527 * @tc.steps: step1. creat frameNode and other creat. 528 */ 529 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 530 const RefPtr<FrameNode> frameNode = 531 FrameNode::CreateFrameNode("frameNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 532 533 auto layoutProperty = frameNode->GetLayoutProperty(); 534 CalcSize idealSize = { CalcLength(ZERO), CalcLength(ZERO) }; 535 layoutProperty->calcLayoutConstraint_ = std::make_unique<MeasureProperty>(); 536 layoutProperty->calcLayoutConstraint_->minSize = idealSize; 537 layoutProperty->calcLayoutConstraint_->maxSize = idealSize; 538 EffectOption option; 539 Color color = Color::TRANSPARENT; 540 option.color = color; 541 542 std::vector<std::pair<float, float>> fractionStops; 543 fractionStops.push_back(std::pair<float, float>(0.0f, 1.0f)); 544 CalcDimension dimensionRadius(0.0); 545 LinearGradientBlurPara blurPara(dimensionRadius, fractionStops, GradientDirection::LEFT); 546 /** 547 * @tc.steps: step2. ResetMinSize test, IsCurrentVisualStateProcess() == false 548 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_ not change 549 */ 550 ViewStackProcessor::GetInstance()->SetVisualState(VisualState::DISABLED); 551 ViewAbstract::ResetMinSize(true); 552 ViewAbstract::ResetMinSize(AceType::RawPtr(FRAME_NODE_REGISTER), true); 553 ViewAbstract::ResetMaxSize(true); 554 ViewAbstract::ResetMaxSize(AceType::RawPtr(FRAME_NODE_REGISTER), true); 555 ViewAbstract::SetBackgroundAlign(Alignment::TOP_LEFT); 556 ViewAbstract::SetBackgroundEffect(option); 557 ViewAbstract::SetBackgroundEffect(AceType::RawPtr(FRAME_NODE_REGISTER), option); 558 ViewAbstract::SetDynamicLightUp(0, 0); 559 ViewAbstract::SetDynamicLightUp(AceType::RawPtr(FRAME_NODE_REGISTER), 0, 0); 560 ViewAbstract::SetLinearGradientBlur(blurPara); 561 ViewAbstract::SetLinearGradientBlur(nullptr, blurPara); 562 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.has_value()); 563 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.has_value()); 564 565 /** 566 * @tc.steps: step3. ResetMinSize test, IsCurrentVisualStateProcess() == true 567 * @tc.expected:call ResetMinSize(),calcLayoutConstraint_->minSize.Width not change 568 */ 569 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 570 ViewAbstract::ResetMinSize(true); 571 ViewAbstract::ResetMaxSize(true); 572 ViewAbstract::SetBackgroundAlign(Alignment::BOTTOM_RIGHT); 573 ViewAbstract::SetBackgroundEffect(option); 574 ViewAbstract::SetDynamicLightUp(0, 0); 575 ViewAbstract::SetLinearGradientBlur(blurPara); 576 ViewAbstract::DisableOnAppear(); 577 ViewAbstract::DisableOnAreaChange(); 578 ViewAbstract::DisableOnDisAppear(); 579 std::vector<DimensionRect> responseRegion; 580 DimensionRect responseRect(Dimension(0), Dimension(0), DimensionOffset(OFFSETF)); 581 responseRegion.emplace_back(responseRect); 582 ViewAbstract::SetMouseResponseRegion(responseRegion); 583 ViewAbstract::SetMouseResponseRegion(AceType::RawPtr(FRAME_NODE_REGISTER), responseRegion); 584 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->minSize.value().Width().has_value()); 585 EXPECT_TRUE(layoutProperty->calcLayoutConstraint_->maxSize.value().Width().has_value()); 586 } 587 588 /** 589 * @tc.name: ViewAbstractTest042 590 * @tc.desc: Test the SetKeyboardShortcut of View_Abstract for tab/Up arrow/Down arrow/Left arrow/Right arrow key. 591 * @tc.type: FUNC 592 */ 593 HWTEST_F(ViewAbstractTestNg, ViewAbstractTest042, TestSize.Level1) 594 { 595 /** 596 * @tc.steps: step1. Create a FrameNode and get eventManager. 597 */ 598 const RefPtr<FrameNode> targetNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 599 ViewStackProcessor::GetInstance()->Push(targetNode); 600 auto eventManager = PipelineContext::GetCurrentContext()->GetEventManager(); 601 /** 602 * @tc.steps: step2. call SetKeyboardShortcut with tab and ModifierKey. 603 * @tc.expected: add fail 604 */ 605 std::vector<ModifierKey> keys; 606 keys.push_back(ModifierKey::SHIFT); 607 ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback); 608 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 609 keys.clear(); 610 611 /** 612 * @tc.steps: step3. call SetKeyboardShortcut with up arrow. 613 * @tc.expected: add success 614 */ 615 ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback); 616 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 617 keys.clear(); 618 619 /** 620 * @tc.steps: step4. call SetKeyboardShortcut with up arrow and ModifierKey. 621 * @tc.expected: add success 622 */ 623 keys.push_back(ModifierKey::ALT); 624 ViewAbstract::SetKeyboardShortcut(VALUE_DPAD_UP, std::move(keys), callback); 625 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 626 keys.clear(); 627 628 /** 629 * @tc.steps: step5. call SetKeyboardShortcut with tab. 630 * @tc.expected: add success 631 */ 632 633 ViewAbstract::SetKeyboardShortcut(VALUE_TAB, std::move(keys), callback); 634 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1); 635 } 636 637 /** 638 * @tc.name: ViewAbstractOffsetEdges001 639 * @tc.desc: test offset attribute, use Edges type. 640 * @tc.type: FUNC 641 */ 642 HWTEST_F(ViewAbstractTestNg, ViewAbstractOffset001, TestSize.Level1) 643 { 644 /** 645 * @tc.steps: step1. create and put mainNode, then build some necessary params. 646 */ 647 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 648 649 /** 650 * @tc.steps: step2. get node in ViewStackProcessor. 651 * @tc.expected: node is not null. 652 */ 653 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 654 EXPECT_NE(rootFrameNode, nullptr); 655 656 /** 657 * @tc.steps: step3. use ViewAbstract::SetOffsetEdges. 658 * @tc.expected: success set render property offsetEdges value. 659 */ 660 EdgesParam edges; 661 CalcDimension top(30, DimensionUnit::VP); 662 CalcDimension left(20, DimensionUnit::VP); 663 edges.SetTop(top); 664 edges.SetLeft(left); 665 ViewAbstract::SetOffsetEdges(edges); 666 667 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 668 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 669 ->GetOffsetEdgesValue(EdgesParam {}).top.value_or(Dimension {}).ConvertToVp(), 30.0f); 670 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 671 ->GetOffsetEdgesValue(EdgesParam {}).left.value_or(Dimension {}).ConvertToVp(), 20.0f); 672 673 /** 674 * @tc.steps: step5. finish view stack. 675 */ 676 ViewStackProcessor::GetInstance()->Finish(); 677 } 678 679 /** 680 * @tc.name: ViewAbstractPositionEdges001 681 * @tc.desc: test position attribute, use Edges type. 682 * @tc.type: FUNC 683 */ 684 HWTEST_F(ViewAbstractTestNg, ViewAbstractPositionEdges001, TestSize.Level1) 685 { 686 /** 687 * @tc.steps: step1. create and put mainNode, then build some necessary params. 688 */ 689 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 690 691 /** 692 * @tc.steps: step2. get node in ViewStackProcessor. 693 * @tc.expected: node is not null. 694 */ 695 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 696 EXPECT_NE(rootFrameNode, nullptr); 697 698 /** 699 * @tc.steps: step3. use ViewAbstract::SetPositionEdges. 700 * @tc.expected: success set render property PositionEdges value. 701 */ 702 EdgesParam edges; 703 CalcDimension bottom(30, DimensionUnit::VP); 704 CalcDimension right(20, DimensionUnit::VP); 705 edges.SetBottom(bottom); 706 edges.SetRight(right); 707 ViewAbstract::SetPositionEdges(edges); 708 709 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 710 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 711 ->GetPositionEdgesValue(EdgesParam {}).bottom.value_or(Dimension {}).ConvertToVp(), 30.0f); 712 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 713 ->GetPositionEdgesValue(EdgesParam {}).right.value_or(Dimension {}).ConvertToVp(), 20.0f); 714 715 /** 716 * @tc.steps: step5. finish view stack. 717 */ 718 ViewStackProcessor::GetInstance()->Finish(); 719 } 720 721 /** 722 * @tc.name: ViewAbstractDisableClickTest 723 * @tc.desc: Test the operation of View_Abstract. 724 * @tc.type: FUNC 725 */ 726 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickTest, TestSize.Level1) 727 { 728 /** 729 * @tc.steps: step1. create framenode and check callback; 730 * @tc.expected: callback is not null. 731 */ 732 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 733 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 734 GestureEventFunc tapEventFunc; 735 ViewAbstract::SetOnClick(std::move(tapEventFunc)); 736 737 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 738 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 739 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 740 ASSERT_NE(frameNode, nullptr); 741 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 742 ASSERT_NE(node, nullptr); 743 auto gestureHub = node->GetOrCreateGestureEventHub(); 744 auto& callback = gestureHub->clickEventActuator_->userCallback_; 745 EXPECT_NE(callback, nullptr); 746 747 /** 748 * @tc.steps: step2. Disable callback. 749 * @tc.expected: callback is null. 750 */ 751 ViewAbstract::DisableOnClick(); 752 EXPECT_EQ(callback, nullptr); 753 754 /** 755 * @tc.steps: step3. Add callback again. 756 * @tc.expected: callback is not null. 757 */ 758 GestureEventFunc tapEventFunc2; 759 ViewAbstract::SetOnClick(std::move(tapEventFunc2)); 760 EXPECT_NE(callback, nullptr); 761 ViewStackProcessor::GetInstance()->instance = nullptr; 762 } 763 764 /** 765 * @tc.name: ViewAbstractDisableTouchTest 766 * @tc.desc: Test the operation of View_Abstract. 767 * @tc.type: FUNC 768 */ 769 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchTest, TestSize.Level1) 770 { 771 /** 772 * @tc.steps: step1. create framenode and check callback; 773 * @tc.expected: callback is not null. 774 */ 775 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 776 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 777 TouchEventFunc touchEventFunc; 778 ViewAbstract::SetOnTouch(std::move(touchEventFunc)); 779 780 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 781 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 782 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 783 ASSERT_NE(frameNode, nullptr); 784 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 785 ASSERT_NE(node, nullptr); 786 auto gestureHub = node->GetOrCreateGestureEventHub(); 787 auto& callback = gestureHub->touchEventActuator_->userCallback_; 788 EXPECT_NE(callback, nullptr); 789 790 /** 791 * @tc.steps: step2. Disable callback. 792 * @tc.expected: callback is null. 793 */ 794 ViewAbstract::DisableOnTouch(); 795 EXPECT_EQ(callback, nullptr); 796 797 /** 798 * @tc.steps: step3. Add callback again. 799 * @tc.expected: callback is not null. 800 */ 801 TouchEventFunc touchEventFunc2; 802 ViewAbstract::SetOnTouch(std::move(touchEventFunc2)); 803 EXPECT_NE(callback, nullptr); 804 ViewStackProcessor::GetInstance()->instance = nullptr; 805 } 806 807 /** 808 * @tc.name: ViewAbstractDisableMouseTest 809 * @tc.desc: Test the operation of View_Abstract. 810 * @tc.type: FUNC 811 */ 812 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseTest, TestSize.Level1) 813 { 814 /** 815 * @tc.steps: step1. create framenode and check callback; 816 * @tc.expected: callback is not null. 817 */ 818 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 819 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 820 OnMouseEventFunc onMouseEventFunc; 821 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc)); 822 823 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 824 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 825 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 826 ASSERT_NE(frameNode, nullptr); 827 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 828 ASSERT_NE(node, nullptr); 829 auto eventHub = node->GetOrCreateInputEventHub(); 830 auto& callback = eventHub->mouseEventActuator_->userCallback_; 831 EXPECT_NE(callback, nullptr); 832 833 /** 834 * @tc.steps: step2. Disable callback. 835 * @tc.expected: callback is null. 836 */ 837 ViewAbstract::DisableOnMouse(); 838 EXPECT_EQ(callback, nullptr); 839 840 /** 841 * @tc.steps: step3. Add callback again. 842 * @tc.expected: callback is not null. 843 */ 844 OnMouseEventFunc onMouseEventFunc2; 845 ViewAbstract::SetOnMouse(std::move(onMouseEventFunc2)); 846 ViewAbstract::SetJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onMouseEventFunc2)); 847 ViewAbstract::ClearJSFrameNodeOnMouse(AceType::RawPtr(FRAME_NODE_REGISTER)); 848 EXPECT_NE(callback, nullptr); 849 ViewStackProcessor::GetInstance()->instance = nullptr; 850 } 851 852 /** 853 * @tc.name: ViewAbstractDisableHoverTest 854 * @tc.desc: Test the operation of View_Abstract. 855 * @tc.type: FUNC 856 */ 857 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverTest, TestSize.Level1) 858 { 859 /** 860 * @tc.steps: step1. create framenode and check callback; 861 * @tc.expected: callback is not null. 862 */ 863 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 864 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 865 OnHoverFunc onHoverEventFunc; 866 ViewAbstract::SetOnHover(std::move(onHoverEventFunc)); 867 868 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 869 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 870 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 871 ASSERT_NE(frameNode, nullptr); 872 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 873 ASSERT_NE(node, nullptr); 874 auto eventHub = node->GetOrCreateInputEventHub(); 875 auto& callback = eventHub->hoverEventActuator_->userCallback_; 876 EXPECT_NE(callback, nullptr); 877 878 /** 879 * @tc.steps: step2. Disable callback. 880 * @tc.expected: callback is null. 881 */ 882 ViewAbstract::DisableOnHover(); 883 EXPECT_EQ(callback, nullptr); 884 885 /** 886 * @tc.steps: step3. Add callback again. 887 * @tc.expected: callback is not null. 888 */ 889 OnHoverFunc onHoverEventFunc2; 890 ViewAbstract::SetOnHover(std::move(onHoverEventFunc2)); 891 EXPECT_NE(callback, nullptr); 892 ViewStackProcessor::GetInstance()->instance = nullptr; 893 } 894 895 /** 896 * @tc.name: ViewAbstractDisableKeyTest 897 * @tc.desc: Test the operation of View_Abstract. 898 * @tc.type: FUNC 899 */ 900 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyTest, TestSize.Level1) 901 { 902 /** 903 * @tc.steps: step1. create framenode and check callback; 904 * @tc.expected: callback is not null. 905 */ 906 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 907 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anonc7b1b4a20402(KeyEventInfo& info) 908 OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {}; 909 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback)); 910 911 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 912 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 913 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 914 ASSERT_NE(frameNode, nullptr); 915 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 916 ASSERT_NE(node, nullptr); 917 auto focusHub = node->GetOrCreateFocusHub(); 918 auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_; 919 EXPECT_TRUE(callback); 920 921 /** 922 * @tc.steps: step2. Disable callback. 923 * @tc.expected: callback is null. 924 */ 925 ViewAbstract::DisableOnKeyEvent(); 926 EXPECT_FALSE(callback); 927 928 /** 929 * @tc.steps: step3. Add callback again. 930 * @tc.expected: callback is not null. 931 */ __anonc7b1b4a20502(KeyEventInfo& info) 932 OnKeyCallbackFunc onKeyCallback2 = [](KeyEventInfo& info) {}; 933 ViewAbstract::SetOnKeyEvent(std::move(onKeyCallback2)); 934 EXPECT_TRUE(callback); 935 ViewStackProcessor::GetInstance()->instance = nullptr; 936 } 937 938 /** 939 * @tc.name: ViewAbstractDisableFocusTest 940 * @tc.desc: Test the operation of View_Abstract. 941 * @tc.type: FUNC 942 */ 943 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusTest, TestSize.Level1) 944 { 945 /** 946 * @tc.steps: step1. create framenode and check callback; 947 * @tc.expected: callback is not null. 948 */ 949 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 950 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anonc7b1b4a20602() 951 OnFocusFunc onFocusCallback = []() {}; 952 ViewAbstract::SetOnFocus(std::move(onFocusCallback)); 953 ViewAbstract::SetOnFocus(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback)); 954 ViewAbstract::SetJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onFocusCallback)); 955 ViewAbstract::ClearJSFrameNodeOnFocusCallback(AceType::RawPtr(FRAME_NODE_REGISTER)); 956 957 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 958 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 959 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 960 ASSERT_NE(frameNode, nullptr); 961 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 962 ASSERT_NE(node, nullptr); 963 auto focusHub = node->GetOrCreateFocusHub(); 964 auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_; 965 EXPECT_NE(callback, nullptr); 966 967 /** 968 * @tc.steps: step2. Disable callback. 969 * @tc.expected: callback is null. 970 */ 971 ViewAbstract::DisableOnFocus(); 972 EXPECT_EQ(callback, nullptr); 973 974 /** 975 * @tc.steps: step3. Add callback again. 976 * @tc.expected: callback is not null. 977 */ __anonc7b1b4a20702() 978 OnFocusFunc onFocusCallback2 = []() {}; 979 ViewAbstract::SetOnFocus(std::move(onFocusCallback2)); 980 EXPECT_NE(callback, nullptr); 981 ViewStackProcessor::GetInstance()->instance = nullptr; 982 } 983 984 /** 985 * @tc.name: ViewAbstractDisableBlurTest 986 * @tc.desc: Test the operation of View_Abstract. 987 * @tc.type: FUNC 988 */ 989 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurTest, TestSize.Level1) 990 { 991 /** 992 * @tc.steps: step1. create framenode and check callback; 993 * @tc.expected: callback is not null. 994 */ 995 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 996 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); __anonc7b1b4a20802() 997 OnBlurFunc onBlurCallback = []() {}; 998 ViewAbstract::SetOnFocus(std::move(onBlurCallback)); 999 ViewAbstract::SetJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback)); 1000 ViewAbstract::ClearJSFrameNodeOnBlurCallback(AceType::RawPtr(FRAME_NODE_REGISTER)); 1001 1002 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1003 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1004 auto frameNodeOne = static_cast<FrameNode*>(ViewAbstract::GetFrameNode()); 1005 EXPECT_EQ(strcmp(frameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1006 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1007 ASSERT_NE(frameNode, nullptr); 1008 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1009 ASSERT_NE(node, nullptr); 1010 auto focusHub = node->GetOrCreateFocusHub(); 1011 auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_; 1012 EXPECT_FALSE(callback); 1013 1014 /** 1015 * @tc.steps: step2. Disable callback. 1016 * @tc.expected: callback is null. 1017 */ 1018 ViewAbstract::DisableOnBlur(); 1019 EXPECT_FALSE(callback); 1020 1021 /** 1022 * @tc.steps: step3. Add callback again. 1023 * @tc.expected: callback is not null. 1024 */ __anonc7b1b4a20902() 1025 OnBlurFunc onBlurCallback2 = []() {}; 1026 ViewAbstract::SetOnBlur(std::move(onBlurCallback2)); 1027 ViewAbstract::SetOnBlur(AceType::RawPtr(FRAME_NODE_REGISTER), std::move(onBlurCallback2)); 1028 EXPECT_TRUE(callback); 1029 ViewStackProcessor::GetInstance()->instance = nullptr; 1030 } 1031 1032 /** 1033 * @tc.name: ViewAbstractMonopolizeEvent001 1034 * @tc.desc: View_Abstract set MonopolizeEvent true test 1035 * @tc.type: FUNC 1036 */ 1037 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent001, TestSize.Level1) 1038 { 1039 /** 1040 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1041 */ 1042 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1043 1044 /** 1045 * @tc.steps: step2. set monopolize 1046 */ 1047 ViewAbstract::SetMonopolizeEvents(true); 1048 ViewAbstract::SetMonopolizeEvents(AceType::RawPtr(FRAME_NODE_REGISTER), true); 1049 1050 /** 1051 * @tc.steps: step3. get node in ViewStackProcessor. 1052 * @tc.expected: node is not null. 1053 */ 1054 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1055 EXPECT_NE(rootFrameNode, nullptr); 1056 1057 /** 1058 * @tc.steps: step4. get monopolizeEvents value of the node. 1059 * @tc.expected: value is equal to true. 1060 */ 1061 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), true); 1062 1063 /** 1064 * @tc.steps: step5. finish view stack. 1065 */ 1066 ViewStackProcessor::GetInstance()->Finish(); 1067 } 1068 1069 /** 1070 * @tc.name: ViewAbstractMonopolizeEvent002 1071 * @tc.desc: View_Abstract set MonopolizeEvent false test 1072 * @tc.type: FUNC 1073 */ 1074 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent002, TestSize.Level1) 1075 { 1076 /** 1077 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1078 */ 1079 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1080 1081 /** 1082 * @tc.steps: step2. set monopolize 1083 */ 1084 ViewAbstract::SetMonopolizeEvents(false); 1085 1086 /** 1087 * @tc.steps: step3. get node in ViewStackProcessor. 1088 * @tc.expected: node is not null. 1089 */ 1090 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1091 EXPECT_NE(rootFrameNode, nullptr); 1092 1093 /** 1094 * @tc.steps: step4. get monopolizeEvents value of the node. 1095 * @tc.expected: value is equal to true. 1096 */ 1097 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false); 1098 1099 /** 1100 * @tc.steps: step5. finish view stack. 1101 */ 1102 ViewStackProcessor::GetInstance()->Finish(); 1103 } 1104 1105 /** 1106 * @tc.name: ViewAbstractMonopolizeEvent003 1107 * @tc.desc: View_Abstract not set MonopolizeEvent test (use default) 1108 * @tc.type: FUNC 1109 */ 1110 HWTEST_F(ViewAbstractTestNg, ViewAbstractMonopolizeEvent003, TestSize.Level1) 1111 { 1112 /** 1113 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1114 */ 1115 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1116 1117 /** 1118 * @tc.steps: step2. get node in ViewStackProcessor. 1119 * @tc.expected: node is not null. 1120 */ 1121 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1122 EXPECT_NE(rootFrameNode, nullptr); 1123 1124 /** 1125 * @tc.steps: step3. get monopolizeEvents value of the node. 1126 * @tc.expected: value is equal to true. 1127 */ 1128 EXPECT_EQ(rootFrameNode->GetMonopolizeEvents(), false); 1129 1130 /** 1131 * @tc.steps: step5. finish view stack. 1132 */ 1133 ViewStackProcessor::GetInstance()->Finish(); 1134 } 1135 1136 /** 1137 * @tc.name: ViewAbstractMenuTransition001 1138 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use dafault) 1139 * @tc.type: FUNC 1140 */ 1141 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition001, TestSize.Level1) 1142 { 1143 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1144 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1145 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1146 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1147 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1148 const RefPtr<FrameNode> mainNode = 1149 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1150 ViewStackProcessor::GetInstance()->Push(mainNode); 1151 auto container = Container::Current(); 1152 ASSERT_NE(container, nullptr); 1153 auto pipelineContext = container->GetPipelineContext(); 1154 ASSERT_NE(pipelineContext, nullptr); 1155 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1156 ASSERT_NE(context, nullptr); 1157 auto overlayManager = context->GetOverlayManager(); 1158 ASSERT_NE(overlayManager, nullptr); 1159 1160 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anonc7b1b4a20a02() 1161 std::function<void()> flagFunc = []() { flag++; }; 1162 std::vector<NG::OptionParam> params = {}; 1163 std::function<void()> buildFunc; 1164 MenuParam menuParam; 1165 std::function<void()> previewBuildFunc = nullptr; 1166 1167 menuParam.type = MenuType::MENU; 1168 menuParam.isShow = true; 1169 1170 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1171 ASSERT_NE(targetNode, nullptr); __anonc7b1b4a20b02null1172 std::function<void()> action = [] {}; 1173 params.emplace_back("MenuItem1", "", action); 1174 params.emplace_back("MenuItem2", "", action); 1175 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1176 auto targetId = targetNode->GetId(); 1177 1178 auto menuNode = overlayManager->GetMenuNode(targetId); 1179 ASSERT_NE(menuNode, nullptr); 1180 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1181 ASSERT_NE(wrapperPattern, nullptr); 1182 EXPECT_EQ(wrapperPattern->HasTransitionEffect(), false); 1183 EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), false); 1184 } 1185 1186 /** 1187 * @tc.name: ViewAbstractMenuTransition002 1188 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true) 1189 * @tc.type: FUNC 1190 */ 1191 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuTransition002, TestSize.Level1) 1192 { 1193 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1194 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1195 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1196 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1197 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1198 const RefPtr<FrameNode> mainNode = 1199 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1200 ViewStackProcessor::GetInstance()->Push(mainNode); 1201 auto container = Container::Current(); 1202 ASSERT_NE(container, nullptr); 1203 auto pipelineContext = container->GetPipelineContext(); 1204 ASSERT_NE(pipelineContext, nullptr); 1205 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1206 ASSERT_NE(context, nullptr); 1207 auto overlayManager = context->GetOverlayManager(); 1208 ASSERT_NE(overlayManager, nullptr); 1209 1210 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); __anonc7b1b4a20c02() 1211 std::function<void()> flagFunc = []() { flag++; }; 1212 std::vector<NG::OptionParam> params = {}; 1213 std::function<void()> buildFunc; 1214 MenuParam menuParam; 1215 std::function<void()> previewBuildFunc = nullptr; 1216 1217 NG::RotateOptions rotate(0.0f, 0.0f, 0.0f, 0.0f, 0.5_pct, 0.5_pct); 1218 1219 menuParam.hasTransitionEffect = true; 1220 menuParam.hasPreviewTransitionEffect = true; 1221 menuParam.transition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate); 1222 menuParam.previewTransition = AceType::MakeRefPtr<NG::ChainedRotateEffect>(rotate); 1223 menuParam.type = MenuType::MENU; 1224 menuParam.isShow = true; 1225 1226 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1227 ASSERT_NE(targetNode, nullptr); __anonc7b1b4a20d02null1228 std::function<void()> action = [] {}; 1229 params.emplace_back("MenuItem1", "", action); 1230 params.emplace_back("MenuItem2", "", action); 1231 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1232 auto targetId = targetNode->GetId(); 1233 1234 auto menuNode = overlayManager->GetMenuNode(targetId); 1235 ASSERT_NE(menuNode, nullptr); 1236 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1237 ASSERT_NE(wrapperPattern, nullptr); 1238 EXPECT_EQ(wrapperPattern->HasTransitionEffect(), true); 1239 EXPECT_EQ(wrapperPattern->HasPreviewTransitionEffect(), true); 1240 } 1241 1242 /** 1243 * @tc.name: ViewAbstractMenuBorderRadius001 1244 * @tc.desc: Test the BindMenu and BindContextMenu of ViewAbstractModelNG (use true) 1245 * @tc.type: FUNC 1246 */ 1247 HWTEST_F(ViewAbstractTestNg, ViewAbstractMenuBorderRadius001, TestSize.Level1) 1248 { 1249 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 1250 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 1251 PipelineBase::GetCurrentContext()->SetEventManager(AceType::MakeRefPtr<EventManager>()); 1252 EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<SelectTheme>())); 1253 int32_t nodeId = ElementRegister::GetInstance()->MakeUniqueId(); 1254 const RefPtr<FrameNode> mainNode = 1255 FrameNode::CreateFrameNode("targetNode", nodeId, AceType::MakeRefPtr<Pattern>(), true); 1256 ViewStackProcessor::GetInstance()->Push(mainNode); 1257 auto container = Container::Current(); 1258 ASSERT_NE(container, nullptr); 1259 auto pipelineContext = container->GetPipelineContext(); 1260 ASSERT_NE(pipelineContext, nullptr); 1261 auto context = AceType::DynamicCast<NG::PipelineContext>(pipelineContext); 1262 ASSERT_NE(context, nullptr); 1263 auto overlayManager = context->GetOverlayManager(); 1264 ASSERT_NE(overlayManager, nullptr); 1265 ASSERT_NE(SubwindowManager::GetInstance(), nullptr); 1266 std::vector<NG::OptionParam> params = {}; 1267 std::function<void()> buildFunc; 1268 MenuParam menuParam; 1269 1270 menuParam.type = MenuType::MENU; 1271 menuParam.isShow = true; 1272 BorderRadiusProperty borderRadius; 1273 borderRadius.SetRadius(Dimension(16)); 1274 menuParam.borderRadius = borderRadius; 1275 1276 auto targetNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1277 ASSERT_NE(targetNode, nullptr); __anonc7b1b4a20e02null1278 std::function<void()> action = [] {}; 1279 params.emplace_back("MenuItem1", "", action); 1280 params.emplace_back("MenuItem2", "", action); 1281 viewAbstractModelNG.BindMenu(std::move(params), std::move(buildFunc), menuParam); 1282 auto targetId = targetNode->GetId(); 1283 1284 auto menuNode = overlayManager->GetMenuNode(targetId); 1285 ASSERT_NE(menuNode, nullptr); 1286 auto wrapperPattern = menuNode->GetPattern<MenuWrapperPattern>(); 1287 ASSERT_NE(wrapperPattern, nullptr); 1288 EXPECT_EQ(wrapperPattern->GetHasCustomRadius(), true); 1289 } 1290 1291 /** 1292 * @tc.name: ViewAbstractDisableClickByFrameNodeTest 1293 * @tc.desc: Test the operation of View_Abstract. 1294 * @tc.type: FUNC 1295 */ 1296 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableClickByFrameNodeTest, TestSize.Level1) 1297 { 1298 /** 1299 * @tc.steps: step1. create framenode and check callback; 1300 * @tc.expected: callback is not null. 1301 */ 1302 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1303 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1304 1305 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1306 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1307 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1308 ASSERT_NE(frameNode, nullptr); 1309 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1310 ASSERT_NE(node, nullptr); 1311 GestureEventFunc tapEventFunc; 1312 ViewAbstract::SetOnClick(AceType::RawPtr(node), std::move(tapEventFunc)); 1313 auto gestureHub = node->GetOrCreateGestureEventHub(); 1314 auto& callback = gestureHub->clickEventActuator_->userCallback_; 1315 EXPECT_NE(callback, nullptr); 1316 1317 /** 1318 * @tc.steps: step2. Disable callback. 1319 * @tc.expected: callback is null. 1320 */ 1321 ViewAbstract::DisableOnClick(AceType::RawPtr(node)); 1322 EXPECT_EQ(callback, nullptr); 1323 } 1324 1325 /** 1326 * @tc.name: ViewAbstractDisableTouchByFrameNodeTest 1327 * @tc.desc: Test the operation of View_Abstract. 1328 * @tc.type: FUNC 1329 */ 1330 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableTouchByFrameNodeTest, TestSize.Level1) 1331 { 1332 /** 1333 * @tc.steps: step1. create framenode and check callback; 1334 * @tc.expected: callback is not null. 1335 */ 1336 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1337 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1338 1339 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1340 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1341 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1342 ASSERT_NE(frameNode, nullptr); 1343 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1344 ASSERT_NE(node, nullptr); 1345 TouchEventFunc touchEventFunc; 1346 ViewAbstract::SetOnTouch(AceType::RawPtr(node), std::move(touchEventFunc)); 1347 auto gestureHub = node->GetOrCreateGestureEventHub(); 1348 auto& callback = gestureHub->touchEventActuator_->userCallback_; 1349 EXPECT_NE(callback, nullptr); 1350 1351 /** 1352 * @tc.steps: step2. Disable callback. 1353 * @tc.expected: callback is null. 1354 */ 1355 ViewAbstract::DisableOnTouch(AceType::RawPtr(node)); 1356 EXPECT_EQ(callback, nullptr); 1357 } 1358 1359 /** 1360 * @tc.name: ViewAbstractDisableMouseByFrameNodeTest 1361 * @tc.desc: Test the operation of View_Abstract. 1362 * @tc.type: FUNC 1363 */ 1364 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableMouseByFrameNodeTest, TestSize.Level1) 1365 { 1366 /** 1367 * @tc.steps: step1. create framenode and check callback; 1368 * @tc.expected: callback is not null. 1369 */ 1370 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1371 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1372 1373 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1374 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1375 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1376 ASSERT_NE(frameNode, nullptr); 1377 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1378 ASSERT_NE(node, nullptr); 1379 OnMouseEventFunc onMouseEventFunc; 1380 ViewAbstract::SetOnMouse(AceType::RawPtr(node), std::move(onMouseEventFunc)); 1381 auto eventHub = node->GetOrCreateInputEventHub(); 1382 auto& callback = eventHub->mouseEventActuator_->userCallback_; 1383 EXPECT_NE(callback, nullptr); 1384 1385 /** 1386 * @tc.steps: step2. Disable callback. 1387 * @tc.expected: callback is null. 1388 */ 1389 ViewAbstract::DisableOnMouse(AceType::RawPtr(node)); 1390 EXPECT_EQ(callback, nullptr); 1391 } 1392 1393 /** 1394 * @tc.name: ViewAbstractDisableHoverByFrameNodeTest 1395 * @tc.desc: Test the operation of View_Abstract. 1396 * @tc.type: FUNC 1397 */ 1398 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableHoverByFrameNodeTest, TestSize.Level1) 1399 { 1400 /** 1401 * @tc.steps: step1. create framenode and check callback; 1402 * @tc.expected: callback is not null. 1403 */ 1404 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1405 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1406 1407 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1408 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1409 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1410 ASSERT_NE(frameNode, nullptr); 1411 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1412 ASSERT_NE(node, nullptr); 1413 OnHoverFunc onHoverEventFunc; 1414 ViewAbstract::SetOnHover(AceType::RawPtr(node), std::move(onHoverEventFunc)); 1415 auto eventHub = node->GetOrCreateInputEventHub(); 1416 auto& callback = eventHub->hoverEventActuator_->userCallback_; 1417 EXPECT_NE(callback, nullptr); 1418 1419 /** 1420 * @tc.steps: step2. Disable callback. 1421 * @tc.expected: callback is null. 1422 */ 1423 ViewAbstract::DisableOnHover(AceType::RawPtr(node)); 1424 EXPECT_EQ(callback, nullptr); 1425 } 1426 1427 /** 1428 * @tc.name: ViewAbstractDisableKeyByFrameNodeTest 1429 * @tc.desc: Test the operation of View_Abstract. 1430 * @tc.type: FUNC 1431 */ 1432 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableKeyByFrameNodeTest, TestSize.Level1) 1433 { 1434 /** 1435 * @tc.steps: step1. create framenode and check callback; 1436 * @tc.expected: callback is not null. 1437 */ 1438 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1439 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1440 1441 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1442 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1443 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1444 ASSERT_NE(frameNode, nullptr); 1445 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1446 ASSERT_NE(node, nullptr); __anonc7b1b4a20f02(KeyEventInfo& info) 1447 OnKeyCallbackFunc onKeyCallback = [](KeyEventInfo& info) {}; 1448 ViewAbstract::SetOnKeyEvent(AceType::RawPtr(node), std::move(onKeyCallback)); 1449 auto focusHub = node->GetOrCreateFocusHub(); 1450 auto& callback = focusHub->focusCallbackEvents_->onKeyEventCallback_; 1451 EXPECT_TRUE(callback); 1452 1453 /** 1454 * @tc.steps: step2. Disable callback. 1455 * @tc.expected: callback is null. 1456 */ 1457 ViewAbstract::DisableOnKeyEvent(AceType::RawPtr(node)); 1458 EXPECT_FALSE(callback); 1459 } 1460 1461 /** 1462 * @tc.name: ViewAbstractDisableFocusByFrameNodeTest 1463 * @tc.desc: Test the operation of View_Abstract. 1464 * @tc.type: FUNC 1465 */ 1466 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableFocusByFrameNodeTest, TestSize.Level1) 1467 { 1468 /** 1469 * @tc.steps: step1. create framenode and check callback; 1470 * @tc.expected: callback is not null. 1471 */ 1472 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1473 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1474 1475 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1476 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1477 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1478 ASSERT_NE(frameNode, nullptr); 1479 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1480 ASSERT_NE(node, nullptr); __anonc7b1b4a21002() 1481 OnFocusFunc onFocusCallback = []() {}; 1482 ViewAbstract::SetOnFocus(AceType::RawPtr(node), std::move(onFocusCallback)); 1483 auto focusHub = node->GetOrCreateFocusHub(); 1484 auto& callback = focusHub->focusCallbackEvents_->onFocusCallback_; 1485 EXPECT_NE(callback, nullptr); 1486 1487 /** 1488 * @tc.steps: step2. Disable callback. 1489 * @tc.expected: callback is null. 1490 */ 1491 ViewAbstract::DisableOnFocus(AceType::RawPtr(node)); 1492 EXPECT_EQ(callback, nullptr); 1493 } 1494 1495 /** 1496 * @tc.name: ViewAbstractDisableBlurByFrameNodeTest 1497 * @tc.desc: Test the operation of View_Abstract. 1498 * @tc.type: FUNC 1499 */ 1500 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableBlurByFrameNodeTest, TestSize.Level1) 1501 { 1502 /** 1503 * @tc.steps: step1. create framenode and check callback; 1504 * @tc.expected: callback is not null. 1505 */ 1506 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1507 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1508 1509 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1510 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1511 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1512 ASSERT_NE(frameNode, nullptr); 1513 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1514 ASSERT_NE(node, nullptr); __anonc7b1b4a21102() 1515 OnBlurFunc onBlurCallback = []() {}; 1516 ViewAbstract::SetOnBlur(AceType::RawPtr(node), std::move(onBlurCallback)); 1517 auto focusHub = node->GetOrCreateFocusHub(); 1518 auto& callback = focusHub->focusCallbackEvents_->onBlurCallback_; 1519 EXPECT_TRUE(callback); 1520 1521 /** 1522 * @tc.steps: step2. Disable callback. 1523 * @tc.expected: callback is null. 1524 */ 1525 ViewAbstract::DisableOnBlur(AceType::RawPtr(node)); 1526 EXPECT_FALSE(callback); 1527 } 1528 1529 /** 1530 * @tc.name: ViewAbstractDisableOnAppearByFrameNodeTest 1531 * @tc.desc: Test the operation of View_Abstract. 1532 * @tc.type: FUNC 1533 */ 1534 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAppearByFrameNodeTest, TestSize.Level1) 1535 { 1536 /** 1537 * @tc.steps: step1. create framenode and check callback; 1538 * @tc.expected: callback is not null. 1539 */ 1540 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1541 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1542 1543 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1544 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1545 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1546 ASSERT_NE(frameNode, nullptr); 1547 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1548 ASSERT_NE(node, nullptr); __anonc7b1b4a21202() 1549 std::function<void()> onAppearCallback = []() {}; 1550 ViewAbstract::SetOnAppear(AceType::RawPtr(node), std::move(onAppearCallback)); 1551 auto eventHub = node->GetEventHub<EventHub>(); 1552 auto& callback = eventHub->onAppear_; 1553 EXPECT_NE(callback, nullptr); 1554 1555 /** 1556 * @tc.steps: step2. Disable callback. 1557 * @tc.expected: callback is null. 1558 */ 1559 ViewAbstract::DisableOnAppear(AceType::RawPtr(node)); 1560 EXPECT_EQ(callback, nullptr); 1561 } 1562 1563 /** 1564 * @tc.name: ViewAbstractDisableOnDisAppearByFrameNodeTest 1565 * @tc.desc: Test the operation of View_Abstract. 1566 * @tc.type: FUNC 1567 */ 1568 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnDisAppearByFrameNodeTest, TestSize.Level1) 1569 { 1570 /** 1571 * @tc.steps: step1. create framenode and check callback; 1572 * @tc.expected: callback is not null. 1573 */ 1574 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1575 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1576 1577 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1578 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1579 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1580 ASSERT_NE(frameNode, nullptr); 1581 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1582 ASSERT_NE(node, nullptr); __anonc7b1b4a21302() 1583 std::function<void()> onDiaAppearCallback = []() {}; 1584 ViewAbstract::SetOnDisappear(AceType::RawPtr(node), std::move(onDiaAppearCallback)); 1585 auto eventHub = node->GetEventHub<EventHub>(); 1586 auto& callback = eventHub->onDisappear_; 1587 EXPECT_NE(callback, nullptr); 1588 1589 /** 1590 * @tc.steps: step2. Disable callback. 1591 * @tc.expected: callback is null. 1592 */ 1593 ViewAbstract::DisableOnDisappear(AceType::RawPtr(node)); 1594 EXPECT_EQ(callback, nullptr); 1595 } 1596 1597 /** 1598 * @tc.name: ViewAbstractDisableOnAreaChangeByFrameNodeTest 1599 * @tc.desc: Test the operation of View_Abstract. 1600 * @tc.type: FUNC 1601 */ 1602 HWTEST_F(ViewAbstractTestNg, ViewAbstractDisableOnAreaChangeByFrameNodeTest, TestSize.Level1) 1603 { 1604 /** 1605 * @tc.steps: step1. create framenode and check callback; 1606 * @tc.expected: callback is not null. 1607 */ 1608 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1609 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1610 1611 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1612 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1613 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1614 ASSERT_NE(frameNode, nullptr); 1615 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1616 ASSERT_NE(node, nullptr); 1617 std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)> 1618 onAreaChangeCallback = __anonc7b1b4a21402(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1619 [](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {}; 1620 ViewAbstract::SetOnAreaChanged(AceType::RawPtr(node), std::move(onAreaChangeCallback)); 1621 auto eventHub = node->GetEventHub<EventHub>(); 1622 auto& callback = eventHub->onAreaChanged_; 1623 EXPECT_NE(callback, nullptr); 1624 1625 /** 1626 * @tc.steps: step2. Disable callback. 1627 * @tc.expected: callback is null. 1628 */ 1629 ViewAbstract::DisableOnAreaChange(AceType::RawPtr(node)); 1630 EXPECT_EQ(callback, nullptr); 1631 } 1632 1633 /** 1634 * @tc.name: ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest 1635 * @tc.desc: Test the operation of View_Abstract. 1636 * @tc.type: FUNC 1637 */ 1638 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnGestureJudgeBeiginByFrameNodeTest, TestSize.Level1) 1639 { 1640 /** 1641 * @tc.steps: step1. create framenode and check callback; 1642 * @tc.expected: callback is not null. 1643 */ 1644 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1645 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1646 1647 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1648 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1649 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1650 ASSERT_NE(frameNode, nullptr); 1651 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1652 ASSERT_NE(node, nullptr); 1653 GestureJudgeFunc onGestureJudgeCallback = [](const RefPtr<GestureInfo>& gestureInfo, __anonc7b1b4a21502(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1654 const std::shared_ptr<BaseGestureEvent>& info) { 1655 return GestureJudgeResult::REJECT; 1656 }; 1657 ViewAbstract::SetOnGestureJudgeBegin(AceType::RawPtr(node), std::move(onGestureJudgeCallback)); 1658 auto gestureHub = node->GetOrCreateGestureEventHub(); 1659 auto& callback = gestureHub->gestureJudgeFunc_; 1660 EXPECT_NE(callback, nullptr); 1661 } 1662 1663 /** 1664 * @tc.name: ViewAbstractSetOnSizeChangeByFrameNodeTest 1665 * @tc.desc: Test the operation of View_Abstract. 1666 * @tc.type: FUNC 1667 */ 1668 HWTEST_F(ViewAbstractTestNg, ViewAbstractSetOnSizeChangeByFrameNodeTest, TestSize.Level1) 1669 { 1670 /** 1671 * @tc.steps: step1. create framenode and check callback; 1672 * @tc.expected: callback is not null. 1673 */ 1674 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1675 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_CHILD); 1676 1677 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1678 EXPECT_EQ(strcmp(topFrameNodeOne->GetTag().c_str(), TAG_CHILD), 0); 1679 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1680 ASSERT_NE(frameNode, nullptr); 1681 auto node = AceType::DynamicCast<NG::FrameNode>(frameNode); 1682 ASSERT_NE(node, nullptr); 1683 std::function<void(const RectF& oldRect, const RectF& rect)> onSizeChangeCallback = [](const RectF& oldRect, __anonc7b1b4a21602(const RectF& oldRect, const RectF& rect) 1684 const RectF& rect) {}; 1685 ViewAbstract::SetOnSizeChanged(AceType::RawPtr(node), std::move(onSizeChangeCallback)); 1686 auto eventHub = node->GetEventHub<EventHub>(); 1687 auto& callback = eventHub->onSizeChanged_; 1688 EXPECT_NE(callback, nullptr); 1689 } 1690 1691 /** 1692 * @tc.name: MotionBlur001 1693 * @tc.desc: SetMotionBlur. 1694 * @tc.type: FUNC 1695 */ 1696 HWTEST_F(ViewAbstractTestNg, MotionBlur001, TestSize.Level1) 1697 { 1698 /** 1699 * @tc.steps: step1. create and put mainNode, then build some necessary params. 1700 */ 1701 ViewStackProcessor::GetInstance()->Push(FRAME_NODE_ROOT); 1702 1703 /** 1704 * @tc.steps: step2. get node in ViewStackProcessor. 1705 * @tc.expected: node is not null. 1706 */ 1707 auto rootFrameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode(); 1708 EXPECT_NE(rootFrameNode, nullptr); 1709 1710 /** 1711 * @tc.steps: step3. use ViewAbstract::SetMotionBlur. 1712 * @tc.expected: success set render property motionBlur value. 1713 */ 1714 MotionBlurOption motionBlurOption; 1715 motionBlurOption.radius = 5; 1716 motionBlurOption.anchor.x = 0.5; 1717 motionBlurOption.anchor.y = 0.5; 1718 ViewAbstract::SetMotionBlur(motionBlurOption); 1719 /** 1720 * @tc.steps: step4. get propMotionBlur value of the node. 1721 * @tc.expected: anchor.x = 0.5, anchor.y = 0.5, radius = 5. 1722 */ 1723 EXPECT_NE(FRAME_NODE_ROOT->GetRenderContext(), nullptr); 1724 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1725 ->GetOrCreateForeground()->propMotionBlur->anchor.x, 0.5); 1726 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1727 ->GetOrCreateForeground()->propMotionBlur->anchor.y, 0.5); 1728 EXPECT_EQ(FRAME_NODE_ROOT->GetRenderContext() 1729 ->GetOrCreateForeground()->propMotionBlur->radius, 5); 1730 1731 /** 1732 * @tc.steps: step5. finish view stack. 1733 */ 1734 ViewStackProcessor::GetInstance()->Finish(); 1735 } 1736 1737 /** 1738 * @tc.name: SetForegroundEffectTest 1739 * @tc.desc: Test the operation of setting foreground effect with different conditions. 1740 * @tc.type: FUNC 1741 */ 1742 HWTEST_F(ViewAbstractTestNg, SetForegroundEffectTest, TestSize.Level1) 1743 { 1744 /** 1745 * @tc.steps: Build a object viewAbstract and set visual state. 1746 */ 1747 ViewStackProcessor viewStackProcessor; 1748 int32_t index = 1; 1749 auto state = static_cast<VisualState>(index); 1750 viewStackProcessor.GetInstance()->SetVisualState(state); 1751 auto topFrameNodeOne = ViewStackProcessor::GetInstance()->GetMainElementNode(); 1752 auto frameNode = AceType::DynamicCast<FrameNode>(topFrameNodeOne); 1753 ASSERT_NE(frameNode, nullptr); 1754 1755 /** 1756 * @tc.steps: Build a object viewAbstract and set visual state. 1757 * @tc.expected: The foreground effect is not changed. 1758 */ 1759 auto originValue = frameNode->GetRenderContext()->GetForegroundEffect(); 1760 ViewAbstract::SetForegroundEffect(1.1f); 1761 ASSERT_NE(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f); 1762 ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), originValue); 1763 1764 /** 1765 * @tc.steps: Set visual state to null and check the current visual state process 1766 * @tc.expected: The foreground effect is changed as expected. 1767 */ 1768 ViewStackProcessor::GetInstance()->visualState_ = std::nullopt; 1769 ViewAbstract::SetForegroundEffect(1.1f); 1770 ASSERT_EQ(frameNode->GetRenderContext()->GetForegroundEffect(), 1.1f); 1771 } 1772 } // namespace OHOS::Ace::NG