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 #include "test/unittest/core/base/frame_node_test_ng.h" 16 17 #include "base/memory/ace_type.h" 18 #include "base/memory/referenced.h" 19 #include "frameworks/core/components_ng/pattern/image/image_pattern.h" 20 21 using namespace testing; 22 using namespace testing::ext; 23 24 namespace OHOS::Ace::NG { 25 namespace { 26 const PanDirection DRAG_DIRECTION = { PanDirection::LEFT }; 27 constexpr int32_t FINGERS_NUMBER = 2; 28 constexpr float DISTANCE = 10.5f; 29 constexpr float DEFAULT_OPACITY = 0.95f; 30 constexpr float PARA_OPACITY_VALUE_1 = 0.1f; 31 constexpr float PARA_OPACITY_VALUE_2 = 0.2f; 32 constexpr float PARA_OPACITY_VALUE_3 = 0.3f; 33 constexpr float PARA_OPACITY_VALUE_4 = 0.4f; 34 constexpr float PARA_OPACITY_VALUE_5 = 0.5f; 35 constexpr float PARA_OPACITY_VALUE_6 = 0.6f; 36 constexpr float PARA_OPACITY_VALUE_7 = 0.7f; 37 constexpr float PARA_OPACITY_VALUE_8 = 1.0f; 38 constexpr float MIN_OPACITY { 0.0f }; 39 constexpr float MAX_OPACITY { 1.0f }; 40 } // namespace 41 42 /** 43 * @tc.name: FrameNodeTestNg_TouchTest041 44 * @tc.desc: Test frameNode TouchTest 45 * @tc.type: FUNC 46 */ 47 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest041, TestSize.Level1) 48 { 49 /** 50 * @tc.steps: step1. construct TouchTest parameters. 51 */ 52 PointF globalPoint; 53 PointF parentLocalPoint; 54 TouchRestrict touchRestrict; 55 TouchTestResult result; 56 ResponseLinkResult responseLinkResult; 57 /** 58 * @tc.steps: step2. set isActive_ and debugEnabled_ is true and FRAME_NODE2 eventHub is HTMBLOCK. 59 * @tc.expected: expect The function return value is STOP_BUBBLING. 60 */ 61 FRAME_NODE2->isActive_ = true; 62 FRAME_NODE2->eventHub_->SetEnabled(true); 63 SystemProperties::debugEnabled_ = true; 64 auto eventHub = FRAME_NODE2->GetOrCreateGestureEventHub(); 65 eventHub->SetHitTestMode(HitTestMode::HTMBLOCK); 66 auto test = FRAME_NODE2->TouchTest( 67 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 68 EXPECT_EQ(test, HitTestResult::OUT_OF_REGION); 69 } 70 71 /** 72 * @tc.name: FrameNodeTestNg_TouchTest042 73 * @tc.desc: Test frameNode TouchTest 74 * @tc.type: FUNC 75 */ 76 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest042, TestSize.Level1) 77 { 78 /** 79 * @tc.steps: step1. construct TouchTest parameters. 80 */ 81 PointF globalPoint; 82 PointF parentLocalPoint; 83 TouchRestrict touchRestrict; 84 TouchTestResult result; 85 ResponseLinkResult responseLinkResult; 86 87 /** 88 * @tc.steps: step2. set debugEnabled_ is true. 89 */ 90 FRAME_NODE2->isActive_ = true; 91 FRAME_NODE2->eventHub_->SetEnabled(true); 92 SystemProperties::debugEnabled_ = true; 93 auto test = FRAME_NODE2->TouchTest( 94 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 95 96 /** 97 * @tc.steps: step3. create childnode. 98 */ 99 auto childNode = FrameNode::CreateFrameNode("main", 2, AceType::MakeRefPtr<Pattern>(), true); 100 childNode->SetExclusiveEventForChild(true); 101 auto mockRenderContextforChild = AceType::MakeRefPtr<MockRenderContext>(); 102 childNode->renderContext_ = mockRenderContextforChild; 103 auto localPoint = PointF(10, 10); 104 mockRenderContextforChild->rect_ = RectF(0, 0, 100, 100); 105 EXPECT_CALL(*mockRenderContextforChild, GetPointWithTransform(_)) 106 .WillRepeatedly(DoAll(SetArgReferee<0>(localPoint))); 107 auto childEventHub = childNode->GetOrCreateGestureEventHub(); 108 childEventHub->SetHitTestMode(HitTestMode::HTMBLOCK); 109 childNode->SetActive(true); 110 111 /** 112 * @tc.steps: step4. add childnode to the framenode. 113 * @tc.expected: expect The function return value is STOP_BUBBLING. 114 */ 115 std::list<RefPtr<FrameNode>> children; 116 children.push_back(childNode); 117 FRAME_NODE2->frameChildren_ = { children.begin(), children.end() }; 118 test = FRAME_NODE2->TouchTest( 119 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 120 EXPECT_EQ(test, HitTestResult::OUT_OF_REGION); 121 } 122 123 /** 124 * @tc.name: FrameNodeTestNg_TouchTest043 125 * @tc.desc: Test frameNode TouchTest 126 * @tc.type: FUNC 127 */ 128 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest043, TestSize.Level1) 129 { 130 /** 131 * @tc.steps: step1. construct TouchTest parameters. 132 */ 133 PointF globalPoint; 134 PointF parentLocalPoint; 135 TouchRestrict touchRestrict; 136 TouchTestResult result; 137 ResponseLinkResult responseLinkResult; 138 /** 139 * @tc.steps: step2. eventHub_->GetGestureEventHub() != nullptr and callback != null. 140 * @tc.expected: expect The function return value is STOP_BUBBLING. 141 */ 142 FRAME_NODE2->isActive_ = true; 143 FRAME_NODE2->eventHub_->SetEnabled(true); 144 SystemProperties::debugEnabled_ = true; __anon37c5be3c0202(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 145 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) { 146 return GestureJudgeResult::REJECT; 147 }; 148 auto gestureEventHub = FRAME_NODE2->eventHub_->GetOrCreateGestureEventHub(); 149 gestureEventHub->SetOnGestureJudgeBegin(gestureJudgeFunc); 150 auto test = FRAME_NODE2->TouchTest( 151 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 152 EXPECT_EQ(test, HitTestResult::OUT_OF_REGION); 153 } 154 155 /** 156 * @tc.name: FrameNodeTouchTest044 157 * @tc.desc: Test method TransferExecuteAction 158 * @tc.type: FUNC 159 */ 160 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest044, TestSize.Level1) 161 { 162 /** 163 * @tc.steps: step1. construct parameters. 164 */ 165 FRAME_NODE2->isActive_ = true; 166 FRAME_NODE2->eventHub_->SetEnabled(true); 167 SystemProperties::debugEnabled_ = true; 168 auto eventHub = FRAME_NODE2->GetOrCreateGestureEventHub(); 169 eventHub->SetHitTestMode(HitTestMode::HTMBLOCK); 170 std::map<std::string, std::string> actionArguments; 171 172 /** 173 * @tc.steps: step2. call TransferExecuteAction. 174 * @tc.expected: expect result is false. 175 */ 176 bool result = FRAME_NODE2->TransferExecuteAction(1, actionArguments, 1, 1); 177 EXPECT_FALSE(result); 178 } 179 180 /** 181 * @tc.name: FrameNodeTouchTest045 182 * @tc.desc: Test method GetUiExtensionId 183 * @tc.type: FUNC 184 */ 185 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest045, TestSize.Level1) 186 { 187 /** 188 * @tc.steps: step1. construct parameters. 189 */ 190 FRAME_NODE2->isActive_ = true; 191 FRAME_NODE2->eventHub_->SetEnabled(true); 192 SystemProperties::debugEnabled_ = true; 193 194 /** 195 * @tc.steps: step2. call GetUiExtensionId. 196 * @tc.expected: expect result is -1. 197 */ 198 int32_t result = FRAME_NODE2->GetUiExtensionId(); 199 EXPECT_EQ(result, -1); 200 } 201 202 /** 203 * @tc.name: FrameNodeTouchTest046 204 * @tc.desc: Test method WrapExtensionAbilityId 205 * @tc.type: FUNC 206 */ 207 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest046, TestSize.Level1) 208 { 209 /** 210 * @tc.steps: step1. construct parameters. 211 */ 212 FRAME_NODE2->isActive_ = true; 213 FRAME_NODE2->eventHub_->SetEnabled(true); 214 SystemProperties::debugEnabled_ = true; 215 216 int32_t extensionOffset = 1; 217 int32_t abilityId = 1; 218 219 /** 220 * @tc.steps: step2. call WrapExtensionAbilityId. 221 * @tc.expected: expect result is -1. 222 */ 223 int32_t result = FRAME_NODE2->WrapExtensionAbilityId(extensionOffset, abilityId); 224 EXPECT_EQ(result, -1); 225 } 226 227 /** 228 * @tc.name: FrameNodeTouchTest048 229 * @tc.desc: Test method DumpViewDataPageNode 230 * @tc.type: FUNC 231 */ 232 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest048, TestSize.Level1) 233 { 234 /** 235 * @tc.steps: step1. construct parameters. 236 */ 237 FRAME_NODE2->isActive_ = true; 238 FRAME_NODE2->eventHub_->SetEnabled(true); 239 SystemProperties::debugEnabled_ = true; 240 auto viewDataWrap = ViewDataWrap::CreateViewDataWrap(); 241 242 /** 243 * @tc.steps: step2. call DumpViewDataPageNode. 244 * @tc.expected: expect renderContext_ not nullptr. 245 */ 246 247 FRAME_NODE2->DumpViewDataPageNode(viewDataWrap); 248 EXPECT_NE(FRAME_NODE2->renderContext_, nullptr); 249 } 250 251 /** 252 * @tc.name: FrameNodeTouchTest049 253 * @tc.desc: Test method GetResponseRegionList 254 * @tc.type: FUNC 255 */ 256 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest049, TestSize.Level1) 257 { 258 /** 259 * @tc.steps: step1. construct parameters. 260 */ 261 FRAME_NODE2->isActive_ = true; 262 FRAME_NODE2->eventHub_->SetEnabled(true); 263 264 DimensionRect responseRect(Dimension(0), Dimension(0), DimensionOffset(OFFSETF)); 265 std::vector<DimensionRect> mouseResponseRegion; 266 mouseResponseRegion.emplace_back(responseRect); 267 268 /** 269 * @tc.steps: step2. call GetResponseRegionList. 270 * @tc.expected: expect MouseResponseRegion is not empty. 271 */ 272 auto gestureEventHub = FRAME_NODE2->eventHub_->GetOrCreateGestureEventHub(); 273 gestureEventHub->SetMouseResponseRegion(mouseResponseRegion); 274 275 auto paintRect = FRAME_NODE2->renderContext_->GetPaintRectWithoutTransform(); 276 FRAME_NODE2->GetResponseRegionList(paintRect, 1); 277 EXPECT_FALSE(gestureEventHub->GetMouseResponseRegion().empty()); 278 } 279 280 /** 281 * @tc.name: FrameNodeTouchTest050 282 * @tc.desc: Test method GetResponseRegionList 283 * @tc.type: FUNC 284 */ 285 HWTEST_F(FrameNodeTestNg, FrameNodeTouchTest050, TestSize.Level1) 286 { 287 /** 288 * @tc.steps: step1. construct parameters. 289 */ 290 FRAME_NODE2->isActive_ = true; 291 292 /** 293 * @tc.steps: step2. call GetResponseRegionList. 294 * @tc.expected: expect GetResponseRegion is not empty. 295 */ 296 std::vector<DimensionRect> responseRegion; 297 responseRegion.push_back(DimensionRect()); 298 auto gestureEventHub = FRAME_NODE2->eventHub_->GetOrCreateGestureEventHub(); 299 gestureEventHub->SetResponseRegion(responseRegion); 300 auto paintRect = FRAME_NODE2->renderContext_->GetPaintRectWithoutTransform(); 301 FRAME_NODE2->GetResponseRegionList(paintRect, 1); 302 EXPECT_FALSE(gestureEventHub->GetResponseRegion().empty()); 303 } 304 305 /** 306 * @tc.name: FrameNodeTestNg_DumpAdvanceInfo001 307 * @tc.desc: Test frame node method DumpAdvanceInfo 308 * @tc.type: FUNC 309 */ 310 HWTEST_F(FrameNodeTestNg, DumpAdvanceInfo001, TestSize.Level1) 311 { 312 /** 313 * @tc.steps: step1. initialize parameters. 314 */ 315 FRAME_NODE3->isActive_ = true; 316 FRAME_NODE3->eventHub_->SetEnabled(true); 317 SystemProperties::debugEnabled_ = true; 318 319 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 320 FRAME_NODE3->renderContext_ = mockRenderContext; 321 FRAME_NODE3->DumpInfo(); 322 323 /** 324 * @tc.steps: step2. initialize layoutProperty_ and call DumpAdvanceInfo. 325 * @tc.expected: expect DumpAdvanceInfo run ok. 326 */ 327 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 328 FRAME_NODE2->layoutProperty_ = layoutProperty; 329 FRAME_NODE3->layoutProperty_->geometryTransition_ = 330 ElementRegister::GetInstance()->GetOrCreateGeometryTransition("test", false, true); 331 FRAME_NODE3->DumpAdvanceInfo(); 332 EXPECT_NE(FRAME_NODE3->renderContext_, nullptr); 333 } 334 335 /** 336 * @tc.name: FrameNodeTestNg_GetOnChildTouchTestRet001 337 * @tc.desc: Test frame node method GetOnChildTouchTestRet 338 * @tc.type: FUNC 339 */ 340 HWTEST_F(FrameNodeTestNg, GetOnChildTouchTestRet001, TestSize.Level1) 341 { 342 /** 343 * @tc.steps: step1. initialize parameters. 344 */ 345 std::vector<TouchTestInfo> touchInfos; 346 TouchTestInfo info; 347 touchInfos.emplace_back(info); 348 349 TouchResult touchResult; 350 touchResult.strategy = TouchTestStrategy::DEFAULT; 351 touchResult.id = "test1"; 352 __anon37c5be3c0302(const std::vector<TouchTestInfo>& touchInfo) 353 OnChildTouchTestFunc callback = [](const std::vector<TouchTestInfo>& touchInfo) { 354 TouchResult res; 355 res.strategy = TouchTestStrategy::DEFAULT; 356 res.id = "test1"; 357 return res; 358 }; 359 360 /** 361 * @tc.steps: step2. set parent node and initialize gestureHub. 362 */ 363 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 364 auto gestureHub = GET_PARENT->GetOrCreateGestureEventHub(); 365 gestureHub->SetOnTouchTestFunc(std::move(callback)); 366 367 /** 368 * @tc.steps: step3. call GetOnChildTouchTestRet. 369 * @tc.expected: expect GetOnChildTouchTestRet run ok. 370 */ 371 TouchResult test = GET_PARENT->GetOnChildTouchTestRet(touchInfos); 372 EXPECT_EQ(test.id, touchResult.id); 373 } 374 375 /** 376 * @tc.name: FrameNodeTestNg_GetOnTouchTestFunc001 377 * @tc.desc: Test frame node method GetOnTouchTestFunc 378 * @tc.type: FUNC 379 */ 380 HWTEST_F(FrameNodeTestNg, GetOnTouchTestFunc001, TestSize.Level1) 381 { 382 /** 383 * @tc.steps: step1. set parent node and call GetOnTouchTestFunc. 384 */ 385 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 386 OnChildTouchTestFunc test = GET_PARENT->GetOnTouchTestFunc(); 387 388 /** 389 * @tc.expected: expect GetOnTouchTestFunc ruturn nullptr. 390 */ 391 EXPECT_EQ(test, nullptr); 392 __anon37c5be3c0402(const std::vector<TouchTestInfo>& touchInfo) 393 OnChildTouchTestFunc callback = [](const std::vector<TouchTestInfo>& touchInfo) { 394 TouchResult result; 395 return result; 396 }; 397 398 /** 399 * @tc.steps: step2. set parent node and initialize gestureHub. 400 */ 401 auto gestureHub = GET_PARENT->GetOrCreateGestureEventHub(); 402 gestureHub->SetOnTouchTestFunc(std::move(callback)); 403 404 /** 405 * @tc.steps: step3. call GetOnTouchTestFunc. 406 * @tc.expected: expect GetOnTouchTestFunc run ok. 407 */ 408 OnChildTouchTestFunc res = GET_PARENT->GetOnTouchTestFunc(); 409 EXPECT_NE(res, nullptr); 410 } 411 412 /** 413 * @tc.name: FrameNodeTestNg_GetDispatchFrameNode001 414 * @tc.desc: Test frame node method GetDispatchFrameNode 415 * @tc.type: FUNC 416 */ 417 HWTEST_F(FrameNodeTestNg, GetDispatchFrameNode001, TestSize.Level1) 418 { 419 /** 420 * @tc.steps: step1. creat node and generate a node tree. 421 */ 422 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 423 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 424 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 425 GET_CHILD1->UpdateInspectorId("child1"); 426 GET_CHILD2->UpdateInspectorId("child2"); 427 GET_PARENT->frameChildren_.insert(GET_CHILD1); 428 GET_PARENT->frameChildren_.insert(GET_CHILD2); 429 430 /** 431 * @tc.steps: step2. initialize parentEventHub and set HitTestMode. 432 */ 433 auto parentEventHub = GET_PARENT->GetOrCreateGestureEventHub(); 434 parentEventHub->SetHitTestMode(HitTestMode::HTMBLOCK); 435 TouchResult touchResult; 436 437 /** 438 * @tc.steps: step3. call GetDispatchFrameNode. 439 * @tc.expected: expect GetDispatchFrameNode ruturn nullptr. 440 */ 441 auto test = GET_PARENT->GetDispatchFrameNode(touchResult); 442 EXPECT_EQ(test, nullptr); 443 } 444 445 /** 446 * @tc.name: FrameNodeTestNg_GetDispatchFrameNode002 447 * @tc.desc: Test frame node method GetDispatchFrameNode 448 * @tc.type: FUNC 449 */ 450 HWTEST_F(FrameNodeTestNg, GetDispatchFrameNode002, TestSize.Level1) 451 { 452 /** 453 * @tc.steps: step1. creat node and generate a node tree. 454 */ 455 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 456 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 457 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 458 GET_CHILD1->UpdateInspectorId("child1"); 459 GET_CHILD2->UpdateInspectorId("child2"); 460 GET_PARENT->frameChildren_.insert(GET_CHILD1); 461 GET_PARENT->frameChildren_.insert(GET_CHILD2); 462 463 /** 464 * @tc.steps: step2. initialize parentEventHub, set HitTestMode and TouchTestStrategy. 465 */ 466 auto parentEventHub = GET_PARENT->GetOrCreateGestureEventHub(); 467 parentEventHub->SetHitTestMode(HitTestMode::HTMDEFAULT); 468 TouchResult touchResult; 469 touchResult.strategy = TouchTestStrategy::FORWARD_COMPETITION; 470 touchResult.id = "child1"; 471 472 /** 473 * @tc.steps: step3. call GetDispatchFrameNode. 474 * @tc.expected: expect GetDispatchFrameNode run ok. 475 */ 476 auto test = GET_PARENT->GetDispatchFrameNode(touchResult); 477 EXPECT_EQ(test, GET_CHILD1); 478 } 479 480 /** 481 * @tc.name: FrameNodeTestNg_GetDispatchFrameNode003 482 * @tc.desc: Test frame node method GetDispatchFrameNode 483 * @tc.type: FUNC 484 */ 485 HWTEST_F(FrameNodeTestNg, GetDispatchFrameNode003, TestSize.Level1) 486 { 487 /** 488 * @tc.steps: step1. creat node and generate a node tree. 489 */ 490 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 491 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 492 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 493 GET_CHILD1->UpdateInspectorId("child1"); 494 GET_CHILD2->UpdateInspectorId("child2"); 495 GET_PARENT->frameChildren_.insert(GET_CHILD1); 496 GET_PARENT->frameChildren_.insert(GET_CHILD2); 497 498 /** 499 * @tc.steps: step2. initialize parentEventHub, set HitTestMode and TouchTestStrategy. 500 */ 501 auto parentEventHub = GET_PARENT->GetOrCreateGestureEventHub(); 502 parentEventHub->SetHitTestMode(HitTestMode::HTMDEFAULT); 503 TouchResult touchResult; 504 touchResult.strategy = TouchTestStrategy::DEFAULT; 505 506 /** 507 * @tc.steps: step3. call GetDispatchFrameNode. 508 * @tc.expected: expect GetDispatchFrameNode ruturn nullptr. 509 */ 510 auto test = GET_PARENT->GetDispatchFrameNode(touchResult); 511 EXPECT_EQ(test, nullptr); 512 } 513 514 /** 515 * @tc.name: FrameNodeTestNg_CollectTouchInfos001 516 * @tc.desc: Test frame node method CollectTouchInfos 517 * @tc.type: FUNC 518 */ 519 HWTEST_F(FrameNodeTestNg, CollectTouchInfos001, TestSize.Level1) 520 { 521 /** 522 * @tc.steps: step1. initialize parameters. 523 */ 524 PointF globalPoint; 525 PointF parentRevertPoint; 526 std::vector<TouchTestInfo> touchInfos; 527 528 /** 529 * @tc.steps: step2. creat node and generate a node tree. 530 */ 531 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 532 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 533 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 534 GET_CHILD1->UpdateInspectorId("child1"); 535 GET_CHILD2->UpdateInspectorId("child2"); 536 GET_PARENT->frameChildren_.insert(GET_CHILD1); 537 GET_PARENT->frameChildren_.insert(GET_CHILD2); 538 __anon37c5be3c0502(const std::vector<TouchTestInfo>& touchInfo) 539 OnChildTouchTestFunc callback = [](const std::vector<TouchTestInfo>& touchInfo) { 540 TouchResult result; 541 return result; 542 }; 543 544 /** 545 * @tc.steps: step3. initialize gestureHub and set HitTestMode. 546 */ 547 auto gestureHub = GET_PARENT->GetOrCreateGestureEventHub(); 548 gestureHub->SetHitTestMode(HitTestMode::HTMDEFAULT); 549 gestureHub->SetOnTouchTestFunc(std::move(callback)); 550 551 /** 552 * @tc.steps: step4. call CollectTouchInfos. 553 * @tc.expected: expect CollectTouchInfos run ok. 554 */ 555 GET_PARENT->CollectTouchInfos(globalPoint, parentRevertPoint, touchInfos); 556 EXPECT_EQ(touchInfos.size(), 2); 557 } 558 559 /** 560 * @tc.name: FrameNodeTestNg_CollectTouchInfos002 561 * @tc.desc: Test frame node method CollectTouchInfos 562 * @tc.type: FUNC 563 */ 564 HWTEST_F(FrameNodeTestNg, CollectTouchInfos002, TestSize.Level1) 565 { 566 /** 567 * @tc.steps: step1. initialize parameters. 568 */ 569 PointF globalPoint; 570 PointF parentRevertPoint; 571 std::vector<TouchTestInfo> touchInfos; 572 573 /** 574 * @tc.steps: step2. creat node and generate a node tree. 575 */ 576 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 577 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 578 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 579 GET_CHILD1->UpdateInspectorId("child1"); 580 GET_CHILD2->UpdateInspectorId("child2"); 581 GET_PARENT->frameChildren_.insert(GET_CHILD1); 582 GET_PARENT->frameChildren_.insert(GET_CHILD2); 583 584 /** 585 * @tc.steps: step3. initialize gestureHub and set HitTestMode. 586 */ 587 auto gestureHub = GET_PARENT->GetOrCreateGestureEventHub(); 588 gestureHub->SetHitTestMode(HitTestMode::HTMBLOCK); 589 590 /** 591 * @tc.steps: step4. call CollectTouchInfos. 592 * @tc.expected: expect CollectTouchInfos return touchInfos.size is 0. 593 */ 594 GET_PARENT->CollectTouchInfos(globalPoint, parentRevertPoint, touchInfos); 595 EXPECT_EQ(touchInfos.size(), 0); 596 } 597 598 /** 599 * @tc.name: FrameNodeTestNg_CollectTouchInfos003 600 * @tc.desc: Test frame node method CollectTouchInfos 601 * @tc.type: FUNC 602 */ 603 HWTEST_F(FrameNodeTestNg, CollectTouchInfos003, TestSize.Level1) 604 { 605 /** 606 * @tc.steps: step1. initialize parameters. 607 */ 608 PointF globalPoint; 609 PointF parentRevertPoint; 610 std::vector<TouchTestInfo> touchInfos; 611 612 /** 613 * @tc.steps: step2. creat node and generate a node tree. 614 */ 615 const RefPtr<FrameNode> GET_PARENT = FrameNode::CreateFrameNode("parent", 4, AceType::MakeRefPtr<Pattern>()); 616 const RefPtr<FrameNode> GET_CHILD1 = FrameNode::CreateFrameNode("child1", 5, AceType::MakeRefPtr<Pattern>()); 617 const RefPtr<FrameNode> GET_CHILD2 = FrameNode::CreateFrameNode("child2", 6, AceType::MakeRefPtr<Pattern>()); 618 GET_CHILD1->UpdateInspectorId("child1"); 619 GET_CHILD2->UpdateInspectorId("child2"); 620 GET_PARENT->frameChildren_.insert(GET_CHILD1); 621 GET_PARENT->frameChildren_.insert(GET_CHILD2); 622 623 /** 624 * @tc.steps: step3. initialize gestureHub and set HitTestMode. 625 */ 626 auto gestureHub = GET_PARENT->GetOrCreateGestureEventHub(); 627 gestureHub->SetHitTestMode(HitTestMode::HTMDEFAULT); 628 629 /** 630 * @tc.steps: step4. call CollectTouchInfos. 631 * @tc.expected: expect CollectTouchInfos return touchInfos.size is 0. 632 */ 633 GET_PARENT->CollectTouchInfos(globalPoint, parentRevertPoint, touchInfos); 634 EXPECT_EQ(touchInfos.size(), 0); 635 } 636 637 /** 638 * @tc.name: FrameNodeTestNg_GetPreviewScaleVal001 639 * @tc.desc: Test frame node method GetPreviewScaleVal 640 * @tc.type: FUNC 641 */ 642 HWTEST_F(FrameNodeTestNg, GetPreviewScaleVal001, TestSize.Level1) 643 { 644 auto frameNode = FRAME_NODE; 645 /** 646 * @tc.steps: step1. initialize parameters. 647 */ 648 frameNode->isActive_ = true; 649 frameNode->eventHub_->SetEnabled(true); 650 SystemProperties::debugEnabled_ = true; 651 652 /** 653 * @tc.steps: step2. call GetPreviewScaleVal 654 * @tc.expected: expect GetPreviewScaleVal return scale value. 655 */ 656 auto geometryNode = frameNode->GetGeometryNode(); 657 geometryNode->SetFrameSize(CONTAINER_SIZE_ZERO); 658 EXPECT_FLOAT_EQ(frameNode->GetPreviewScaleVal(), 1.0f); 659 660 double screenWidth = 1216.0; 661 ScreenSystemManager::GetInstance().SetWindowInfo(screenWidth, 1.0, 1.0); 662 geometryNode->SetFrameSize(CONTAINER_SIZE_SMALL); 663 EXPECT_FLOAT_EQ(frameNode->GetPreviewScaleVal(), 1.0f); 664 665 /** 666 * @tc.steps: step3. set a large size and call GetPreviewScaleVal. 667 * @tc.expected: expect GetPreviewScaleVal return scale value. 668 */ 669 geometryNode->SetFrameSize(CONTAINER_SIZE_HUGE); 670 EXPECT_LT(frameNode->GetPreviewScaleVal(), 1.0f); 671 } 672 673 /** 674 * @tc.name: FrameNodeTestNg_GetPreviewScaleVal002 675 * @tc.desc: Test frame node method GetPreviewScaleVal 676 * @tc.type: FUNC 677 */ 678 HWTEST_F(FrameNodeTestNg, GetPreviewScaleVal002, TestSize.Level1) 679 { 680 auto frameNode = FRAME_NODE; 681 /** 682 * @tc.steps: step1. initialize parameters. 683 */ 684 frameNode->isActive_ = true; 685 frameNode->eventHub_->SetEnabled(true); 686 SystemProperties::debugEnabled_ = true; 687 688 /** 689 * @tc.steps: step2. set frame size to huge and drag preview options to disable scale then call GetPreviewScaleVal 690 * @tc.expected: expect GetPreviewScaleVal return scale value. 691 */ 692 auto geometryNode = frameNode->GetGeometryNode(); 693 geometryNode->SetFrameSize(CONTAINER_SIZE_HUGE); 694 NG::DragPreviewOption option { false }; 695 frameNode->SetDragPreviewOptions(option); 696 EXPECT_FLOAT_EQ(frameNode->GetPreviewScaleVal(), 1.0f); 697 698 /** 699 * @tc.steps: step3. set set drag preview options to auto and call GetPreviewScaleVal. 700 * @tc.expected: expect GetPreviewScaleVal return scale value. 701 */ 702 option = { true }; 703 frameNode->SetDragPreviewOptions(option); 704 EXPECT_LT(frameNode->GetPreviewScaleVal(), 1.0f); 705 } 706 707 /** 708 * @tc.name: FrameNodeTestNg_GetPreviewApplyVal001 709 * @tc.desc: Test frame node method GetPreviewApplyVal001 710 * @tc.type: FUNC 711 */ 712 HWTEST_F(FrameNodeTestNg, GetPreviewApplyVal001, TestSize.Level1) 713 { 714 auto frameNode = FRAME_NODE; 715 /** 716 * @tc.steps: step1. initialize parameters. 717 */ 718 frameNode->isActive_ = true; 719 frameNode->eventHub_->SetEnabled(true); 720 SystemProperties::debugEnabled_ = true; 721 722 /** 723 * @tc.steps: step2. set drag preview options and call GetDragPreviewOption. 724 * @tc.expected: expect GetDragPreviewOption return apply . 725 */ 726 auto geometryNode = frameNode->GetGeometryNode(); 727 geometryNode->SetFrameSize(CONTAINER_SIZE_HUGE); 728 NG::DragPreviewOption previewOption; __anon37c5be3c0602(WeakPtr<NG::FrameNode> frameNode) 729 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) {}; 730 frameNode->SetDragPreviewOptions(previewOption); 731 EXPECT_NE(frameNode->GetDragPreviewOption().onApply, nullptr); 732 } 733 734 /** 735 * @tc.name: FrameNodeTestNg_GetPreviewScaleVal003 736 * @tc.desc: Test frame node method GetPreviewScaleVal 737 * @tc.type: FUNC 738 */ 739 HWTEST_F(FrameNodeTestNg, GetPreviewScaleVal003, TestSize.Level1) 740 { 741 auto frameNode = FRAME_NODE_WEB_ETS_TAG; 742 /** 743 * @tc.steps: step1. initialize parameters. 744 */ 745 frameNode->isActive_ = true; 746 frameNode->eventHub_->SetEnabled(true); 747 SystemProperties::debugEnabled_ = true; 748 749 /** 750 * @tc.steps: step2. call GetPreviewScaleVal 751 * @tc.expected: expect GetPreviewScaleVal return scale value. 752 */ 753 auto geometryNode = frameNode->GetGeometryNode(); 754 geometryNode->SetFrameSize(CONTAINER_SIZE_HUGE); 755 756 EXPECT_FLOAT_EQ(frameNode->GetPreviewScaleVal(), 1.0f); 757 } 758 759 /** 760 * @tc.name: FrameNodeTestNg_IsPreviewNeedScale001 761 * @tc.desc: Test frame node method IsPreviewNeedScale 762 * @tc.type: FUNC 763 */ 764 HWTEST_F(FrameNodeTestNg, IsPreviewNeedScale001, TestSize.Level1) 765 { 766 auto frameNode = FRAME_NODE; 767 /** 768 * @tc.steps: step1. initialize parameters. 769 */ 770 FRAME_NODE->isActive_ = true; 771 FRAME_NODE->eventHub_->SetEnabled(true); 772 SystemProperties::debugEnabled_ = true; 773 774 /** 775 * @tc.steps: step2. call IsPreviewNeedScale 776 * @tc.expected: expect IsPreviewNeedScale return false. 777 */ 778 auto geometryNode = frameNode->GetGeometryNode(); 779 geometryNode->SetFrameSize(CONTAINER_SIZE_SMALL); 780 EXPECT_FALSE(FRAME_NODE->IsPreviewNeedScale()); 781 782 /** 783 * @tc.steps: step2. set a large size and call IsPreviewNeedScale. 784 * @tc.expected: expect IsPreviewNeedScale return true. 785 */ 786 geometryNode->SetFrameSize(CONTAINER_SIZE_HUGE); 787 EXPECT_TRUE(FRAME_NODE->IsPreviewNeedScale()); 788 } 789 790 /** 791 * @tc.name: FrameNodeTestNg_GetOffsetInScreen001 792 * @tc.desc: Test frame node method GetOffsetInScreen 793 * @tc.type: FUNC 794 */ 795 HWTEST_F(FrameNodeTestNg, GetOffsetInScreen001, TestSize.Level1) 796 { 797 /** 798 * @tc.steps: step1. initialize parameters. 799 */ 800 FRAME_NODE->isActive_ = true; 801 FRAME_NODE->eventHub_->SetEnabled(true); 802 SystemProperties::debugEnabled_ = true; 803 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 804 ASSERT_NE(mockRenderContext, nullptr); 805 mockRenderContext->rect_ = RectF(DEFAULT_X, DEFAULT_Y, DEFAULT_X, DEFAULT_Y); 806 FRAME_NODE->renderContext_ = mockRenderContext; 807 808 /** 809 * @tc.steps: step2. call GetOffsetInScreen. 810 * @tc.expected: expect GetOffsetInScreen return the result which is not (0, 0). 811 */ 812 EXPECT_EQ(FRAME_NODE->GetOffsetInScreen(), OffsetF(0.0f, 0.0f)); 813 } 814 815 /** 816 * @tc.name: FrameNodeTestNg_GetPixelMap001 817 * @tc.desc: Test frame node method GetPixelMap 818 * @tc.type: FUNC 819 */ 820 HWTEST_F(FrameNodeTestNg, GetPixelMap001, TestSize.Level1) 821 { 822 /** 823 * @tc.steps: step1. initialize parameters. 824 */ 825 FRAME_NODE->isActive_ = true; 826 FRAME_NODE->eventHub_->SetEnabled(true); 827 SystemProperties::debugEnabled_ = true; 828 auto gestureHub = FRAME_NODE->GetOrCreateGestureEventHub(); 829 ASSERT_NE(gestureHub, nullptr); 830 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 831 ASSERT_NE(mockRenderContext, nullptr); 832 FRAME_NODE->renderContext_ = mockRenderContext; 833 834 /** 835 * @tc.steps: step2. Don't initialize pixelMap and rosenNode. 836 * @tc.expected: expect GetPixelMap() == nullptr. 837 */ 838 EXPECT_EQ(FRAME_NODE->GetPixelMap(), nullptr); 839 840 /** 841 * @tc.steps: step3. set a pixelMap of gestureHub, and call GetPixelMap. 842 * @tc.expected: expect GetPixelMap() != nullptr. 843 */ 844 void* voidPtr = static_cast<void*>(new char[0]); 845 RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr); 846 ASSERT_NE(pixelMap, nullptr); 847 gestureHub->SetPixelMap(pixelMap); 848 EXPECT_NE(FRAME_NODE->GetPixelMap(), nullptr); 849 850 /** 851 * @tc.steps: step4. set a pixelMap of the renderContext, and call GetPixelMap. 852 * @tc.expected: expect GetPixelMap() != nullptr. 853 */ 854 gestureHub->SetPixelMap(nullptr); 855 EXPECT_EQ(FRAME_NODE->GetPixelMap(), nullptr); 856 } 857 858 /** 859 * @tc.name: FindChildByNameTest001 860 * @tc.desc: Test FindChildByName with one tree 861 * @tc.type: FUNC 862 */ 863 HWTEST_F(FrameNodeTestNg, FindChildByNameTest001, TestSize.Level1) 864 { 865 /** 866 * @tc.steps: step1. Create frameNode and set the parent and children. 867 */ 868 const std::string parentNodeName = "nodeParent"; 869 const std::string thisNodeName = "nodeThis"; 870 const std::string childrenNodeName = "nodeChildren"; 871 const std::string testChildNodeName = "test"; 872 auto nodeParent = FrameNode::CreateFrameNode(parentNodeName, 10, AceType::MakeRefPtr<Pattern>(), true); 873 auto nodeThis = FrameNode::CreateFrameNode(thisNodeName, 20, AceType::MakeRefPtr<Pattern>()); 874 auto nodeChildren = FrameNode::CreateFrameNode(childrenNodeName, 30, AceType::MakeRefPtr<Pattern>()); 875 876 /** 877 * @tc.steps: step1. Set the node's relation. 878 */ 879 nodeParent->AddChild(nodeThis); 880 nodeParent->AddChild(nodeChildren); 881 882 /** 883 * @tc.steps: step3. Init inspectorId. 884 */ 885 nodeParent->UpdateInspectorId(parentNodeName); 886 nodeChildren->UpdateInspectorId(childrenNodeName); 887 nodeThis->UpdateInspectorId(thisNodeName); 888 889 /** 890 * @tc.steps: step4. Traversal the frameNodeTree. 891 */ 892 auto finalResult = FrameNode::FindChildByName(nodeParent, childrenNodeName); 893 EXPECT_EQ(finalResult, nodeChildren); 894 895 auto noChildResult = FrameNode::FindChildByName(nodeParent, testChildNodeName); 896 EXPECT_EQ(noChildResult, nullptr); 897 898 nodeParent->Clean(); 899 auto noHaveResult = FrameNode::FindChildByName(nodeParent, childrenNodeName); 900 EXPECT_EQ(noHaveResult, nullptr); 901 } 902 903 /** 904 * @tc.name: FindChildByNameTest002 905 * @tc.desc: Test FindChildByName with two tree 906 * @tc.type: FUNC 907 */ 908 HWTEST_F(FrameNodeTestNg, FindChildByNameTest002, TestSize.Level1) 909 { 910 /** 911 * @tc.steps: step1. Create frameNode and set the parent and children. 912 */ 913 const std::string parentNodeName = "nodeParent"; 914 const std::string nodeOneName = "nodeOne"; 915 const std::string nodeOneChildName = "nodeOneChildren"; 916 const std::string nodeTwoName = "nodeTwo"; 917 const std::string nodeTwoChildName = "nodeTwoChildren"; 918 const std::string testChildNodeName = "test"; 919 auto nodeParent = FrameNode::CreateFrameNode(parentNodeName, 10, AceType::MakeRefPtr<Pattern>(), true); 920 auto nodeOne = FrameNode::CreateFrameNode(nodeOneName, 20, AceType::MakeRefPtr<Pattern>()); 921 auto nodeOneChildren = FrameNode::CreateFrameNode(nodeOneChildName, 30, AceType::MakeRefPtr<Pattern>()); 922 auto nodeTwo = FrameNode::CreateFrameNode(nodeTwoName, 40, AceType::MakeRefPtr<Pattern>()); 923 auto nodeTwoChildren = FrameNode::CreateFrameNode(nodeTwoChildName, 50, AceType::MakeRefPtr<Pattern>()); 924 925 /** 926 * @tc.steps: step1. Set the node's relation. 927 */ 928 nodeParent->AddChild(nodeOne); 929 nodeParent->AddChild(nodeTwo); 930 nodeOne->AddChild(nodeOneChildren); 931 nodeTwo->AddChild(nodeTwoChildren); 932 933 /** 934 * @tc.steps: step3. Init inspectorId. 935 */ 936 nodeParent->UpdateInspectorId(parentNodeName); 937 nodeOne->UpdateInspectorId(nodeOneName); 938 nodeOneChildren->UpdateInspectorId(nodeOneChildName); 939 nodeTwo->UpdateInspectorId(nodeTwoName); 940 nodeTwoChildren->UpdateInspectorId(nodeTwoChildName); 941 942 /** 943 * @tc.steps: step4. Traversal the frameNodeTree. 944 */ 945 auto finalResult = FrameNode::FindChildByName(nodeParent, nodeOneChildName); 946 EXPECT_EQ(finalResult, nodeOneChildren); 947 948 auto noChildResult = FrameNode::FindChildByName(nodeParent, testChildNodeName); 949 EXPECT_EQ(noChildResult, nullptr); 950 951 nodeParent->Clean(); 952 auto noHaveResult = FrameNode::FindChildByName(nodeParent, nodeTwoChildName); 953 EXPECT_EQ(noHaveResult, nullptr); 954 } 955 956 /** 957 * @tc.name: SetOnSizeChangeCallback001 958 * @tc.desc: Test SetOnSizeChangeCallback 959 * @tc.type: FUNC 960 */ 961 HWTEST_F(FrameNodeTestNg, SetOnSizeChangeCallback001, TestSize.Level1) 962 { 963 /** 964 * @tc.steps: step1. build a object to SetOnSizeChangeCallback 965 * @tc.expected: expect cover branch lastFrameNodeRect_ non null and function is run ok. 966 */ __anon37c5be3c0702(const RectF& oldRect, const RectF& rect) 967 OnSizeChangedFunc callback = [](const RectF& oldRect, const RectF& rect) {}; 968 FRAME_NODE2->SetOnSizeChangeCallback(std::move(callback)); 969 EXPECT_NE(FRAME_NODE2->lastFrameNodeRect_, nullptr); 970 auto eventHub = FRAME_NODE2->GetEventHub<NG::EventHub>(); 971 EXPECT_NE(eventHub, nullptr); 972 EXPECT_TRUE(eventHub->HasOnSizeChanged()); 973 974 /** 975 * @tc.steps: step2.test while callback is nullptr 976 * @tc.expected:expect cover branch lastFrameNodeRect_ non null and function is run ok. 977 */ 978 FRAME_NODE2->lastFrameNodeRect_ = std::make_unique<RectF>(); 979 FRAME_NODE2->SetOnSizeChangeCallback(nullptr); 980 EXPECT_NE(FRAME_NODE2->lastFrameNodeRect_, nullptr); 981 EXPECT_NE(eventHub, nullptr); 982 EXPECT_FALSE(eventHub->HasOnSizeChanged()); 983 } 984 985 /** 986 * @tc.name: TriggerOnSizeChangeCallback001 987 * @tc.desc: Test frame node method 988 * @tc.type: FUNC 989 */ 990 HWTEST_F(FrameNodeTestNg, TriggerOnSizeChangeCallback001, TestSize.Level1) 991 { 992 /** 993 * @tc.steps: step1. set a flag and init a callback(onSizeChanged) 994 */ 995 bool flag = false; __anon37c5be3c0802(const RectF& oldRect, const RectF& rect) 996 OnSizeChangedFunc onSizeChanged = [&flag](const RectF& oldRect, const RectF& rect) { flag = !flag; }; 997 998 /** 999 * @tc.steps: step2. call TriggerOnSizeChangeCallback before set callback 1000 * @tc.expected: expect flag is still false 1001 */ 1002 FRAME_NODE2->TriggerOnSizeChangeCallback(); 1003 EXPECT_FALSE(flag); 1004 1005 /** 1006 * @tc.steps: step3.set callback and release lastFrameNodeRect_ 1007 * @tc.expected: expect flag is still false 1008 */ 1009 FRAME_NODE2->eventHub_->SetOnSizeChanged(std::move(onSizeChanged)); 1010 FRAME_NODE2->lastFrameNodeRect_ = nullptr; 1011 FRAME_NODE2->TriggerOnSizeChangeCallback(); 1012 EXPECT_FALSE(flag); 1013 1014 /** 1015 * @tc.steps: step4.set lastFrameNodeRect_ 1016 * @tc.expected: expect flag is still false 1017 */ 1018 FRAME_NODE2->lastFrameNodeRect_ = std::make_unique<RectF>(); 1019 FRAME_NODE2->TriggerOnSizeChangeCallback(); 1020 EXPECT_FALSE(flag); 1021 } 1022 1023 /** 1024 * @tc.name: OnTouchInterceptTest001 1025 * @tc.desc: Test onTouchIntercept method 1026 * @tc.type: FUNC 1027 */ 1028 HWTEST_F(FrameNodeTestNg, OnTouchInterceptTest001, TestSize.Level1) 1029 { 1030 /** 1031 * @tc.steps: step1. construct TouchTest parameters. 1032 */ 1033 PointF globalPoint; 1034 PointF parentLocalPoint; 1035 TouchRestrict touchRestrict; 1036 TouchTestResult result; 1037 ResponseLinkResult responseLinkResult; 1038 1039 /** 1040 * @tc.steps: step2. create node and set callback. 1041 */ 1042 auto childNode = FrameNode::CreateFrameNode("main", 2, AceType::MakeRefPtr<Pattern>(), true); 1043 childNode->SetExclusiveEventForChild(true); 1044 auto mockRenderContextforChild = AceType::MakeRefPtr<MockRenderContext>(); 1045 childNode->renderContext_ = mockRenderContextforChild; 1046 auto localPoint = PointF(10, 10); 1047 mockRenderContextforChild->rect_ = RectF(0, 0, 100, 100); 1048 EXPECT_CALL(*mockRenderContextforChild, GetPointWithTransform(_)) 1049 .WillRepeatedly(DoAll(SetArgReferee<0>(localPoint))); 1050 auto childEventHub = childNode->GetOrCreateGestureEventHub(); 1051 childEventHub->SetHitTestMode(HitTestMode::HTMBLOCK); 1052 childNode->SetActive(true); 1053 EXPECT_NE(childNode->eventHub_->GetGestureEventHub(), nullptr); __anon37c5be3c0902(TouchEventInfo& event) 1054 auto callback = [](TouchEventInfo& event) -> HitTestMode { return HitTestMode::HTMNONE; }; 1055 childEventHub->SetOnTouchIntercept(callback); 1056 1057 /** 1058 * @tc.steps: step3. trigger touch test. 1059 * @tc.expected: expect the touch test mode is correct. 1060 */ 1061 HitTestMode hitTestModeofChilds[] = { HitTestMode::HTMDEFAULT, HitTestMode::HTMBLOCK, HitTestMode::HTMTRANSPARENT, 1062 HitTestMode::HTMNONE, HitTestMode::HTMTRANSPARENT_SELF }; 1063 int32_t i = 0; 1064 for (auto hitTestModeofChild : hitTestModeofChilds) { 1065 childEventHub->SetHitTestMode(hitTestModeofChild); 1066 childNode->TouchTest( 1067 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 1068 auto mode = childEventHub->GetHitTestMode(); 1069 EXPECT_EQ(mode, hitTestModeofChilds[i++]); 1070 } 1071 1072 /** 1073 * @tc.steps: step4. modify callback and trigger touch test. 1074 * @tc.expected: expect the touch test mode is correct. 1075 */ 1076 i = 0; __anon37c5be3c0a02(TouchEventInfo& event) 1077 auto blockCallback = [](TouchEventInfo& event) -> HitTestMode { return HitTestMode::HTMBLOCK; }; 1078 childEventHub->SetOnTouchIntercept(blockCallback); 1079 for (auto hitTestModeofChild : hitTestModeofChilds) { 1080 childEventHub->SetHitTestMode(hitTestModeofChild); 1081 childNode->TouchTest( 1082 globalPoint, parentLocalPoint, parentLocalPoint, touchRestrict, result, 1, responseLinkResult); 1083 auto mode = childEventHub->GetHitTestMode(); 1084 EXPECT_EQ(mode, hitTestModeofChilds[i++]); 1085 } 1086 } 1087 1088 /** 1089 * @tc.name: FrameNodeTestNg0040 1090 * @tc.desc: Test frame node method 1091 * @tc.type: FUNC 1092 */ 1093 HWTEST_F(FrameNodeTestNg, FrameNodeTestNg0040, TestSize.Level1) 1094 { 1095 auto frameNode = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 1096 std::set<std::string> allowDropSet; 1097 frameNode->SetAllowDrop(allowDropSet); 1098 std::set<std::string> allowDrop = frameNode->GetAllowDrop(); 1099 EXPECT_TRUE(allowDrop.empty()); 1100 } 1101 1102 /** 1103 * @tc.name: FrameNodeTestNg0050 1104 * @tc.desc: Test frame node method 1105 * @tc.type: FUNC 1106 */ 1107 HWTEST_F(FrameNodeTestNg, FrameNodeTestNg0050, TestSize.Level1) 1108 { 1109 auto context = PipelineContext::GetCurrentContext(); 1110 ASSERT_NE(context, nullptr); 1111 auto node = FrameNode::CreateFrameNode("main", 1, AceType::MakeRefPtr<Pattern>(), true); 1112 ASSERT_NE(node, nullptr); 1113 node->GetOrCreateGestureEventHub(); 1114 node->AttachContext(AceType::RawPtr(context)); 1115 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1116 node->renderContext_ = mockRenderContext; 1117 EXPECT_EQ(node->context_, AceType::RawPtr(context)); 1118 1119 node->DetachContext(true); 1120 EXPECT_EQ(node->context_, nullptr); 1121 } 1122 1123 /** 1124 * @tc.name: FrameNodeTestNg_GetPositionToScreen001 1125 * @tc.desc: Test frame node method GetPositionToScreen 1126 * @tc.type: FUNC 1127 */ 1128 HWTEST_F(FrameNodeTestNg, GetPositionToScreen001, TestSize.Level1) 1129 { 1130 OffsetF Offset = { 0, 0 }; 1131 FRAME_NODE2->SetParent(FRAME_NODE3); 1132 auto screenOffset = FRAME_NODE2->GetPositionToScreen(); 1133 EXPECT_EQ(screenOffset, Offset); 1134 } 1135 1136 /** 1137 * @tc.name: FrameNodeTestNg_GetPositionToParentWithTransform001 1138 * @tc.desc: Test frame node method GetPositionToParentWithTransform 1139 * @tc.type: FUNC 1140 */ 1141 HWTEST_F(FrameNodeTestNg, GetPositionToParentWithTransform001, TestSize.Level1) 1142 { 1143 OffsetF Offset = { 0, 0 }; 1144 FRAME_NODE2->SetParent(FRAME_NODE3); 1145 auto parentOffsetWithTransform = FRAME_NODE2->GetPositionToParentWithTransform(); 1146 EXPECT_EQ(parentOffsetWithTransform, Offset); 1147 } 1148 1149 /** 1150 * @tc.name: FrameNodeTestNg_GetPositionToParentWithTransform001 1151 * @tc.desc: Test frame node method GetPositionToParentWithTransform 1152 * @tc.type: FUNC 1153 */ 1154 HWTEST_F(FrameNodeTestNg, GetPositionToScreenWithTransform001, TestSize.Level1) 1155 { 1156 OffsetF Offset = { 0, 0 }; 1157 FRAME_NODE2->SetParent(FRAME_NODE3); 1158 auto screenOffsetWithTransform = FRAME_NODE2->GetPositionToScreenWithTransform(); 1159 EXPECT_EQ(screenOffsetWithTransform, Offset); 1160 } 1161 1162 /** 1163 * @tc.name: FrameNodeTestNg_GetPositionToWindowWithTransform001 1164 * @tc.desc: Test frame node method GetPositionToWindowWithTransform 1165 * @tc.type: FUNC 1166 */ 1167 HWTEST_F(FrameNodeTestNg, GetPositionToWindowWithTransform001, TestSize.Level1) 1168 { 1169 OffsetF Offset = { 0, 0 }; 1170 FRAME_NODE2->SetParent(FRAME_NODE3); 1171 auto windowOffsetWithTransform = FRAME_NODE2->GetPositionToWindowWithTransform(); 1172 EXPECT_EQ(windowOffsetWithTransform, Offset); 1173 } 1174 1175 /** 1176 * @tc.name: GetPreviewOptionFromModifier001 1177 * @tc.desc: Test UpdatePreviewOptionFromModifier 1178 * @tc.type: FUNC 1179 * @tc.author: 1180 */ 1181 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier001, TestSize.Level1) 1182 { 1183 /** 1184 * @tc.steps: step1. Create FrameNode. 1185 */ 1186 auto frameNode = FrameNode::CreateFrameNode( 1187 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1188 EXPECT_NE(frameNode, nullptr); 1189 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1190 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1191 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1192 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1193 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1194 /** 1195 * @tc.steps: step2. get DragPreviewOption. 1196 */ 1197 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1198 /** 1199 * @tc.steps: step3. set opacity. 1200 */ 1201 dragPreviewOption.options.opacity = -50.0f; 1202 frameNode->SetDragPreviewOptions(dragPreviewOption); 1203 /** 1204 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1205 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1206 */ 1207 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1208 dragPreviewOption = frameNode->GetDragPreviewOption(); 1209 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1210 } 1211 1212 /** 1213 * @tc.name: GetPreviewOptionFromModifier002 1214 * @tc.desc: Test UpdatePreviewOptionFromModifier 1215 * @tc.type: FUNC 1216 * @tc.author: 1217 */ 1218 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier002, TestSize.Level1) 1219 { 1220 /** 1221 * @tc.steps: step1. Create FrameNode. 1222 */ 1223 auto frameNode = FrameNode::CreateFrameNode( 1224 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1225 EXPECT_NE(frameNode, nullptr); 1226 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1227 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1228 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1229 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1230 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1231 /** 1232 * @tc.steps: step2. get DragPreviewOption. 1233 */ 1234 NG::DragPreviewOption previewOption; __anon37c5be3c0b02(WeakPtr<NG::FrameNode> frameNode) 1235 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1236 auto node = frameNode.Upgrade(); 1237 CHECK_NULL_VOID(node); 1238 if ((PARA_OPACITY_VALUE_1 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_1 > MIN_OPACITY)) { 1239 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_1); 1240 } else { 1241 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1242 } 1243 }; 1244 /** 1245 * @tc.steps: step3. set opacity. 1246 */ 1247 frameNode->SetDragPreviewOptions(previewOption); 1248 /** 1249 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1250 * @tc.expected: opacity in DragPreviewOption is equal to 0.1f. 1251 */ 1252 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1253 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.1f); 1254 } 1255 1256 /** 1257 * @tc.name: GetPreviewOptionFromModifier003 1258 * @tc.desc: Test UpdatePreviewOptionFromModifier 1259 * @tc.type: FUNC 1260 * @tc.author: 1261 */ 1262 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier003, TestSize.Level1) 1263 { 1264 /** 1265 * @tc.steps: step1. Create FrameNode. 1266 */ 1267 auto frameNode = FrameNode::CreateFrameNode( 1268 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1269 EXPECT_NE(frameNode, nullptr); 1270 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1271 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1272 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1273 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1274 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1275 /** 1276 * @tc.steps: step2. get DragPreviewOption. 1277 */ 1278 NG::DragPreviewOption previewOption; __anon37c5be3c0c02(WeakPtr<NG::FrameNode> frameNode) 1279 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1280 auto node = frameNode.Upgrade(); 1281 CHECK_NULL_VOID(node); 1282 if ((PARA_OPACITY_VALUE_2 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_2 > MIN_OPACITY)) { 1283 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_2); 1284 } else { 1285 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1286 } 1287 }; 1288 /** 1289 * @tc.steps: step3. set opacity. 1290 */ 1291 frameNode->SetDragPreviewOptions(previewOption); 1292 /** 1293 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1294 * @tc.expected: opacity in DragPreviewOption is equal to 0.2f. 1295 */ 1296 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1297 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.2f); 1298 } 1299 1300 /** 1301 * @tc.name: GetPreviewOptionFromModifier004 1302 * @tc.desc: Test UpdatePreviewOptionFromModifier 1303 * @tc.type: FUNC 1304 * @tc.author: 1305 */ 1306 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier004, TestSize.Level1) 1307 { 1308 /** 1309 * @tc.steps: step1. Create FrameNode. 1310 */ 1311 auto frameNode = FrameNode::CreateFrameNode( 1312 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1313 EXPECT_NE(frameNode, nullptr); 1314 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1315 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1316 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1317 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1318 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1319 /** 1320 * @tc.steps: step2. get DragPreviewOption. 1321 */ 1322 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1323 /** 1324 * @tc.steps: step3. set opacity. 1325 */ 1326 dragPreviewOption.options.opacity = 0.0f; 1327 frameNode->SetDragPreviewOptions(dragPreviewOption); 1328 /** 1329 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1330 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1331 */ 1332 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1333 dragPreviewOption = frameNode->GetDragPreviewOption(); 1334 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1335 } 1336 1337 /** 1338 * @tc.name: GetPreviewOptionFromModifier005 1339 * @tc.desc: Test UpdatePreviewOptionFromModifier 1340 * @tc.type: FUNC 1341 * @tc.author: 1342 */ 1343 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier005, TestSize.Level1) 1344 { 1345 /** 1346 * @tc.steps: step1. Create FrameNode. 1347 */ 1348 auto frameNode = FrameNode::CreateFrameNode( 1349 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1350 EXPECT_NE(frameNode, nullptr); 1351 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1352 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1353 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1354 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1355 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1356 /** 1357 * @tc.steps: step2. get DragPreviewOption. 1358 */ 1359 NG::DragPreviewOption previewOption; __anon37c5be3c0d02(WeakPtr<NG::FrameNode> frameNode) 1360 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1361 auto node = frameNode.Upgrade(); 1362 CHECK_NULL_VOID(node); 1363 if ((PARA_OPACITY_VALUE_3 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_3 > MIN_OPACITY)) { 1364 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_3); 1365 } else { 1366 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1367 } 1368 }; 1369 /** 1370 * @tc.steps: step3. set opacity. 1371 */ 1372 frameNode->SetDragPreviewOptions(previewOption); 1373 /** 1374 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1375 * @tc.expected: opacity in DragPreviewOption is equal to 0.3f. 1376 */ 1377 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1378 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.3f); 1379 } 1380 1381 /** 1382 * @tc.name: GetPreviewOptionFromModifier006 1383 * @tc.desc: Test UpdatePreviewOptionFromModifier 1384 * @tc.type: FUNC 1385 * @tc.author: 1386 */ 1387 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier006, TestSize.Level1) 1388 { 1389 /** 1390 * @tc.steps: step1. Create FrameNode. 1391 */ 1392 auto frameNode = FrameNode::CreateFrameNode( 1393 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1394 EXPECT_NE(frameNode, nullptr); 1395 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1396 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1397 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1398 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1399 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1400 /** 1401 * @tc.steps: step2. get DragPreviewOption. 1402 */ 1403 NG::DragPreviewOption previewOption; __anon37c5be3c0e02(WeakPtr<NG::FrameNode> frameNode) 1404 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1405 auto node = frameNode.Upgrade(); 1406 CHECK_NULL_VOID(node); 1407 if ((PARA_OPACITY_VALUE_4 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_4 > MIN_OPACITY)) { 1408 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_4); 1409 } else { 1410 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1411 } 1412 }; 1413 /** 1414 * @tc.steps: step3. set opacity. 1415 */ 1416 frameNode->SetDragPreviewOptions(previewOption); 1417 /** 1418 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1419 * @tc.expected: opacity in DragPreviewOption is equal to 0.4f. 1420 */ 1421 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1422 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.4f); 1423 } 1424 1425 /** 1426 * @tc.name: GetPreviewOptionFromModifier007 1427 * @tc.desc: Test UpdatePreviewOptionFromModifier 1428 * @tc.type: FUNC 1429 * @tc.author: 1430 */ 1431 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier007, TestSize.Level1) 1432 { 1433 /** 1434 * @tc.steps: step1. Create FrameNode. 1435 */ 1436 auto frameNode = FrameNode::CreateFrameNode( 1437 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1438 EXPECT_NE(frameNode, nullptr); 1439 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1440 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1441 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1442 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1443 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1444 /** 1445 * @tc.steps: step2. get DragPreviewOption. 1446 */ 1447 NG::DragPreviewOption previewOption; __anon37c5be3c0f02(WeakPtr<NG::FrameNode> frameNode) 1448 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1449 auto node = frameNode.Upgrade(); 1450 CHECK_NULL_VOID(node); 1451 if ((PARA_OPACITY_VALUE_5 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_5 > MIN_OPACITY)) { 1452 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_5); 1453 } else { 1454 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1455 } 1456 }; 1457 /** 1458 * @tc.steps: step3. set opacity. 1459 */ 1460 frameNode->SetDragPreviewOptions(previewOption); 1461 /** 1462 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1463 * @tc.expected: opacity in DragPreviewOption is equal to 0.5f. 1464 */ 1465 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1466 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.5f); 1467 } 1468 1469 /** 1470 * @tc.name: GetPreviewOptionFromModifier008 1471 * @tc.desc: Test UpdatePreviewOptionFromModifier 1472 * @tc.type: FUNC 1473 * @tc.author: 1474 */ 1475 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier008, TestSize.Level1) 1476 { 1477 /** 1478 * @tc.steps: step1. Create FrameNode. 1479 */ 1480 auto frameNode = FrameNode::CreateFrameNode( 1481 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1482 EXPECT_NE(frameNode, nullptr); 1483 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1484 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1485 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1486 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1487 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1488 /** 1489 * @tc.steps: step2. get DragPreviewOption. 1490 */ 1491 NG::DragPreviewOption previewOption; __anon37c5be3c1002(WeakPtr<NG::FrameNode> frameNode) 1492 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1493 auto node = frameNode.Upgrade(); 1494 CHECK_NULL_VOID(node); 1495 if ((PARA_OPACITY_VALUE_6 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_6 > MIN_OPACITY)) { 1496 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_6); 1497 } else { 1498 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1499 } 1500 }; 1501 /** 1502 * @tc.steps: step3. set opacity. 1503 */ 1504 frameNode->SetDragPreviewOptions(previewOption); 1505 /** 1506 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1507 * @tc.expected: opacity in DragPreviewOption is equal to 0.6f. 1508 */ 1509 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1510 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.6f); 1511 } 1512 1513 /** 1514 * @tc.name: GetPreviewOptionFromModifier009 1515 * @tc.desc: Test UpdatePreviewOptionFromModifier 1516 * @tc.type: FUNC 1517 * @tc.author: 1518 */ 1519 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier009, TestSize.Level1) 1520 { 1521 /** 1522 * @tc.steps: step1. Create FrameNode. 1523 */ 1524 auto frameNode = FrameNode::CreateFrameNode( 1525 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1526 EXPECT_NE(frameNode, nullptr); 1527 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1528 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1529 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1530 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1531 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1532 /** 1533 * @tc.steps: step2. get DragPreviewOption. 1534 */ 1535 NG::DragPreviewOption previewOption; __anon37c5be3c1102(WeakPtr<NG::FrameNode> frameNode) 1536 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1537 auto node = frameNode.Upgrade(); 1538 CHECK_NULL_VOID(node); 1539 if ((PARA_OPACITY_VALUE_7 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_7 > MIN_OPACITY)) { 1540 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_7); 1541 } else { 1542 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1543 } 1544 }; 1545 /** 1546 * @tc.steps: step3. set opacity. 1547 */ 1548 frameNode->SetDragPreviewOptions(previewOption); 1549 /** 1550 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1551 * @tc.expected: opacity in DragPreviewOption is equal to 0.7f. 1552 */ 1553 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1554 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 0.7f); 1555 } 1556 1557 /** 1558 * @tc.name: GetPreviewOptionFromModifier010 1559 * @tc.desc: Test UpdatePreviewOptionFromModifier 1560 * @tc.type: FUNC 1561 * @tc.author: 1562 */ 1563 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier010, TestSize.Level1) 1564 { 1565 /** 1566 * @tc.steps: step1. Create FrameNode. 1567 */ 1568 auto frameNode = FrameNode::CreateFrameNode( 1569 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1570 EXPECT_NE(frameNode, nullptr); 1571 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1572 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1573 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1574 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1575 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1576 /** 1577 * @tc.steps: step2. get DragPreviewOption. 1578 */ 1579 NG::DragPreviewOption previewOption; __anon37c5be3c1202(WeakPtr<NG::FrameNode> frameNode) 1580 previewOption.onApply = [](WeakPtr<NG::FrameNode> frameNode) { 1581 auto node = frameNode.Upgrade(); 1582 CHECK_NULL_VOID(node); 1583 if ((PARA_OPACITY_VALUE_8 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_8 > MIN_OPACITY)) { 1584 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_8); 1585 } else { 1586 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1587 } 1588 }; 1589 /** 1590 * @tc.steps: step3. set opacity. 1591 */ 1592 frameNode->SetDragPreviewOptions(previewOption); 1593 /** 1594 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1595 * @tc.expected: opacity in DragPreviewOption is equal to 1.0f. 1596 */ 1597 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1598 EXPECT_EQ(frameNode->GetDragPreviewOption().options.opacity, 1.0f); 1599 } 1600 1601 /** 1602 * @tc.name: GetPreviewOptionFromModifier011 1603 * @tc.desc: Test UpdatePreviewOptionFromModifier 1604 * @tc.type: FUNC 1605 * @tc.author: 1606 */ 1607 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier011, TestSize.Level1) 1608 { 1609 /** 1610 * @tc.steps: step1. Create FrameNode. 1611 */ 1612 auto frameNode = FrameNode::CreateFrameNode( 1613 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1614 EXPECT_NE(frameNode, nullptr); 1615 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1616 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1617 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1618 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1619 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1620 /** 1621 * @tc.steps: step2. get DragPreviewOption. 1622 */ 1623 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1624 /** 1625 * @tc.steps: step3. set opacity. 1626 */ 1627 dragPreviewOption.options.opacity = 2.0f; 1628 frameNode->SetDragPreviewOptions(dragPreviewOption); 1629 /** 1630 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1631 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1632 */ 1633 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1634 dragPreviewOption = frameNode->GetDragPreviewOption(); 1635 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1636 } 1637 1638 /** 1639 * @tc.name: GetPreviewOptionFromModifier012 1640 * @tc.desc: Test UpdatePreviewOptionFromModifier 1641 * @tc.type: FUNC 1642 * @tc.author: 1643 */ 1644 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier012, TestSize.Level1) 1645 { 1646 /** 1647 * @tc.steps: step1. Create FrameNode. 1648 */ 1649 auto frameNode = FrameNode::CreateFrameNode( 1650 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1651 EXPECT_NE(frameNode, nullptr); 1652 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1653 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1654 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1655 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1656 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1657 /** 1658 * @tc.steps: step2. get DragPreviewOption. 1659 */ 1660 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1661 /** 1662 * @tc.steps: step3. set opacity. 1663 */ 1664 dragPreviewOption.options.opacity = 50.0f; 1665 frameNode->SetDragPreviewOptions(dragPreviewOption); 1666 /** 1667 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1668 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1669 */ 1670 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1671 dragPreviewOption = frameNode->GetDragPreviewOption(); 1672 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1673 } 1674 1675 /** 1676 * @tc.name: GetPreviewOptionFromModifier013 1677 * @tc.desc: Test UpdatePreviewOptionFromModifier 1678 * @tc.type: FUNC 1679 * @tc.author: 1680 */ 1681 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier013, TestSize.Level1) 1682 { 1683 /** 1684 * @tc.steps: step1. Create FrameNode. 1685 */ 1686 auto frameNode = FrameNode::CreateFrameNode( 1687 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1688 EXPECT_NE(frameNode, nullptr); 1689 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1690 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1691 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1692 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1693 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1694 /** 1695 * @tc.steps: step2. get DragPreviewOption. 1696 */ 1697 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1698 /** 1699 * @tc.steps: step3. set opacity. 1700 */ 1701 dragPreviewOption.options.opacity = 60.0f; 1702 frameNode->SetDragPreviewOptions(dragPreviewOption); 1703 /** 1704 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1705 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1706 */ 1707 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1708 dragPreviewOption = frameNode->GetDragPreviewOption(); 1709 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1710 } 1711 1712 /** 1713 * @tc.name: GetPreviewOptionFromModifier014 1714 * @tc.desc: Test UpdatePreviewOptionFromModifier 1715 * @tc.type: FUNC 1716 * @tc.author: 1717 */ 1718 HWTEST_F(FrameNodeTestNg, GetPreviewOptionFromModifier014, TestSize.Level1) 1719 { 1720 /** 1721 * @tc.steps: step1. Create FrameNode. 1722 */ 1723 auto frameNode = FrameNode::CreateFrameNode( 1724 V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<ImagePattern>()); 1725 EXPECT_NE(frameNode, nullptr); 1726 auto eventHub = AceType::MakeRefPtr<EventHub>(); 1727 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1728 auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub))); 1729 auto dragEventActuator = AceType::MakeRefPtr<DragEventActuator>( 1730 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), DRAG_DIRECTION, FINGERS_NUMBER, DISTANCE); 1731 /** 1732 * @tc.steps: step2. get DragPreviewOption. 1733 */ 1734 auto dragPreviewOption = frameNode->GetDragPreviewOption(); 1735 /** 1736 * @tc.steps: step3. set opacity. 1737 */ 1738 dragPreviewOption.options.opacity = -60.0f; 1739 frameNode->SetDragPreviewOptions(dragPreviewOption); 1740 /** 1741 * @tc.steps: step4. call UpdatePreviewOptionFromModifier 1742 * @tc.expected: opacity in DragPreviewOption is equal to 0.95f. 1743 */ 1744 dragEventActuator->UpdatePreviewOptionFromModifier(frameNode); 1745 dragPreviewOption = frameNode->GetDragPreviewOption(); 1746 EXPECT_EQ(dragPreviewOption.options.opacity, 0.95f); 1747 } 1748 } // namespace OHOS::Ace::NG