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