1 /* 2 * Copyright (c) 2025 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 <optional> 17 18 #include "gtest/gtest.h" 19 20 #include "test/mock/base/mock_drag_window.h" 21 #include "test/mock/core/common/mock_container.h" 22 #include "test/mock/core/common/mock_interaction_interface.h" 23 #include "test/mock/core/pipeline/mock_pipeline_context.h" 24 25 #include "base/image/pixel_map.h" 26 #include "base/memory/ace_type.h" 27 #include "base/memory/referenced.h" 28 #include "base/subwindow/subwindow_manager.h" 29 #include "core/common/interaction/interaction_interface.h" 30 #include "core/components/common/layout/grid_system_manager.h" 31 #include "core/components_ng/base/frame_node.h" 32 #include "core/components_ng/base/geometry_node.h" 33 #include "core/components_ng/base/ui_node.h" 34 #include "core/components_ng/event/event_hub.h" 35 #include "core/components_ng/manager/drag_drop/drag_drop_func_wrapper.h" 36 #include "core/components_ng/manager/drag_drop/drag_drop_manager.h" 37 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h" 38 39 using namespace testing; 40 using namespace testing::ext; 41 namespace OHOS::Ace::NG { 42 namespace { 43 RefPtr<DragWindow> MOCK_DRAG_WINDOW; 44 constexpr float DEFAULT_OPACITY = 0.95f; 45 constexpr float PARA_OPACITY_VALUE_1 = 0.3f; 46 constexpr float PARA_OPACITY_VALUE_2 = 0.0f; 47 constexpr float PARA_OPACITY_VALUE_3 = 0.5f; 48 constexpr float PARA_OPACITY_VALUE_4 = 0.7f; 49 constexpr float PARA_OPACITY_VALUE_5 = 1.0f; 50 constexpr float PARA_OPACITY_VALUE_6 = 10.0f; 51 constexpr float PARA_OPACITY_VALUE_7 = 50.0f; 52 constexpr float PARA_OPACITY_VALUE_8 = -50.0f; 53 54 constexpr float PARA_OPACITY_VALUE_9 = 0.1f; 55 constexpr float PARA_OPACITY_VALUE_10 = 0.2f; 56 constexpr float PARA_OPACITY_VALUE_11 = 0.4f; 57 constexpr float PARA_OPACITY_VALUE_12 = 0.6f; 58 constexpr float PARA_OPACITY_VALUE_13 = 0.8f; 59 constexpr float PARA_OPACITY_VALUE_14 = 0.9f; 60 constexpr float PARA_OPACITY_VALUE_15 = 1.1f; 61 constexpr float PARA_OPACITY_VALUE_16 = 1.2f; 62 constexpr float PARA_OPACITY_VALUE_17 = 1.3f; 63 constexpr float PARA_OPACITY_VALUE_18 = 1.4f; 64 constexpr float PARA_OPACITY_VALUE_19 = 1.5f; 65 constexpr float PARA_OPACITY_VALUE_20 = 1.6f; 66 constexpr float PARA_OPACITY_VALUE_21 = 1.7f; 67 constexpr float PARA_OPACITY_VALUE_22 = 1.8f; 68 constexpr float PARA_OPACITY_VALUE_23 = 1.9f; 69 constexpr float PARA_OPACITY_VALUE_24 = 2.0f; 70 constexpr float PARA_OPACITY_VALUE_25 = 2.1f; 71 constexpr float PARA_OPACITY_VALUE_26 = 2.2f; 72 constexpr float PARA_OPACITY_VALUE_27 = 2.3f; 73 constexpr float PARA_OPACITY_VALUE_28 = 2.4f; 74 constexpr float PARA_OPACITY_VALUE_29 = 2.5f; 75 constexpr float PARA_OPACITY_VALUE_30 = 2.6f; 76 constexpr float PARA_OPACITY_VALUE_31 = 2.7f; 77 constexpr float PARA_OPACITY_VALUE_32 = 2.8f; 78 constexpr float PARA_OPACITY_VALUE_33 = 2.9f; 79 constexpr float PARA_OPACITY_VALUE_34 = 3.0f; 80 constexpr float PARA_OPACITY_VALUE_35 = 3.1f; 81 constexpr float PARA_OPACITY_VALUE_36 = 3.2f; 82 constexpr float PARA_OPACITY_VALUE_37 = 3.3f; 83 constexpr float PARA_OPACITY_VALUE_38 = 3.4f; 84 constexpr float PARA_OPACITY_VALUE_39 = 3.5f; 85 constexpr float PARA_OPACITY_VALUE_40 = 3.6f; 86 constexpr float PARA_OPACITY_VALUE_41 = 3.7f; 87 constexpr float PARA_OPACITY_VALUE_42 = 3.8f; 88 constexpr float PARA_OPACITY_VALUE_43 = 3.9f; 89 constexpr float PARA_OPACITY_VALUE_44 = 4.0f; 90 constexpr float PARA_OPACITY_VALUE_45 = 4.1f; 91 constexpr float PARA_OPACITY_VALUE_46 = 4.2f; 92 constexpr float PARA_OPACITY_VALUE_47 = 4.3f; 93 constexpr float PARA_OPACITY_VALUE_48 = 4.4f; 94 constexpr float PARA_OPACITY_VALUE_49 = 4.5f; 95 constexpr float PARA_OPACITY_VALUE_50 = 4.6f; 96 constexpr float PARA_OPACITY_VALUE_51 = 4.7f; 97 constexpr float PARA_OPACITY_VALUE_52 = 4.8f; 98 constexpr float PARA_OPACITY_VALUE_53 = 4.9f; 99 constexpr float PARA_OPACITY_VALUE_54 = 5.0f; 100 101 constexpr float MIN_OPACITY { 0.0f }; 102 constexpr float MAX_OPACITY { 1.0f }; 103 } // namespace 104 105 class DragDropFuncWrapperTestNg : public testing::Test { 106 public: 107 static void SetUpTestCase(); 108 static void TearDownTestCase(); 109 }; 110 SetUpTestCase()111 void DragDropFuncWrapperTestNg::SetUpTestCase() 112 { 113 MockPipelineContext::SetUp(); 114 MockContainer::SetUp(); 115 MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0); 116 } 117 TearDownTestCase()118 void DragDropFuncWrapperTestNg::TearDownTestCase() 119 { 120 MockPipelineContext::TearDown(); 121 MockContainer::TearDown(); 122 MOCK_DRAG_WINDOW = nullptr; 123 } 124 125 /** 126 * @tc.name: DragDropFuncWrapperTest001 127 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 128 * @tc.type: FUNC 129 * @tc.author: 130 */ 131 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest001, TestSize.Level1) 132 { 133 /** 134 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.3f 135 */ __anon3073c4e50202(WeakPtr<NG::FrameNode> frameNode) 136 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 137 auto node = frameNode.Upgrade(); 138 CHECK_NULL_VOID(node); 139 if ((PARA_OPACITY_VALUE_1 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_1 > MIN_OPACITY)) { 140 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_1); 141 } else { 142 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 143 } 144 }; 145 146 /** 147 * @tc.steps: step2. construct a DragPreviewOption object 148 */ 149 NG::DragPreviewOption option; 150 151 /** 152 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 153 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.3f. 154 */ 155 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 156 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_1); 157 } 158 159 /** 160 * @tc.name: DragDropFuncWrapperTest002 161 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 162 * @tc.type: FUNC 163 * @tc.author: 164 */ 165 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest002, TestSize.Level1) 166 { 167 /** 168 * @tc.steps: step1. construct a lambda function, don't set drag preview opacity 169 */ __anon3073c4e50302(WeakPtr<NG::FrameNode> frameNode) 170 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {}; 171 172 /** 173 * @tc.steps: step2. construct a DragPreviewOption object 174 */ 175 NG::DragPreviewOption option; 176 177 /** 178 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 179 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 180 */ 181 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 182 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 183 } 184 185 /** 186 * @tc.name: DragDropFuncWrapperTest003 187 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 188 * @tc.type: FUNC 189 * @tc.author: 190 */ 191 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest003, TestSize.Level1) 192 { 193 /** 194 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.0f 195 */ __anon3073c4e50402(WeakPtr<NG::FrameNode> frameNode) 196 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 197 auto node = frameNode.Upgrade(); 198 CHECK_NULL_VOID(node); 199 if ((PARA_OPACITY_VALUE_2 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_2 > MIN_OPACITY)) { 200 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_2); 201 } else { 202 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 203 } 204 }; 205 206 /** 207 * @tc.steps: step2. construct a DragPreviewOption object 208 */ 209 NG::DragPreviewOption option; 210 211 /** 212 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 213 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 214 */ 215 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 216 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 217 } 218 219 /** 220 * @tc.name: DragDropFuncWrapperTest004 221 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 222 * @tc.type: FUNC 223 * @tc.author: 224 */ 225 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest004, TestSize.Level1) 226 { 227 /** 228 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.5f 229 */ __anon3073c4e50502(WeakPtr<NG::FrameNode> frameNode) 230 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 231 auto node = frameNode.Upgrade(); 232 CHECK_NULL_VOID(node); 233 if ((PARA_OPACITY_VALUE_3 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_3 > MIN_OPACITY)) { 234 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_3); 235 } else { 236 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 237 } 238 }; 239 240 /** 241 * @tc.steps: step2. construct a DragPreviewOption object 242 */ 243 NG::DragPreviewOption option; 244 245 /** 246 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 247 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.5f. 248 */ 249 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 250 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_3); 251 } 252 253 /** 254 * @tc.name: DragDropFuncWrapperTest005 255 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 256 * @tc.type: FUNC 257 * @tc.author: 258 */ 259 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest005, TestSize.Level1) 260 { 261 /** 262 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.7f 263 */ __anon3073c4e50602(WeakPtr<NG::FrameNode> frameNode) 264 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 265 auto node = frameNode.Upgrade(); 266 CHECK_NULL_VOID(node); 267 if ((PARA_OPACITY_VALUE_4 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_4 > MIN_OPACITY)) { 268 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_4); 269 } else { 270 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 271 } 272 }; 273 274 /** 275 * @tc.steps: step2. construct a DragPreviewOption object 276 */ 277 NG::DragPreviewOption option; 278 279 /** 280 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 281 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.7f. 282 */ 283 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 284 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_4); 285 } 286 287 /** 288 * @tc.name: DragDropFuncWrapperTest006 289 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 290 * @tc.type: FUNC 291 * @tc.author: 292 */ 293 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest006, TestSize.Level1) 294 { 295 /** 296 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.0f 297 */ __anon3073c4e50702(WeakPtr<NG::FrameNode> frameNode) 298 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 299 auto node = frameNode.Upgrade(); 300 CHECK_NULL_VOID(node); 301 if ((PARA_OPACITY_VALUE_5 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_5 > MIN_OPACITY)) { 302 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_5); 303 } else { 304 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 305 } 306 }; 307 308 /** 309 * @tc.steps: step2. construct a DragPreviewOption object 310 */ 311 NG::DragPreviewOption option; 312 313 /** 314 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 315 * @tc.expected: step3. opacity in DragPreviewOption is equal to 1.0f. 316 */ 317 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 318 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_5); 319 } 320 321 /** 322 * @tc.name: DragDropFuncWrapperTest007 323 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 324 * @tc.type: FUNC 325 * @tc.author: 326 */ 327 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest007, TestSize.Level1) 328 { 329 /** 330 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 10.0f 331 */ __anon3073c4e50802(WeakPtr<NG::FrameNode> frameNode) 332 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 333 auto node = frameNode.Upgrade(); 334 CHECK_NULL_VOID(node); 335 if ((PARA_OPACITY_VALUE_6 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_6 > MIN_OPACITY)) { 336 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_6); 337 } else { 338 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 339 } 340 }; 341 342 /** 343 * @tc.steps: step2. construct a DragPreviewOption object 344 */ 345 NG::DragPreviewOption option; 346 347 /** 348 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 349 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 350 */ 351 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 352 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 353 } 354 355 /** 356 * @tc.name: DragDropFuncWrapperTest008 357 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 358 * @tc.type: FUNC 359 * @tc.author: 360 */ 361 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest008, TestSize.Level1) 362 { 363 /** 364 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 50.0f 365 */ __anon3073c4e50902(WeakPtr<NG::FrameNode> frameNode) 366 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 367 auto node = frameNode.Upgrade(); 368 CHECK_NULL_VOID(node); 369 if ((PARA_OPACITY_VALUE_7 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_7 > MIN_OPACITY)) { 370 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_7); 371 } else { 372 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 373 } 374 }; 375 376 /** 377 * @tc.steps: step2. construct a DragPreviewOption object 378 */ 379 NG::DragPreviewOption option; 380 381 /** 382 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 383 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 384 */ 385 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 386 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 387 } 388 389 /** 390 * @tc.name: DragDropFuncWrapperTest009 391 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 392 * @tc.type: FUNC 393 * @tc.author: 394 */ 395 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest009, TestSize.Level1) 396 { 397 /** 398 * @tc.steps: step1. construct a lambda function, set drag preview opacity is -50.0f 399 */ __anon3073c4e50a02(WeakPtr<NG::FrameNode> frameNode) 400 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 401 auto node = frameNode.Upgrade(); 402 CHECK_NULL_VOID(node); 403 if ((PARA_OPACITY_VALUE_8 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_8 > MIN_OPACITY)) { 404 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_8); 405 } else { 406 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 407 } 408 }; 409 410 /** 411 * @tc.steps: step2. construct a DragPreviewOption object 412 */ 413 NG::DragPreviewOption option; 414 415 /** 416 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 417 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 418 */ 419 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 420 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 421 } 422 423 /** 424 * @tc.name: DragDropFuncWrapperTest010 425 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 426 * @tc.type: FUNC 427 * @tc.author: 428 */ 429 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest010, TestSize.Level1) 430 { 431 /** 432 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.1f 433 */ __anon3073c4e50b02(WeakPtr<NG::FrameNode> frameNode) 434 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 435 auto node = frameNode.Upgrade(); 436 CHECK_NULL_VOID(node); 437 if ((PARA_OPACITY_VALUE_9 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_9 > MIN_OPACITY)) { 438 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_9); 439 } else { 440 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 441 } 442 }; 443 444 /** 445 * @tc.steps: step2. construct a DragPreviewOption object 446 */ 447 NG::DragPreviewOption option; 448 449 /** 450 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 451 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.1f. 452 */ 453 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 454 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_9); 455 } 456 457 /** 458 * @tc.name: DragDropFuncWrapperTest011 459 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 460 * @tc.type: FUNC 461 * @tc.author: 462 */ 463 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest011, TestSize.Level1) 464 { 465 /** 466 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.2f 467 */ __anon3073c4e50c02(WeakPtr<NG::FrameNode> frameNode) 468 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 469 auto node = frameNode.Upgrade(); 470 CHECK_NULL_VOID(node); 471 if ((PARA_OPACITY_VALUE_10 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_10 > MIN_OPACITY)) { 472 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_10); 473 } else { 474 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 475 } 476 }; 477 478 /** 479 * @tc.steps: step2. construct a DragPreviewOption object 480 */ 481 NG::DragPreviewOption option; 482 483 /** 484 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 485 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.2f. 486 */ 487 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 488 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_10); 489 } 490 491 /** 492 * @tc.name: DragDropFuncWrapperTest012 493 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 494 * @tc.type: FUNC 495 * @tc.author: 496 */ 497 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest012, TestSize.Level1) 498 { 499 /** 500 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.4f 501 */ __anon3073c4e50d02(WeakPtr<NG::FrameNode> frameNode) 502 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 503 auto node = frameNode.Upgrade(); 504 CHECK_NULL_VOID(node); 505 if ((PARA_OPACITY_VALUE_11 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_11 > MIN_OPACITY)) { 506 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_11); 507 } else { 508 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 509 } 510 }; 511 512 /** 513 * @tc.steps: step2. construct a DragPreviewOption object 514 */ 515 NG::DragPreviewOption option; 516 517 /** 518 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 519 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.4f. 520 */ 521 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 522 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_11); 523 } 524 525 /** 526 * @tc.name: DragDropFuncWrapperTest013 527 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 528 * @tc.type: FUNC 529 * @tc.author: 530 */ 531 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest013, TestSize.Level1) 532 { 533 /** 534 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.6f 535 */ __anon3073c4e50e02(WeakPtr<NG::FrameNode> frameNode) 536 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 537 auto node = frameNode.Upgrade(); 538 CHECK_NULL_VOID(node); 539 if ((PARA_OPACITY_VALUE_12 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_12 > MIN_OPACITY)) { 540 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_12); 541 } else { 542 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 543 } 544 }; 545 546 /** 547 * @tc.steps: step2. construct a DragPreviewOption object 548 */ 549 NG::DragPreviewOption option; 550 551 /** 552 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 553 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.6f. 554 */ 555 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 556 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_12); 557 } 558 559 /** 560 * @tc.name: DragDropFuncWrapperTest014 561 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 562 * @tc.type: FUNC 563 * @tc.author: 564 */ 565 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest014, TestSize.Level1) 566 { 567 /** 568 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.8f 569 */ __anon3073c4e50f02(WeakPtr<NG::FrameNode> frameNode) 570 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 571 auto node = frameNode.Upgrade(); 572 CHECK_NULL_VOID(node); 573 if ((PARA_OPACITY_VALUE_13 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_13 > MIN_OPACITY)) { 574 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_13); 575 } else { 576 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 577 } 578 }; 579 580 /** 581 * @tc.steps: step2. construct a DragPreviewOption object 582 */ 583 NG::DragPreviewOption option; 584 585 /** 586 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 587 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.8f. 588 */ 589 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 590 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_13); 591 } 592 593 /** 594 * @tc.name: DragDropFuncWrapperTest015 595 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 596 * @tc.type: FUNC 597 * @tc.author: 598 */ 599 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest015, TestSize.Level1) 600 { 601 /** 602 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.9f 603 */ __anon3073c4e51002(WeakPtr<NG::FrameNode> frameNode) 604 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 605 auto node = frameNode.Upgrade(); 606 CHECK_NULL_VOID(node); 607 if ((PARA_OPACITY_VALUE_14 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_14 > MIN_OPACITY)) { 608 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_14); 609 } else { 610 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 611 } 612 }; 613 614 /** 615 * @tc.steps: step2. construct a DragPreviewOption object 616 */ 617 NG::DragPreviewOption option; 618 619 /** 620 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 621 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.9f. 622 */ 623 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 624 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_14); 625 } 626 627 /** 628 * @tc.name: DragDropFuncWrapperTest016 629 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 630 * @tc.type: FUNC 631 * @tc.author: 632 */ 633 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest016, TestSize.Level1) 634 { 635 /** 636 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.1f 637 */ __anon3073c4e51102(WeakPtr<NG::FrameNode> frameNode) 638 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 639 auto node = frameNode.Upgrade(); 640 CHECK_NULL_VOID(node); 641 if ((PARA_OPACITY_VALUE_15 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_15 > MIN_OPACITY)) { 642 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_15); 643 } else { 644 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 645 } 646 }; 647 648 /** 649 * @tc.steps: step2. construct a DragPreviewOption object 650 */ 651 NG::DragPreviewOption option; 652 653 /** 654 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 655 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 656 */ 657 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 658 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 659 } 660 661 /** 662 * @tc.name: DragDropFuncWrapperTest017 663 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 664 * @tc.type: FUNC 665 * @tc.author: 666 */ 667 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest017, TestSize.Level1) 668 { 669 /** 670 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.2f 671 */ __anon3073c4e51202(WeakPtr<NG::FrameNode> frameNode) 672 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 673 auto node = frameNode.Upgrade(); 674 CHECK_NULL_VOID(node); 675 if ((PARA_OPACITY_VALUE_16 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_16 > MIN_OPACITY)) { 676 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_16); 677 } else { 678 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 679 } 680 }; 681 682 /** 683 * @tc.steps: step2. construct a DragPreviewOption object 684 */ 685 NG::DragPreviewOption option; 686 687 /** 688 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 689 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 690 */ 691 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 692 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 693 } 694 695 /** 696 * @tc.name: DragDropFuncWrapperTest018 697 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 698 * @tc.type: FUNC 699 * @tc.author: 700 */ 701 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest018, TestSize.Level1) 702 { 703 /** 704 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.3f 705 */ __anon3073c4e51302(WeakPtr<NG::FrameNode> frameNode) 706 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 707 auto node = frameNode.Upgrade(); 708 CHECK_NULL_VOID(node); 709 if ((PARA_OPACITY_VALUE_17 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_17 > MIN_OPACITY)) { 710 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_17); 711 } else { 712 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 713 } 714 }; 715 716 /** 717 * @tc.steps: step2. construct a DragPreviewOption object 718 */ 719 NG::DragPreviewOption option; 720 721 /** 722 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 723 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 724 */ 725 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 726 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 727 } 728 729 /** 730 * @tc.name: DragDropFuncWrapperTest019 731 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 732 * @tc.type: FUNC 733 * @tc.author: 734 */ 735 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest019, TestSize.Level1) 736 { 737 /** 738 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.4f 739 */ __anon3073c4e51402(WeakPtr<NG::FrameNode> frameNode) 740 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 741 auto node = frameNode.Upgrade(); 742 CHECK_NULL_VOID(node); 743 if ((PARA_OPACITY_VALUE_18 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_18 > MIN_OPACITY)) { 744 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_18); 745 } else { 746 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 747 } 748 }; 749 750 /** 751 * @tc.steps: step2. construct a DragPreviewOption object 752 */ 753 NG::DragPreviewOption option; 754 755 /** 756 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 757 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 758 */ 759 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 760 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 761 } 762 763 /** 764 * @tc.name: DragDropFuncWrapperTest020 765 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 766 * @tc.type: FUNC 767 * @tc.author: 768 */ 769 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest020, TestSize.Level1) 770 { 771 /** 772 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.5f 773 */ __anon3073c4e51502(WeakPtr<NG::FrameNode> frameNode) 774 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 775 auto node = frameNode.Upgrade(); 776 CHECK_NULL_VOID(node); 777 if ((PARA_OPACITY_VALUE_19 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_19 > MIN_OPACITY)) { 778 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_19); 779 } else { 780 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 781 } 782 }; 783 784 /** 785 * @tc.steps: step2. construct a DragPreviewOption object 786 */ 787 NG::DragPreviewOption option; 788 789 /** 790 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 791 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 792 */ 793 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 794 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 795 } 796 797 /** 798 * @tc.name: DragDropFuncWrapperTest021 799 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 800 * @tc.type: FUNC 801 * @tc.author: 802 */ 803 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest021, TestSize.Level1) 804 { 805 /** 806 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.6f 807 */ __anon3073c4e51602(WeakPtr<NG::FrameNode> frameNode) 808 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 809 auto node = frameNode.Upgrade(); 810 CHECK_NULL_VOID(node); 811 if ((PARA_OPACITY_VALUE_20 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_20 > MIN_OPACITY)) { 812 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_20); 813 } else { 814 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 815 } 816 }; 817 818 /** 819 * @tc.steps: step2. construct a DragPreviewOption object 820 */ 821 NG::DragPreviewOption option; 822 823 /** 824 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 825 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 826 */ 827 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 828 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 829 } 830 831 /** 832 * @tc.name: DragDropFuncWrapperTest022 833 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 834 * @tc.type: FUNC 835 * @tc.author: 836 */ 837 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest022, TestSize.Level1) 838 { 839 /** 840 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.7f 841 */ __anon3073c4e51702(WeakPtr<NG::FrameNode> frameNode) 842 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 843 auto node = frameNode.Upgrade(); 844 CHECK_NULL_VOID(node); 845 if ((PARA_OPACITY_VALUE_21 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_21 > MIN_OPACITY)) { 846 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_21); 847 } else { 848 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 849 } 850 }; 851 852 /** 853 * @tc.steps: step2. construct a DragPreviewOption object 854 */ 855 NG::DragPreviewOption option; 856 857 /** 858 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 859 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 860 */ 861 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 862 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 863 } 864 865 /** 866 * @tc.name: DragDropFuncWrapperTest023 867 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 868 * @tc.type: FUNC 869 * @tc.author: 870 */ 871 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest023, TestSize.Level1) 872 { 873 /** 874 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.8f 875 */ __anon3073c4e51802(WeakPtr<NG::FrameNode> frameNode) 876 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 877 auto node = frameNode.Upgrade(); 878 CHECK_NULL_VOID(node); 879 if ((PARA_OPACITY_VALUE_22 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_22 > MIN_OPACITY)) { 880 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_22); 881 } else { 882 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 883 } 884 }; 885 886 /** 887 * @tc.steps: step2. construct a DragPreviewOption object 888 */ 889 NG::DragPreviewOption option; 890 891 /** 892 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 893 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 894 */ 895 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 896 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 897 } 898 899 /** 900 * @tc.name: DragDropFuncWrapperTest024 901 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 902 * @tc.type: FUNC 903 * @tc.author: 904 */ 905 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest024, TestSize.Level1) 906 { 907 /** 908 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.9f 909 */ __anon3073c4e51902(WeakPtr<NG::FrameNode> frameNode) 910 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 911 auto node = frameNode.Upgrade(); 912 CHECK_NULL_VOID(node); 913 if ((PARA_OPACITY_VALUE_23 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_23 > MIN_OPACITY)) { 914 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_23); 915 } else { 916 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 917 } 918 }; 919 920 /** 921 * @tc.steps: step2. construct a DragPreviewOption object 922 */ 923 NG::DragPreviewOption option; 924 925 /** 926 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 927 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 928 */ 929 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 930 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 931 } 932 933 /** 934 * @tc.name: DragDropFuncWrapperTest025 935 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 936 * @tc.type: FUNC 937 * @tc.author: 938 */ 939 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest025, TestSize.Level1) 940 { 941 /** 942 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.0f 943 */ __anon3073c4e51a02(WeakPtr<NG::FrameNode> frameNode) 944 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 945 auto node = frameNode.Upgrade(); 946 CHECK_NULL_VOID(node); 947 if ((PARA_OPACITY_VALUE_24 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_24 > MIN_OPACITY)) { 948 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_24); 949 } else { 950 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 951 } 952 }; 953 954 /** 955 * @tc.steps: step2. construct a DragPreviewOption object 956 */ 957 NG::DragPreviewOption option; 958 959 /** 960 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 961 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 962 */ 963 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 964 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 965 } 966 967 /** 968 * @tc.name: DragDropFuncWrapperTest026 969 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 970 * @tc.type: FUNC 971 * @tc.author: 972 */ 973 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest026, TestSize.Level1) 974 { 975 /** 976 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.1f 977 */ __anon3073c4e51b02(WeakPtr<NG::FrameNode> frameNode) 978 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 979 auto node = frameNode.Upgrade(); 980 CHECK_NULL_VOID(node); 981 if ((PARA_OPACITY_VALUE_25 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_25 > MIN_OPACITY)) { 982 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_25); 983 } else { 984 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 985 } 986 }; 987 988 /** 989 * @tc.steps: step2. construct a DragPreviewOption object 990 */ 991 NG::DragPreviewOption option; 992 993 /** 994 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 995 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 996 */ 997 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 998 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 999 } 1000 1001 /** 1002 * @tc.name: DragDropFuncWrapperTest027 1003 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1004 * @tc.type: FUNC 1005 * @tc.author: 1006 */ 1007 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest027, TestSize.Level1) 1008 { 1009 /** 1010 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.2f 1011 */ __anon3073c4e51c02(WeakPtr<NG::FrameNode> frameNode) 1012 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1013 auto node = frameNode.Upgrade(); 1014 CHECK_NULL_VOID(node); 1015 if ((PARA_OPACITY_VALUE_26 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_26 > MIN_OPACITY)) { 1016 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_26); 1017 } else { 1018 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1019 } 1020 }; 1021 1022 /** 1023 * @tc.steps: step2. construct a DragPreviewOption object 1024 */ 1025 NG::DragPreviewOption option; 1026 1027 /** 1028 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1029 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1030 */ 1031 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1032 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1033 } 1034 1035 /** 1036 * @tc.name: DragDropFuncWrapperTest028 1037 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1038 * @tc.type: FUNC 1039 * @tc.author: 1040 */ 1041 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest028, TestSize.Level1) 1042 { 1043 /** 1044 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.3f 1045 */ __anon3073c4e51d02(WeakPtr<NG::FrameNode> frameNode) 1046 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1047 auto node = frameNode.Upgrade(); 1048 CHECK_NULL_VOID(node); 1049 if ((PARA_OPACITY_VALUE_27 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_27 > MIN_OPACITY)) { 1050 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_27); 1051 } else { 1052 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1053 } 1054 }; 1055 1056 /** 1057 * @tc.steps: step2. construct a DragPreviewOption object 1058 */ 1059 NG::DragPreviewOption option; 1060 1061 /** 1062 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1063 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1064 */ 1065 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1066 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1067 } 1068 1069 /** 1070 * @tc.name: DragDropFuncWrapperTest029 1071 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1072 * @tc.type: FUNC 1073 * @tc.author: 1074 */ 1075 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest029, TestSize.Level1) 1076 { 1077 /** 1078 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.4f 1079 */ __anon3073c4e51e02(WeakPtr<NG::FrameNode> frameNode) 1080 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1081 auto node = frameNode.Upgrade(); 1082 CHECK_NULL_VOID(node); 1083 if ((PARA_OPACITY_VALUE_28 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_28 > MIN_OPACITY)) { 1084 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_28); 1085 } else { 1086 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1087 } 1088 }; 1089 1090 /** 1091 * @tc.steps: step2. construct a DragPreviewOption object 1092 */ 1093 NG::DragPreviewOption option; 1094 1095 /** 1096 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1097 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1098 */ 1099 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1100 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1101 } 1102 1103 /** 1104 * @tc.name: DragDropFuncWrapperTest030 1105 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1106 * @tc.type: FUNC 1107 * @tc.author: 1108 */ 1109 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest030, TestSize.Level1) 1110 { 1111 /** 1112 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.5f 1113 */ __anon3073c4e51f02(WeakPtr<NG::FrameNode> frameNode) 1114 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1115 auto node = frameNode.Upgrade(); 1116 CHECK_NULL_VOID(node); 1117 if ((PARA_OPACITY_VALUE_29 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_29 > MIN_OPACITY)) { 1118 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_29); 1119 } else { 1120 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1121 } 1122 }; 1123 1124 /** 1125 * @tc.steps: step2. construct a DragPreviewOption object 1126 */ 1127 NG::DragPreviewOption option; 1128 1129 /** 1130 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1131 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1132 */ 1133 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1134 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1135 } 1136 1137 /** 1138 * @tc.name: DragDropFuncWrapperTest031 1139 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1140 * @tc.type: FUNC 1141 * @tc.author: 1142 */ 1143 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest031, TestSize.Level1) 1144 { 1145 /** 1146 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.6f 1147 */ __anon3073c4e52002(WeakPtr<NG::FrameNode> frameNode) 1148 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1149 auto node = frameNode.Upgrade(); 1150 CHECK_NULL_VOID(node); 1151 if ((PARA_OPACITY_VALUE_30 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_30 > MIN_OPACITY)) { 1152 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_30); 1153 } else { 1154 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1155 } 1156 }; 1157 1158 /** 1159 * @tc.steps: step2. construct a DragPreviewOption object 1160 */ 1161 NG::DragPreviewOption option; 1162 1163 /** 1164 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1165 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1166 */ 1167 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1168 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1169 } 1170 1171 /** 1172 * @tc.name: DragDropFuncWrapperTest032 1173 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1174 * @tc.type: FUNC 1175 * @tc.author: 1176 */ 1177 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest032, TestSize.Level1) 1178 { 1179 /** 1180 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.7f 1181 */ __anon3073c4e52102(WeakPtr<NG::FrameNode> frameNode) 1182 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1183 auto node = frameNode.Upgrade(); 1184 CHECK_NULL_VOID(node); 1185 if ((PARA_OPACITY_VALUE_31 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_31 > MIN_OPACITY)) { 1186 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_31); 1187 } else { 1188 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1189 } 1190 }; 1191 1192 /** 1193 * @tc.steps: step2. construct a DragPreviewOption object 1194 */ 1195 NG::DragPreviewOption option; 1196 1197 /** 1198 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1199 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1200 */ 1201 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1202 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1203 } 1204 1205 /** 1206 * @tc.name: DragDropFuncWrapperTest033 1207 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1208 * @tc.type: FUNC 1209 * @tc.author: 1210 */ 1211 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest033, TestSize.Level1) 1212 { 1213 /** 1214 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.8f 1215 */ __anon3073c4e52202(WeakPtr<NG::FrameNode> frameNode) 1216 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1217 auto node = frameNode.Upgrade(); 1218 CHECK_NULL_VOID(node); 1219 if ((PARA_OPACITY_VALUE_32 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_32 > MIN_OPACITY)) { 1220 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_32); 1221 } else { 1222 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1223 } 1224 }; 1225 1226 /** 1227 * @tc.steps: step2. construct a DragPreviewOption object 1228 */ 1229 NG::DragPreviewOption option; 1230 1231 /** 1232 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1233 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1234 */ 1235 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1236 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1237 } 1238 1239 /** 1240 * @tc.name: DragDropFuncWrapperTest034 1241 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1242 * @tc.type: FUNC 1243 * @tc.author: 1244 */ 1245 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest034, TestSize.Level1) 1246 { 1247 /** 1248 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.9f 1249 */ __anon3073c4e52302(WeakPtr<NG::FrameNode> frameNode) 1250 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1251 auto node = frameNode.Upgrade(); 1252 CHECK_NULL_VOID(node); 1253 if ((PARA_OPACITY_VALUE_33 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_33 > MIN_OPACITY)) { 1254 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_33); 1255 } else { 1256 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1257 } 1258 }; 1259 1260 /** 1261 * @tc.steps: step2. construct a DragPreviewOption object 1262 */ 1263 NG::DragPreviewOption option; 1264 1265 /** 1266 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1267 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1268 */ 1269 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1270 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1271 } 1272 1273 /** 1274 * @tc.name: DragDropFuncWrapperTest035 1275 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1276 * @tc.type: FUNC 1277 * @tc.author: 1278 */ 1279 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest035, TestSize.Level1) 1280 { 1281 /** 1282 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.0f 1283 */ __anon3073c4e52402(WeakPtr<NG::FrameNode> frameNode) 1284 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1285 auto node = frameNode.Upgrade(); 1286 CHECK_NULL_VOID(node); 1287 if ((PARA_OPACITY_VALUE_34 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_34 > MIN_OPACITY)) { 1288 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_34); 1289 } else { 1290 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1291 } 1292 }; 1293 1294 /** 1295 * @tc.steps: step2. construct a DragPreviewOption object 1296 */ 1297 NG::DragPreviewOption option; 1298 1299 /** 1300 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1301 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1302 */ 1303 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1304 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1305 } 1306 1307 /** 1308 * @tc.name: DragDropFuncWrapperTest036 1309 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1310 * @tc.type: FUNC 1311 * @tc.author: 1312 */ 1313 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest036, TestSize.Level1) 1314 { 1315 /** 1316 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.1f 1317 */ __anon3073c4e52502(WeakPtr<NG::FrameNode> frameNode) 1318 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1319 auto node = frameNode.Upgrade(); 1320 CHECK_NULL_VOID(node); 1321 if ((PARA_OPACITY_VALUE_35 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_35 > MIN_OPACITY)) { 1322 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_35); 1323 } else { 1324 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1325 } 1326 }; 1327 1328 /** 1329 * @tc.steps: step2. construct a DragPreviewOption object 1330 */ 1331 NG::DragPreviewOption option; 1332 1333 /** 1334 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1335 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1336 */ 1337 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1338 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1339 } 1340 1341 /** 1342 * @tc.name: DragDropFuncWrapperTest037 1343 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1344 * @tc.type: FUNC 1345 * @tc.author: 1346 */ 1347 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest037, TestSize.Level1) 1348 { 1349 /** 1350 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.2f 1351 */ __anon3073c4e52602(WeakPtr<NG::FrameNode> frameNode) 1352 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1353 auto node = frameNode.Upgrade(); 1354 CHECK_NULL_VOID(node); 1355 if ((PARA_OPACITY_VALUE_36 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_36 > MIN_OPACITY)) { 1356 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_36); 1357 } else { 1358 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1359 } 1360 }; 1361 1362 /** 1363 * @tc.steps: step2. construct a DragPreviewOption object 1364 */ 1365 NG::DragPreviewOption option; 1366 1367 /** 1368 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1369 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1370 */ 1371 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1372 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1373 } 1374 1375 /** 1376 * @tc.name: DragDropFuncWrapperTest038 1377 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1378 * @tc.type: FUNC 1379 * @tc.author: 1380 */ 1381 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest038, TestSize.Level1) 1382 { 1383 /** 1384 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.3f 1385 */ __anon3073c4e52702(WeakPtr<NG::FrameNode> frameNode) 1386 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1387 auto node = frameNode.Upgrade(); 1388 CHECK_NULL_VOID(node); 1389 if ((PARA_OPACITY_VALUE_37 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_37 > MIN_OPACITY)) { 1390 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_37); 1391 } else { 1392 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1393 } 1394 }; 1395 1396 /** 1397 * @tc.steps: step2. construct a DragPreviewOption object 1398 */ 1399 NG::DragPreviewOption option; 1400 1401 /** 1402 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1403 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1404 */ 1405 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1406 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1407 } 1408 1409 /** 1410 * @tc.name: DragDropFuncWrapperTest039 1411 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1412 * @tc.type: FUNC 1413 * @tc.author: 1414 */ 1415 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest039, TestSize.Level1) 1416 { 1417 /** 1418 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.4f 1419 */ __anon3073c4e52802(WeakPtr<NG::FrameNode> frameNode) 1420 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1421 auto node = frameNode.Upgrade(); 1422 CHECK_NULL_VOID(node); 1423 if ((PARA_OPACITY_VALUE_38 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_38 > MIN_OPACITY)) { 1424 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_38); 1425 } else { 1426 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1427 } 1428 }; 1429 1430 /** 1431 * @tc.steps: step2. construct a DragPreviewOption object 1432 */ 1433 NG::DragPreviewOption option; 1434 1435 /** 1436 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1437 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1438 */ 1439 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1440 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1441 } 1442 1443 /** 1444 * @tc.name: DragDropFuncWrapperTest040 1445 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1446 * @tc.type: FUNC 1447 * @tc.author: 1448 */ 1449 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest040, TestSize.Level1) 1450 { 1451 /** 1452 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.5f 1453 */ __anon3073c4e52902(WeakPtr<NG::FrameNode> frameNode) 1454 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1455 auto node = frameNode.Upgrade(); 1456 CHECK_NULL_VOID(node); 1457 if ((PARA_OPACITY_VALUE_39 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_39 > MIN_OPACITY)) { 1458 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_39); 1459 } else { 1460 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1461 } 1462 }; 1463 1464 /** 1465 * @tc.steps: step2. construct a DragPreviewOption object 1466 */ 1467 NG::DragPreviewOption option; 1468 1469 /** 1470 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1471 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1472 */ 1473 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1474 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1475 } 1476 1477 /** 1478 * @tc.name: DragDropFuncWrapperTest041 1479 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1480 * @tc.type: FUNC 1481 * @tc.author: 1482 */ 1483 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest041, TestSize.Level1) 1484 { 1485 /** 1486 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.6f 1487 */ __anon3073c4e52a02(WeakPtr<NG::FrameNode> frameNode) 1488 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1489 auto node = frameNode.Upgrade(); 1490 CHECK_NULL_VOID(node); 1491 if ((PARA_OPACITY_VALUE_40 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_40 > MIN_OPACITY)) { 1492 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_40); 1493 } else { 1494 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1495 } 1496 }; 1497 1498 /** 1499 * @tc.steps: step2. construct a DragPreviewOption object 1500 */ 1501 NG::DragPreviewOption option; 1502 1503 /** 1504 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1505 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1506 */ 1507 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1508 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1509 } 1510 1511 /** 1512 * @tc.name: DragDropFuncWrapperTest042 1513 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1514 * @tc.type: FUNC 1515 * @tc.author: 1516 */ 1517 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest042, TestSize.Level1) 1518 { 1519 /** 1520 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.7f 1521 */ __anon3073c4e52b02(WeakPtr<NG::FrameNode> frameNode) 1522 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1523 auto node = frameNode.Upgrade(); 1524 CHECK_NULL_VOID(node); 1525 if ((PARA_OPACITY_VALUE_41 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_41 > MIN_OPACITY)) { 1526 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_41); 1527 } else { 1528 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1529 } 1530 }; 1531 1532 /** 1533 * @tc.steps: step2. construct a DragPreviewOption object 1534 */ 1535 NG::DragPreviewOption option; 1536 1537 /** 1538 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1539 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1540 */ 1541 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1542 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1543 } 1544 1545 /** 1546 * @tc.name: DragDropFuncWrapperTest043 1547 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1548 * @tc.type: FUNC 1549 * @tc.author: 1550 */ 1551 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest043, TestSize.Level1) 1552 { 1553 /** 1554 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.8f 1555 */ __anon3073c4e52c02(WeakPtr<NG::FrameNode> frameNode) 1556 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1557 auto node = frameNode.Upgrade(); 1558 CHECK_NULL_VOID(node); 1559 if ((PARA_OPACITY_VALUE_42 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_42 > MIN_OPACITY)) { 1560 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_42); 1561 } else { 1562 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1563 } 1564 }; 1565 1566 /** 1567 * @tc.steps: step2. construct a DragPreviewOption object 1568 */ 1569 NG::DragPreviewOption option; 1570 1571 /** 1572 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1573 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1574 */ 1575 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1576 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1577 } 1578 1579 /** 1580 * @tc.name: DragDropFuncWrapperTest044 1581 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1582 * @tc.type: FUNC 1583 * @tc.author: 1584 */ 1585 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest044, TestSize.Level1) 1586 { 1587 /** 1588 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.9f 1589 */ __anon3073c4e52d02(WeakPtr<NG::FrameNode> frameNode) 1590 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1591 auto node = frameNode.Upgrade(); 1592 CHECK_NULL_VOID(node); 1593 if ((PARA_OPACITY_VALUE_43 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_43 > MIN_OPACITY)) { 1594 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_43); 1595 } else { 1596 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1597 } 1598 }; 1599 1600 /** 1601 * @tc.steps: step2. construct a DragPreviewOption object 1602 */ 1603 NG::DragPreviewOption option; 1604 1605 /** 1606 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1607 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1608 */ 1609 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1610 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1611 } 1612 1613 /** 1614 * @tc.name: DragDropFuncWrapperTest045 1615 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1616 * @tc.type: FUNC 1617 * @tc.author: 1618 */ 1619 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest045, TestSize.Level1) 1620 { 1621 /** 1622 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.0f 1623 */ __anon3073c4e52e02(WeakPtr<NG::FrameNode> frameNode) 1624 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1625 auto node = frameNode.Upgrade(); 1626 CHECK_NULL_VOID(node); 1627 if ((PARA_OPACITY_VALUE_44 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_44 > MIN_OPACITY)) { 1628 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_44); 1629 } else { 1630 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1631 } 1632 }; 1633 1634 /** 1635 * @tc.steps: step2. construct a DragPreviewOption object 1636 */ 1637 NG::DragPreviewOption option; 1638 1639 /** 1640 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1641 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1642 */ 1643 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1644 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1645 } 1646 1647 /** 1648 * @tc.name: DragDropFuncWrapperTest046 1649 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1650 * @tc.type: FUNC 1651 * @tc.author: 1652 */ 1653 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest046, TestSize.Level1) 1654 { 1655 /** 1656 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.1f 1657 */ __anon3073c4e52f02(WeakPtr<NG::FrameNode> frameNode) 1658 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1659 auto node = frameNode.Upgrade(); 1660 CHECK_NULL_VOID(node); 1661 if ((PARA_OPACITY_VALUE_45 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_45 > MIN_OPACITY)) { 1662 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_45); 1663 } else { 1664 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1665 } 1666 }; 1667 1668 /** 1669 * @tc.steps: step2. construct a DragPreviewOption object 1670 */ 1671 NG::DragPreviewOption option; 1672 1673 /** 1674 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1675 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1676 */ 1677 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1678 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1679 } 1680 1681 /** 1682 * @tc.name: DragDropFuncWrapperTest047 1683 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1684 * @tc.type: FUNC 1685 * @tc.author: 1686 */ 1687 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest047, TestSize.Level1) 1688 { 1689 /** 1690 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.2f 1691 */ __anon3073c4e53002(WeakPtr<NG::FrameNode> frameNode) 1692 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1693 auto node = frameNode.Upgrade(); 1694 CHECK_NULL_VOID(node); 1695 if ((PARA_OPACITY_VALUE_46 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_46 > MIN_OPACITY)) { 1696 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_46); 1697 } else { 1698 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1699 } 1700 }; 1701 1702 /** 1703 * @tc.steps: step2. construct a DragPreviewOption object 1704 */ 1705 NG::DragPreviewOption option; 1706 1707 /** 1708 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1709 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1710 */ 1711 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1712 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1713 } 1714 1715 /** 1716 * @tc.name: DragDropFuncWrapperTest048 1717 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1718 * @tc.type: FUNC 1719 * @tc.author: 1720 */ 1721 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest048, TestSize.Level1) 1722 { 1723 /** 1724 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.3f 1725 */ __anon3073c4e53102(WeakPtr<NG::FrameNode> frameNode) 1726 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1727 auto node = frameNode.Upgrade(); 1728 CHECK_NULL_VOID(node); 1729 if ((PARA_OPACITY_VALUE_47 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_47 > MIN_OPACITY)) { 1730 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_47); 1731 } else { 1732 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1733 } 1734 }; 1735 1736 /** 1737 * @tc.steps: step2. construct a DragPreviewOption object 1738 */ 1739 NG::DragPreviewOption option; 1740 1741 /** 1742 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1743 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1744 */ 1745 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1746 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1747 } 1748 1749 /** 1750 * @tc.name: DragDropFuncWrapperTest049 1751 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1752 * @tc.type: FUNC 1753 * @tc.author: 1754 */ 1755 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest049, TestSize.Level1) 1756 { 1757 /** 1758 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.4f 1759 */ __anon3073c4e53202(WeakPtr<NG::FrameNode> frameNode) 1760 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1761 auto node = frameNode.Upgrade(); 1762 CHECK_NULL_VOID(node); 1763 if ((PARA_OPACITY_VALUE_48 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_48 > MIN_OPACITY)) { 1764 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_48); 1765 } else { 1766 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1767 } 1768 }; 1769 1770 /** 1771 * @tc.steps: step2. construct a DragPreviewOption object 1772 */ 1773 NG::DragPreviewOption option; 1774 1775 /** 1776 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1777 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1778 */ 1779 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1780 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1781 } 1782 1783 /** 1784 * @tc.name: DragDropFuncWrapperTest050 1785 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1786 * @tc.type: FUNC 1787 * @tc.author: 1788 */ 1789 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest050, TestSize.Level1) 1790 { 1791 /** 1792 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.5f 1793 */ __anon3073c4e53302(WeakPtr<NG::FrameNode> frameNode) 1794 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1795 auto node = frameNode.Upgrade(); 1796 CHECK_NULL_VOID(node); 1797 if ((PARA_OPACITY_VALUE_49 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_49 > MIN_OPACITY)) { 1798 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_49); 1799 } else { 1800 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1801 } 1802 }; 1803 1804 /** 1805 * @tc.steps: step2. construct a DragPreviewOption object 1806 */ 1807 NG::DragPreviewOption option; 1808 1809 /** 1810 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1811 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1812 */ 1813 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1814 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1815 } 1816 1817 /** 1818 * @tc.name: DragDropFuncWrapperTest051 1819 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1820 * @tc.type: FUNC 1821 * @tc.author: 1822 */ 1823 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest051, TestSize.Level1) 1824 { 1825 /** 1826 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.6f 1827 */ __anon3073c4e53402(WeakPtr<NG::FrameNode> frameNode) 1828 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1829 auto node = frameNode.Upgrade(); 1830 CHECK_NULL_VOID(node); 1831 if ((PARA_OPACITY_VALUE_50 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_50 > MIN_OPACITY)) { 1832 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_50); 1833 } else { 1834 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1835 } 1836 }; 1837 1838 /** 1839 * @tc.steps: step2. construct a DragPreviewOption object 1840 */ 1841 NG::DragPreviewOption option; 1842 1843 /** 1844 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1845 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1846 */ 1847 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1848 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1849 } 1850 1851 /** 1852 * @tc.name: DragDropFuncWrapperTest052 1853 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1854 * @tc.type: FUNC 1855 * @tc.author: 1856 */ 1857 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest052, TestSize.Level1) 1858 { 1859 /** 1860 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.7f 1861 */ __anon3073c4e53502(WeakPtr<NG::FrameNode> frameNode) 1862 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1863 auto node = frameNode.Upgrade(); 1864 CHECK_NULL_VOID(node); 1865 if ((PARA_OPACITY_VALUE_51 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_51 > MIN_OPACITY)) { 1866 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_51); 1867 } else { 1868 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1869 } 1870 }; 1871 1872 /** 1873 * @tc.steps: step2. construct a DragPreviewOption object 1874 */ 1875 NG::DragPreviewOption option; 1876 1877 /** 1878 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1879 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1880 */ 1881 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1882 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1883 } 1884 1885 /** 1886 * @tc.name: DragDropFuncWrapperTest053 1887 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1888 * @tc.type: FUNC 1889 * @tc.author: 1890 */ 1891 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest053, TestSize.Level1) 1892 { 1893 /** 1894 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.8f 1895 */ __anon3073c4e53602(WeakPtr<NG::FrameNode> frameNode) 1896 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1897 auto node = frameNode.Upgrade(); 1898 CHECK_NULL_VOID(node); 1899 if ((PARA_OPACITY_VALUE_52 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_52 > MIN_OPACITY)) { 1900 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_52); 1901 } else { 1902 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1903 } 1904 }; 1905 1906 /** 1907 * @tc.steps: step2. construct a DragPreviewOption object 1908 */ 1909 NG::DragPreviewOption option; 1910 1911 /** 1912 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1913 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1914 */ 1915 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1916 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1917 } 1918 1919 /** 1920 * @tc.name: DragDropFuncWrapperTest054 1921 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1922 * @tc.type: FUNC 1923 * @tc.author: 1924 */ 1925 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest054, TestSize.Level1) 1926 { 1927 /** 1928 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.9f 1929 */ __anon3073c4e53702(WeakPtr<NG::FrameNode> frameNode) 1930 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1931 auto node = frameNode.Upgrade(); 1932 CHECK_NULL_VOID(node); 1933 if ((PARA_OPACITY_VALUE_53 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_53 > MIN_OPACITY)) { 1934 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_53); 1935 } else { 1936 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1937 } 1938 }; 1939 1940 /** 1941 * @tc.steps: step2. construct a DragPreviewOption object 1942 */ 1943 NG::DragPreviewOption option; 1944 1945 /** 1946 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1947 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1948 */ 1949 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1950 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1951 } 1952 1953 /** 1954 * @tc.name: DragDropFuncWrapperTest055 1955 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier 1956 * @tc.type: FUNC 1957 * @tc.author: 1958 */ 1959 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest055, TestSize.Level1) 1960 { 1961 /** 1962 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 5.0f 1963 */ __anon3073c4e53802(WeakPtr<NG::FrameNode> frameNode) 1964 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) { 1965 auto node = frameNode.Upgrade(); 1966 CHECK_NULL_VOID(node); 1967 if ((PARA_OPACITY_VALUE_54 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_54 > MIN_OPACITY)) { 1968 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_54); 1969 } else { 1970 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY); 1971 } 1972 }; 1973 1974 /** 1975 * @tc.steps: step2. construct a DragPreviewOption object 1976 */ 1977 NG::DragPreviewOption option; 1978 1979 /** 1980 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier 1981 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f. 1982 */ 1983 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option); 1984 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY); 1985 } 1986 1987 } // namespace OHOS::Ace::NG 1988