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 <cstdint> 16 #include <cstring> 17 #include <iostream> 18 19 #include "gtest/gtest.h" 20 #define private public 21 #define protected public 22 #include "drag_and_drop.h" 23 #include "event_converter.h" 24 #include "udmf.h" 25 #include "native_interface.h" 26 #include "native_node.h" 27 #include "native_type.h" 28 #include "node_model.h" 29 #include "securec.h" 30 #include "test/mock/base/mock_task_executor.h" 31 #include "test/mock/core/common/mock_container.h" 32 #include "test/mock/core/common/mock_theme_manager.h" 33 #include "test/mock/core/pipeline/mock_pipeline_context.h" 34 35 using namespace testing; 36 using namespace testing::ext; 37 namespace OHOS::Ace { 38 namespace { 39 const float WINDOW_X = 1.0f; 40 const float WINDOW_Y = 1.0f; 41 const float TOUCH_POINT_X = 1.0f; 42 const float TOUCH_POINT_Y = 1.0f; 43 const float PREVIEW_RECT_WIDTH = 1.0f; 44 const float PREVIEW_RECT_HEIGHT = 1.0f; 45 const float DISPLAY_X = 1.0f; 46 const float DISPLAY_Y = 1.0f; 47 const float GLOBAL_DISPLAY_X = 1.0f; 48 const float GLOBAL_DISPLAY_Y = 1.0f; 49 const float VELOCITY_X = 1.0f; 50 const float VELOCITY_Y = 1.0f; 51 const float VELOCITY = 1.0f; 52 const int32_t DISPLAYID = 0; 53 } // namespace 54 class DragAndDropTest : public testing::Test { 55 public: SetUpTestSuite()56 static void SetUpTestSuite() 57 { 58 NG::MockPipelineContext::SetUp(); 59 MockContainer::SetUp(); 60 MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent(); 61 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>(); 62 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_; 63 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 64 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 65 } TearDownTestSuite()66 static void TearDownTestSuite() 67 { 68 NG::MockPipelineContext::TearDown(); 69 MockContainer::TearDown(); 70 } 71 }; 72 73 /** 74 * @tc.name: DragAndDropTest001 75 * @tc.desc: Test the DragAction for C-API. 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(DragAndDropTest, DragAndDropTest001, TestSize.Level1) 79 { 80 /** 81 * @tc.steps: step1.create dragAction. 82 */ 83 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 84 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 85 auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK); 86 auto rootFrameNode = reinterpret_cast<ArkUI_Node*>(rootNode); 87 auto frameNode = reinterpret_cast<NG::FrameNode*>(rootFrameNode->uiNodeHandle); 88 auto context = NG::MockPipelineContext::GetCurrent(); 89 frameNode->context_ = AceType::RawPtr(context); 90 auto* dragAction = OH_ArkUI_CreateDragActionWithNode(rootNode); 91 EXPECT_NE(dragAction, nullptr); 92 EXPECT_EQ(OH_ArkUI_DragAction_SetPointerId(dragAction, 0), ARKUI_ERROR_CODE_NO_ERROR); 93 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointX(dragAction, 1.0), ARKUI_ERROR_CODE_NO_ERROR); 94 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointY(dragAction, 1.0), ARKUI_ERROR_CODE_NO_ERROR); 95 auto* interalDragAction = reinterpret_cast<ArkUIDragAction*>(dragAction); 96 EXPECT_EQ(interalDragAction->pointerId, 0); 97 EXPECT_EQ(interalDragAction->touchPointX, 1.0); 98 EXPECT_EQ(interalDragAction->touchPointY, 1.0); 99 OH_ArkUI_DragAction_RegisterStatusListener( __anon65be1aee0202(ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) 100 dragAction, nullptr, [](ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) -> void { 101 EXPECT_NE( 102 OH_ArkUI_DragAndDropInfo_GetDragStatus(dragAndDropInfo), ArkUI_DragStatus::ARKUI_DRAG_STATUS_UNKNOWN); 103 EXPECT_NE(OH_ArkUI_DragAndDropInfo_GetDragEvent(dragAndDropInfo), nullptr); 104 }); 105 OH_ArkUI_DragAction_UnregisterStatusListener(dragAction); 106 EXPECT_EQ(OH_ArkUI_StartDrag(dragAction), ARKUI_ERROR_CODE_NO_ERROR); 107 OH_ArkUI_DragAction_Dispose(dragAction); 108 } 109 110 /** 111 * @tc.name: DragAndDropTest002 112 * @tc.desc: Test the DragAction for C-API. 113 * @tc.type: FUNC 114 */ 115 HWTEST_F(DragAndDropTest, DragAndDropTest002, TestSize.Level1) 116 { 117 /** 118 * @tc.steps: step1.create dragAction. 119 */ 120 auto uiContext = new ArkUI_Context({ .id = 1 }); 121 auto dragAction = OH_ArkUI_CreateDragActionWithContext(uiContext); 122 EXPECT_NE(dragAction, nullptr); 123 EXPECT_EQ(OH_ArkUI_DragAction_SetPointerId(dragAction, 0), ARKUI_ERROR_CODE_NO_ERROR); 124 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointX(dragAction, 1.0), ARKUI_ERROR_CODE_NO_ERROR); 125 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointY(dragAction, 1.0), ARKUI_ERROR_CODE_NO_ERROR); 126 auto* interalDragAction = reinterpret_cast<ArkUIDragAction*>(dragAction); 127 EXPECT_EQ(interalDragAction->pointerId, 0); 128 EXPECT_EQ(interalDragAction->touchPointX, 1.0); 129 EXPECT_EQ(interalDragAction->touchPointY, 1.0); 130 OH_ArkUI_DragAction_RegisterStatusListener( __anon65be1aee0302(ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) 131 dragAction, nullptr, [](ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) -> void { 132 EXPECT_NE( 133 OH_ArkUI_DragAndDropInfo_GetDragStatus(dragAndDropInfo), ArkUI_DragStatus::ARKUI_DRAG_STATUS_UNKNOWN); 134 EXPECT_NE(OH_ArkUI_DragAndDropInfo_GetDragEvent(dragAndDropInfo), nullptr); 135 }); 136 OH_ArkUI_DragAction_UnregisterStatusListener(dragAction); 137 EXPECT_EQ(OH_ArkUI_StartDrag(dragAction), ARKUI_ERROR_CODE_NO_ERROR); 138 OH_ArkUI_DragAction_Dispose(dragAction); 139 delete uiContext; 140 } 141 142 /** 143 * @tc.name: DragAndDropTest003 144 * @tc.desc: test OH_ArkUI_NodeEvent_GetDragEvent function; 145 * @tc.type: FUNC 146 */ 147 HWTEST_F(DragAndDropTest, DragAndDropTest003, TestSize.Level1) 148 { 149 ArkUI_NodeEvent event = { 0, -1 }; 150 auto eventType = OH_ArkUI_NodeEvent_GetDragEvent(&event); 151 EXPECT_EQ(eventType, nullptr); 152 } 153 154 /** 155 * @tc.name: DragAndDropTest004 156 * @tc.desc: test NodeDrag function; 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(DragAndDropTest, DragAndDropTest004, TestSize.Level1) 160 { 161 /** 162 * @tc.steps: step1.create FrameNode is not null, related function is called. 163 */ 164 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 165 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 166 auto textNode = new ArkUI_Node({ ARKUI_NODE_TEXT, nullptr, true }); 167 auto areaNode = new ArkUI_Node({ ARKUI_NODE_TEXT_AREA, nullptr, true }); 168 169 /** 170 * @tc.expected: Return expected results. 171 */ 172 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_PRE_DRAG, 0, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 173 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_DRAG_START, 1, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 174 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_DRAG_ENTER, 2, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 175 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_DRAG_MOVE, 3, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 176 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_DRAG_LEAVE, 4, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 177 EXPECT_EQ(nodeAPI->registerNodeEvent(areaNode, NODE_ON_DROP, 5, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 178 EXPECT_EQ(nodeAPI->registerNodeEvent(textNode, NODE_ON_DRAG_END, 6, nullptr), ARKUI_ERROR_CODE_NO_ERROR); 179 delete textNode; 180 delete areaNode; 181 } 182 183 /** 184 * @tc.name: DragAndDropTest005 185 * @tc.desc: Test the OH_ArkUI_NodeEvent_GetPreDragStatus. 186 * @tc.type: FUNC 187 */ 188 HWTEST_F(DragAndDropTest, DragAndDropTest005, TestSize.Level1) 189 { 190 /** 191 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 192 */ 193 ArkUI_NodeEvent nodeEvent; 194 ArkUINodeEvent event; 195 event.kind = ArkUIEventCategory::COMPONENT_ASYNC_EVENT; 196 event.componentAsyncEvent.subKind = ON_PRE_DRAG; 197 event.componentAsyncEvent.data[0].i32 = 198 static_cast<ArkUI_Int32>(OHOS::Ace::PreDragStatus::READY_TO_TRIGGER_DRAG_ACTION); 199 nodeEvent.origin = &event; 200 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_COMPONENT_EVENT; 201 auto ret1 = OH_ArkUI_NodeEvent_GetPreDragStatus(&nodeEvent); 202 203 /** 204 * @tc.steps: step2.set DragEvent is nullptr, related function is called. 205 */ 206 auto ret2 = OH_ArkUI_NodeEvent_GetPreDragStatus(nullptr); 207 208 /** 209 * @tc.steps: step3.set category to other type, related function is called. 210 */ 211 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 212 auto ret3 = OH_ArkUI_NodeEvent_GetPreDragStatus(&nodeEvent); 213 214 /** 215 * @tc.steps: step4.set origin to nullptr, related function is called. 216 */ 217 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_COMPONENT_EVENT; 218 nodeEvent.origin = nullptr; 219 auto ret4 = OH_ArkUI_NodeEvent_GetPreDragStatus(&nodeEvent); 220 221 /** 222 * @tc.expected: Return expected results. 223 */ 224 EXPECT_EQ(ret1, ArkUI_PreDragStatus::ARKUI_PRE_DRAG_STATUS_READY_TO_TRIGGER_DRAG); 225 EXPECT_EQ(ret2, ArkUI_PreDragStatus::ARKUI_PRE_DRAG_STATUS_UNKNOWN); 226 EXPECT_EQ(ret3, ArkUI_PreDragStatus::ARKUI_PRE_DRAG_STATUS_UNKNOWN); 227 EXPECT_EQ(ret4, ArkUI_PreDragStatus::ARKUI_PRE_DRAG_STATUS_UNKNOWN); 228 } 229 230 /** 231 * @tc.name: DragAndDropTest006 232 * @tc.desc: Test the OH_ArkUI_DragEvent_DisableDefaultDropAnimation. 233 * @tc.type: FUNC 234 */ 235 HWTEST_F(DragAndDropTest, DragAndDropTest006, TestSize.Level1) 236 { 237 /** 238 * @tc.steps: step1.create DragEvent, related function is called. 239 */ 240 ArkUIDragEvent dragEvent; 241 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 242 auto ret1 = OH_ArkUI_DragEvent_DisableDefaultDropAnimation(drag_Event, true); 243 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 244 EXPECT_EQ(dragEvent.useCustomDropAnimation, true); 245 auto ret2 = OH_ArkUI_DragEvent_DisableDefaultDropAnimation(drag_Event, false); 246 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 247 EXPECT_EQ(dragEvent.useCustomDropAnimation, false); 248 249 /** 250 * @tc.steps: step2.set DragEvent is nullptr, related function is called. 251 */ 252 auto ret3 = OH_ArkUI_DragEvent_DisableDefaultDropAnimation(nullptr, false); 253 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 254 auto ret4 = OH_ArkUI_DragEvent_DisableDefaultDropAnimation(nullptr, false); 255 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 256 } 257 258 /** 259 * @tc.name: DragAndDropTest007 260 * @tc.desc: Test the OH_ArkUI_SetNodeDraggable. 261 * @tc.type: FUNC 262 */ 263 HWTEST_F(DragAndDropTest, DragAndDropTest007, TestSize.Level1) 264 { 265 /** 266 * @tc.steps: step1.create DragEvent, related function is called. 267 */ 268 auto textNode = new ArkUI_Node({ ARKUI_NODE_TEXT, nullptr, true }); 269 auto ret1 = OH_ArkUI_SetNodeDraggable(textNode, true); 270 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 271 272 auto ret2 = OH_ArkUI_SetNodeDraggable(textNode, false); 273 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 274 275 /** 276 * @tc.steps: step2.set DragEvent is nullptr, related function is called. 277 */ 278 auto ret3 = OH_ArkUI_SetNodeDraggable(nullptr, true); 279 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 280 auto ret4 = OH_ArkUI_SetNodeDraggable(nullptr, false); 281 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 282 delete textNode; 283 } 284 285 /** 286 * @tc.name: DragAndDropTest008 287 * @tc.desc: Test the OH_ArkUI_CreateDragPreviewOption. 288 * @tc.type: FUNC 289 */ 290 HWTEST_F(DragAndDropTest, DragAndDropTest008, TestSize.Level1) 291 { 292 /** 293 * @tc.steps: step1.create ArkUI_DragPreviewOption. 294 * @tc.expected: Return expected results. 295 */ 296 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 297 EXPECT_NE(dragPreviewOption, nullptr); 298 299 /** 300 * @tc.steps: step2.create ArkUI_DragPreviewOption. 301 * @tc.expected: Return expected results. 302 */ 303 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 304 dragPreviewOption = nullptr; 305 EXPECT_EQ(dragPreviewOption, nullptr); 306 } 307 308 /** 309 * @tc.name: DragAndDropTest009 310 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetScaleMode. 311 * @tc.type: FUNC 312 */ 313 HWTEST_F(DragAndDropTest, DragAndDropTest009, TestSize.Level1) 314 { 315 /** 316 * @tc.steps: step1.create dragPreviewOption and set scaleMode. 317 * @tc.expected: Return expected results. 318 */ 319 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 320 auto ret1 = OH_ArkUI_DragPreviewOption_SetScaleMode( 321 dragPreviewOption, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_AUTO); 322 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 323 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 324 EXPECT_TRUE(option->isScaleEnabled); 325 EXPECT_FALSE(option->isDefaultShadowEnabled); 326 EXPECT_FALSE(option->isDefaultRadiusEnabled); 327 auto ret2 = OH_ArkUI_DragPreviewOption_SetScaleMode( 328 dragPreviewOption, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_DISABLED); 329 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 330 EXPECT_FALSE(option->isScaleEnabled); 331 332 /** 333 * @tc.steps: step2.set preview option with nullptr. 334 * @tc.expected: Return expected results. 335 */ 336 auto ret3 = 337 OH_ArkUI_DragPreviewOption_SetScaleMode(nullptr, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_AUTO); 338 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 339 auto ret4 = 340 OH_ArkUI_DragPreviewOption_SetScaleMode(nullptr, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_DISABLED); 341 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 342 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 343 } 344 345 /** 346 * @tc.name: DragAndDropTest010 347 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled. 348 * @tc.type: FUNC 349 */ 350 HWTEST_F(DragAndDropTest, DragAndDropTest010, TestSize.Level1) 351 { 352 /** 353 * @tc.steps: step1.create dragPreviewOption and call related function. 354 * @tc.expected: Return expected results. 355 */ 356 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 357 auto ret1 = OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, true); 358 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 359 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 360 EXPECT_TRUE(option->isDefaultShadowEnabled); 361 auto ret2 = OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, false); 362 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 363 EXPECT_FALSE(option->isDefaultShadowEnabled); 364 365 /** 366 * @tc.steps: step2.set preview option with nullptr. 367 * @tc.expected: Return expected results. 368 */ 369 auto ret3 = OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(nullptr, true); 370 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 371 auto ret4 = OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(nullptr, false); 372 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 373 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 374 } 375 376 /** 377 * @tc.name: DragAndDropTest011 378 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled. 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(DragAndDropTest, DragAndDropTest011, TestSize.Level1) 382 { 383 /** 384 * @tc.steps: step1.create dragPreviewOption and call related function. 385 * @tc.expected: Return expected results. 386 */ 387 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 388 auto ret1 = OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, true); 389 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 390 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 391 EXPECT_TRUE(option->isDefaultRadiusEnabled); 392 393 auto ret2 = OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, false); 394 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 395 EXPECT_FALSE(option->isDefaultRadiusEnabled); 396 397 /** 398 * @tc.steps: step2.set preview option with nullptr. 399 * @tc.expected: Return expected results. 400 */ 401 auto ret3 = OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(nullptr, true); 402 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 403 auto ret4 = OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(nullptr, false); 404 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 405 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 406 } 407 408 /** 409 * @tc.name: DragAndDropTest012 410 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled. 411 * @tc.type: FUNC 412 */ 413 HWTEST_F(DragAndDropTest, DragAndDropTest012, TestSize.Level1) 414 { 415 /** 416 * @tc.steps: step1.create dragPreviewOption and call related function. 417 * @tc.expected: Return expected results. 418 */ 419 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 420 auto ret1 = OH_ArkUI_DragPreviewOption_SetNumberBadgeEnabled(dragPreviewOption, true); 421 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 422 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 423 EXPECT_FALSE(option->isNumberBadgeEnabled); 424 EXPECT_TRUE(option->isShowBadge); 425 426 auto ret2 = OH_ArkUI_DragPreviewOption_SetNumberBadgeEnabled(dragPreviewOption, false); 427 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 428 EXPECT_FALSE(option->isNumberBadgeEnabled); 429 EXPECT_FALSE(option->isShowBadge); 430 431 /** 432 * @tc.steps: step2.set preview option with nullptr. 433 * @tc.expected: Return expected results. 434 */ 435 auto ret3 = OH_ArkUI_DragPreviewOption_SetNumberBadgeEnabled(nullptr, true); 436 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 437 auto ret4 = OH_ArkUI_DragPreviewOption_SetNumberBadgeEnabled(nullptr, false); 438 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 439 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 440 } 441 442 /** 443 * @tc.name: DragAndDropTest013 444 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetBadgeNumber. 445 * @tc.type: FUNC 446 */ 447 HWTEST_F(DragAndDropTest, DragAndDropTest013, TestSize.Level1) 448 { 449 /** 450 * @tc.steps: step1.create dragPreviewOption and call related function. 451 * @tc.expected: Return expected results. 452 */ 453 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 454 auto ret1 = OH_ArkUI_DragPreviewOption_SetBadgeNumber(dragPreviewOption, 2); 455 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 456 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 457 EXPECT_TRUE(option->isNumberBadgeEnabled); 458 EXPECT_EQ(option->badgeNumber, 2); 459 460 /** 461 * @tc.steps: step2.set preview option with nullptr. 462 * @tc.expected: Return expected results. 463 */ 464 auto ret2 = OH_ArkUI_DragPreviewOption_SetBadgeNumber(nullptr, true); 465 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 466 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 467 } 468 469 /** 470 * @tc.name: DragAndDropTest014 471 * @tc.desc: Test the OH_ArkUI_DragPreviewOption_SetDefaultAnimationBeforeLiftingEnabled. 472 * @tc.type: FUNC 473 */ 474 HWTEST_F(DragAndDropTest, DragAndDropTest014, TestSize.Level1) 475 { 476 /** 477 * @tc.steps: step1.create dragPreviewOption and call related function. 478 * @tc.expected: Return expected results. 479 */ 480 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 481 auto ret1 = OH_ArkUI_DragPreviewOption_SetDefaultAnimationBeforeLiftingEnabled(dragPreviewOption, true); 482 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 483 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 484 EXPECT_TRUE(option->defaultAnimationBeforeLifting); 485 auto ret2 = OH_ArkUI_DragPreviewOption_SetDefaultAnimationBeforeLiftingEnabled(dragPreviewOption, false); 486 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 487 EXPECT_FALSE(option->defaultAnimationBeforeLifting); 488 489 /** 490 * @tc.steps: step2.set preview option with nullptr. 491 * @tc.expected: Return expected results. 492 */ 493 auto ret3 = OH_ArkUI_DragPreviewOption_SetDefaultAnimationBeforeLiftingEnabled(nullptr, true); 494 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 495 auto ret4 = OH_ArkUI_DragPreviewOption_SetDefaultAnimationBeforeLiftingEnabled(nullptr, false); 496 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_PARAM_INVALID); 497 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 498 } 499 500 /** 501 * @tc.name: DragAndDropTest015 502 * @tc.desc: Test the preview option mix setting. 503 * @tc.type: FUNC 504 */ 505 HWTEST_F(DragAndDropTest, DragAndDropTest015, TestSize.Level1) 506 { 507 /** 508 * @tc.steps: step1.create dragPreviewOption and call mix related function. 509 * @tc.expected: Return expected results. 510 */ 511 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 512 OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, true); 513 OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, true); 514 OH_ArkUI_DragPreviewOption_SetScaleMode( 515 dragPreviewOption, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_AUTO); 516 auto* option = reinterpret_cast<ArkUIDragPreViewAndInteractionOptions*>(dragPreviewOption); 517 EXPECT_TRUE(option->isScaleEnabled); 518 EXPECT_FALSE(option->isDefaultShadowEnabled); 519 EXPECT_FALSE(option->isDefaultRadiusEnabled); 520 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 521 } 522 523 /** 524 * @tc.name: DragAndDropTest016 525 * @tc.desc: Test OH_ArkUI_SetNodeDragPreviewOption. 526 * @tc.type: FUNC 527 */ 528 HWTEST_F(DragAndDropTest, DragAndDropTest016, TestSize.Level1) 529 { 530 /** 531 * @tc.steps: step1.create dragPreviewOption and call mix related function. 532 * @tc.expected: Return expected results. 533 */ 534 auto* dragPreviewOption = OH_ArkUI_CreateDragPreviewOption(); 535 OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, true); 536 OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, true); 537 OH_ArkUI_DragPreviewOption_SetScaleMode( 538 dragPreviewOption, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_AUTO); 539 auto textNode = new ArkUI_Node({ ARKUI_NODE_TEXT, nullptr, true }); 540 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 541 OH_ArkUI_DragPreviewOption_SetScaleMode( 542 dragPreviewOption, ArkUI_DragPreviewScaleMode::ARKUI_DRAG_PREVIEW_SCALE_DISABLED); 543 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 544 OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, true); 545 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 546 OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(dragPreviewOption, false); 547 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 548 OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, true); 549 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 550 OH_ArkUI_DragPreviewOption_SetDefaultRadiusEnabled(dragPreviewOption, false); 551 EXPECT_EQ(OH_ArkUI_SetNodeDragPreviewOption(textNode, dragPreviewOption), ARKUI_ERROR_CODE_NO_ERROR); 552 553 /** 554 * @tc.steps: step2.set preview option with nullptr. 555 * @tc.expected: Return expected results. 556 */ 557 auto ret2 = OH_ArkUI_SetNodeDragPreviewOption(nullptr, dragPreviewOption); 558 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 559 OH_ArkUI_DragPreviewOption_Dispose(dragPreviewOption); 560 delete textNode; 561 } 562 563 /** 564 * @tc.name: DragAndDropTest0017 565 * @tc.desc: test set DragEvent property function; 566 * @tc.type: FUNC 567 */ 568 HWTEST_F(DragAndDropTest, DragAndDropTest0017, TestSize.Level1) 569 { 570 /** 571 *@tc.steps : step1.create and set property. 572 */ 573 ArkUIDragEvent dragEvent; 574 dragEvent.windowX = WINDOW_X; 575 dragEvent.windowY = WINDOW_Y; 576 dragEvent.displayX = DISPLAY_X; 577 dragEvent.displayY = DISPLAY_Y; 578 dragEvent.touchPointX = TOUCH_POINT_X; 579 dragEvent.touchPointY = TOUCH_POINT_Y; 580 581 dragEvent.previewRectWidth = PREVIEW_RECT_WIDTH; 582 dragEvent.previewRectHeight = PREVIEW_RECT_HEIGHT; 583 dragEvent.velocityX = VELOCITY_X; 584 dragEvent.velocityY = VELOCITY_Y; 585 dragEvent.velocity = VELOCITY; 586 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 587 588 /** 589 * @tc.expected: Return expected results. 590 */ 591 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToWindow(drag_Event), WINDOW_X); 592 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToWindow(drag_Event), WINDOW_Y); 593 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointX(drag_Event), TOUCH_POINT_X); 594 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointY(drag_Event), TOUCH_POINT_Y); 595 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToDisplay(drag_Event), DISPLAY_X); 596 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToDisplay(drag_Event), DISPLAY_Y); 597 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectWidth(drag_Event), PREVIEW_RECT_WIDTH); 598 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectHeight(drag_Event), PREVIEW_RECT_HEIGHT); 599 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityX(drag_Event), VELOCITY_X); 600 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityY(drag_Event), VELOCITY_Y); 601 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocity(drag_Event), VELOCITY); 602 } 603 604 /** 605 * @tc.name: DragAndDropTest0018 606 * @tc.desc: test set DragEvent property function; 607 * @tc.type: FUNC 608 */ 609 HWTEST_F(DragAndDropTest, DragAndDropTest0018, TestSize.Level1) 610 { 611 /** 612 * @tc.expected: Return expected results. 613 */ 614 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToWindow(nullptr), 0.0f); 615 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToWindow(nullptr), 0.0f); 616 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointX(nullptr), 0.0f); 617 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointY(nullptr), 0.0f); 618 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToDisplay(nullptr), 0.0f); 619 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToDisplay(nullptr), 0.0f); 620 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectWidth(nullptr), 0.0f); 621 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectHeight(nullptr), 0.0f); 622 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityX(nullptr), 0.0f); 623 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityY(nullptr), 0.0f); 624 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocity(nullptr), 0.0f); 625 } 626 627 /** 628 * @tc.name: DragAndDropTest0019 629 * @tc.desc: test ConvertOriginEventType function for drag event. 630 * @tc.type: FUNC 631 */ 632 HWTEST_F(DragAndDropTest, DragAndDropTest019, TestSize.Level1) 633 { 634 int32_t ret; 635 int32_t nodeType = static_cast<int32_t>(NODE_ON_PRE_DRAG); 636 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_PRE_DRAG, nodeType); 637 EXPECT_EQ(ret, static_cast<int32_t>(ON_PRE_DRAG)); 638 639 nodeType = static_cast<int32_t>(NODE_ON_DRAG_START); 640 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DRAG_START, nodeType); 641 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_START)); 642 643 nodeType = static_cast<int32_t>(NODE_ON_DRAG_ENTER); 644 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DRAG_ENTER, nodeType); 645 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_ENTER)); 646 647 nodeType = static_cast<int32_t>(NODE_ON_DRAG_MOVE); 648 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DRAG_MOVE, nodeType); 649 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_MOVE)); 650 651 nodeType = static_cast<int32_t>(NODE_ON_DRAG_LEAVE); 652 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DRAG_LEAVE, nodeType); 653 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_LEAVE)); 654 655 nodeType = static_cast<int32_t>(NODE_ON_DROP); 656 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DROP, nodeType); 657 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_DROP)); 658 659 nodeType = static_cast<int32_t>(NODE_ON_DRAG_END); 660 ret = OHOS::Ace::NodeModel::ConvertOriginEventType(NODE_ON_DRAG_END, nodeType); 661 EXPECT_EQ(ret, static_cast<int32_t>(ON_DRAG_END)); 662 } 663 664 /** 665 * @tc.name: DragAndDropTest0020 666 * @tc.desc: test ConvertToNodeEventType function for drag event. 667 * @tc.type: FUNC 668 */ 669 HWTEST_F(DragAndDropTest, DragAndDropTest020, TestSize.Level1) 670 { 671 int32_t ret; 672 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_PRE_DRAG); 673 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_PRE_DRAG)); 674 675 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_START); 676 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DRAG_START)); 677 678 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_ENTER); 679 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DRAG_ENTER)); 680 681 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_MOVE); 682 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DRAG_MOVE)); 683 684 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_LEAVE); 685 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DRAG_LEAVE)); 686 687 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_DROP); 688 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DROP)); 689 690 ret = OHOS::Ace::NodeModel::ConvertToNodeEventType(ON_DRAG_END); 691 EXPECT_EQ(ret, static_cast<int32_t>(NODE_ON_DRAG_END)); 692 } 693 694 /** 695 * @tc.name: DragAndDropTest0021 696 * @tc.desc: test OH_ArkUI_DragEvent_GetDropOperation. 697 * @tc.type: FUNC 698 */ 699 HWTEST_F(DragAndDropTest, DragAndDropTest021, TestSize.Level1) 700 { 701 /** 702 *@tc.steps : step1.create and set property. 703 */ 704 ArkUIDragEvent dragEvent; 705 dragEvent.dragBehavior = ArkUI_DropOperation::ARKUI_DROP_OPERATION_MOVE; 706 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 707 ArkUI_DropOperation operation; 708 auto ret = OH_ArkUI_DragEvent_GetDropOperation(drag_Event, &operation); 709 710 /** 711 * @tc.expected: Return expected results. 712 */ 713 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 714 EXPECT_EQ(operation, ArkUI_DropOperation::ARKUI_DROP_OPERATION_MOVE); 715 EXPECT_EQ(OH_ArkUI_DragEvent_GetDropOperation(nullptr, &operation), ARKUI_ERROR_CODE_PARAM_INVALID); 716 EXPECT_EQ(OH_ArkUI_DragEvent_GetDropOperation(drag_Event, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 717 } 718 719 /** 720 * @tc.name: DragAndDropTest0022 721 * @tc.desc: Test the OH_ArkUI_DragEvent_GetModifierKeyStates. 722 * @tc.type: FUNC 723 */ 724 HWTEST_F(DragAndDropTest, DragAndDropTest0022, TestSize.Level1) 725 { 726 /** 727 * @tc.steps: step1.create DragEvent, related function is called. 728 */ 729 uint64_t pressedKeys = 0; 730 ArkUIDragEvent dragEvent; 731 dragEvent.modifierKeyState = (1 << 0); 732 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 733 auto ret1 = OH_ArkUI_DragEvent_GetModifierKeyStates(drag_Event, &pressedKeys); 734 735 /** 736 * @tc.steps: step2.set DragEvent is nullptr, related function is called. 737 */ 738 auto ret2 = OH_ArkUI_DragEvent_GetModifierKeyStates(nullptr, nullptr); 739 740 /** 741 * @tc.expected: Return expected results. 742 */ 743 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 744 EXPECT_EQ(pressedKeys, (1 << 0)); 745 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 746 } 747 748 /** 749 * @tc.name: DragAndDropTest0023 750 * @tc.desc: Test the OH_ArkUI_DragEvent_GetDataTypeCount. 751 * @tc.type: FUNC 752 */ 753 HWTEST_F(DragAndDropTest, DragAndDropTest0023, TestSize.Level1) 754 { 755 /** 756 * @tc.steps: step1.create DragEvent, related function is called. 757 */ 758 int32_t count = 0; 759 ArkUIDragEvent dragEvent; 760 dragEvent.dataTypesCount = 2; 761 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 762 auto ret1 = OH_ArkUI_DragEvent_GetDataTypeCount(drag_Event, &count); 763 764 /** 765 * @tc.steps: step2.set DragEvent is nullptr, related function is called. 766 */ 767 auto ret2 = OH_ArkUI_DragEvent_GetDataTypeCount(nullptr, nullptr); 768 769 /** 770 * @tc.expected: Return expected results. 771 */ 772 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 773 EXPECT_EQ(count, 2); 774 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 775 } 776 777 /** 778 * @tc.name: DragAndDropTest0024 779 * @tc.desc: Test the OH_ArkUI_DragEvent_GetDataTypes. 780 * @tc.type: FUNC 781 */ 782 HWTEST_F(DragAndDropTest, DragAndDropTest0024, TestSize.Level1) 783 { 784 /** 785 * @tc.steps: step1.create DragEvent and set null parameters. 786 * @tc.expected: Return expected results. 787 */ 788 ArkUIDragEvent dragEvent; 789 dragEvent.dataTypesCount = 5; 790 dragEvent.dataTypesMaxStrLength = 128; 791 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 792 793 auto ret1 = OH_ArkUI_DragEvent_GetDataTypes(nullptr, nullptr, 1, 128); 794 auto ret2 = OH_ArkUI_DragEvent_GetDataTypes(drag_Event, nullptr, 1, 128); 795 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 796 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 797 798 /** 799 * @tc.steps: step1.create DragEvent and set BufferSizeError parameters. 800 * @tc.expected: Return expected results. 801 */ 802 char stringArray[10][128]; 803 char *types1[128]; 804 for (int i = 0; i < 10; i++) { 805 types1[i] = stringArray[i]; 806 } 807 auto ret3 = OH_ArkUI_DragEvent_GetDataTypes(drag_Event, types1, 1, 128); 808 auto ret4 = OH_ArkUI_DragEvent_GetDataTypes(drag_Event, types1, 6, 127); 809 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR); 810 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_BUFFER_SIZE_ERROR); 811 812 /** 813 * @tc.steps: step1.create DragEvent and set no error parameters. 814 * @tc.expected: Return expected results. 815 */ 816 const char *dataTypes[128]; 817 for (int i = 0; i < 10; i++) { 818 dataTypes[i] = stringArray[i]; 819 } 820 dragEvent.dataTypes = dataTypes; 821 dragEvent.dataTypes[0] = strdup("text/plain"); 822 dragEvent.dataTypes[1] = strdup("image/png"); 823 drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 824 auto ret5 = OH_ArkUI_DragEvent_GetDataTypes(drag_Event, types1, 6, 128); 825 EXPECT_EQ(ret5, ARKUI_ERROR_CODE_NO_ERROR); 826 } 827 828 /** 829 * @tc.name: DragAndDropTest0025 830 * @tc.desc: Test the OH_ArkUI_CreateDragActionWithNode. 831 * @tc.type: FUNC 832 */ 833 HWTEST_F(DragAndDropTest, DragAndDropTest0025, TestSize.Level1) 834 { 835 /** 836 * @tc.steps: step1.set null ArkUI_NodeHandle, related function is called. 837 */ 838 auto* dragAction = OH_ArkUI_CreateDragActionWithNode(nullptr); 839 840 /** 841 * @tc.expected: Return expected results. 842 */ 843 EXPECT_EQ(dragAction, nullptr); 844 } 845 846 /** 847 * @tc.name: DragAndDropTest0026 848 * @tc.desc: Test the OH_ArkUI_CreateDragActionWithContext. 849 * @tc.type: FUNC 850 */ 851 HWTEST_F(DragAndDropTest, DragAndDropTest0026, TestSize.Level1) 852 { 853 /** 854 * @tc.steps: step1.set null ArkUI_ContextHandle, related function is called. 855 */ 856 auto* dragAction = OH_ArkUI_CreateDragActionWithContext(nullptr); 857 OH_ArkUI_DragAction_Dispose(dragAction); 858 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointX(dragAction, 1.0), ARKUI_ERROR_CODE_PARAM_INVALID); 859 EXPECT_EQ(OH_ArkUI_DragAction_SetTouchPointY(dragAction, 1.0), ARKUI_ERROR_CODE_PARAM_INVALID); 860 861 /** 862 * @tc.expected: Return expected results. 863 */ 864 EXPECT_EQ(dragAction, nullptr); 865 } 866 867 /** 868 * @tc.name: DragAndDropTest0027 869 * @tc.desc: Test the OH_ArkUI_CreateDragActionWithContext. 870 * @tc.type: FUNC 871 */ 872 HWTEST_F(DragAndDropTest, DragAndDropTest0027, TestSize.Level1) 873 { 874 /** 875 * @tc.steps: step1.create dragAction. 876 */ 877 auto uiContext = new ArkUI_Context({ .id = 1 }); 878 auto dragAction = OH_ArkUI_CreateDragActionWithContext(uiContext); 879 EXPECT_NE(dragAction, nullptr); 880 881 /** 882 * @tc.steps: step2.set pointer is smaller than MIN_POINTID, related function is called. 883 */ 884 auto ret1 = OH_ArkUI_DragAction_SetPointerId(dragAction, -1); 885 886 /** 887 * @tc.steps: step2.set dragAction is null, related function is called. 888 */ 889 auto ret2 = OH_ArkUI_DragAction_SetPointerId(nullptr, 1); 890 891 /** 892 * @tc.expected: Return expected results. 893 */ 894 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 895 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 896 OH_ArkUI_DragAction_Dispose(dragAction); 897 delete uiContext; 898 } 899 900 /** 901 * @tc.name: DragAndDropTest0028 902 * @tc.desc: Test the OH_ArkUI_DragAction_SetDragPreviewOption. 903 * @tc.type: FUNC 904 */ 905 HWTEST_F(DragAndDropTest, DragAndDropTest0028, TestSize.Level1) 906 { 907 /** 908 * @tc.steps: step1.create dragAction. 909 */ 910 auto uiContext = new ArkUI_Context({ .id = 1 }); 911 auto dragAction = OH_ArkUI_CreateDragActionWithContext(uiContext); 912 EXPECT_NE(dragAction, nullptr); 913 auto *previewOptions = OH_ArkUI_CreateDragPreviewOption(); 914 OH_ArkUI_DragPreviewOption_SetDefaultShadowEnabled(previewOptions, true); 915 auto ret1 = OH_ArkUI_DragAction_SetDragPreviewOption(dragAction, previewOptions); 916 917 /** 918 * @tc.steps: step2.set dragAction is null, related function is called. 919 */ 920 auto ret2 = OH_ArkUI_DragAction_SetDragPreviewOption(nullptr, previewOptions); 921 922 /** 923 * @tc.expected: Return expected results. 924 */ 925 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 926 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 927 OH_ArkUI_DragPreviewOption_Dispose(previewOptions); 928 OH_ArkUI_DragAction_Dispose(dragAction); 929 delete uiContext; 930 } 931 932 /** 933 * @tc.name: DragAndDropTest0029 934 * @tc.desc: Test the OH_ArkUI_DragAction_RegisterStatusListener. 935 * @tc.type: FUNC 936 */ 937 HWTEST_F(DragAndDropTest, DragAndDropTest0029, TestSize.Level1) 938 { 939 /** 940 * @tc.steps: step1.set dragAction is null, related function is called. 941 */ 942 auto ret = OH_ArkUI_DragAction_RegisterStatusListener( __anon65be1aee0402(ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) 943 nullptr, nullptr, [](ArkUI_DragAndDropInfo* dragAndDropInfo, void* userData) -> void { 944 EXPECT_NE( 945 OH_ArkUI_DragAndDropInfo_GetDragStatus(dragAndDropInfo), ArkUI_DragStatus::ARKUI_DRAG_STATUS_UNKNOWN); 946 EXPECT_NE(OH_ArkUI_DragAndDropInfo_GetDragEvent(dragAndDropInfo), nullptr); 947 }); 948 OH_ArkUI_DragAction_UnregisterStatusListener(nullptr); 949 950 /** 951 * @tc.expected: Return expected results. 952 */ 953 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 954 } 955 956 /** 957 * @tc.name: DragAndDropTest0030 958 * @tc.desc: Test the OH_ArkUI_DragAndDropInfo_GetDragStatus. 959 * @tc.type: FUNC 960 */ 961 HWTEST_F(DragAndDropTest, DragAndDropTest0030, TestSize.Level1) 962 { 963 /** 964 * @tc.steps: step1.set dragAction is null, related function is called. 965 */ 966 auto ret1 = OH_ArkUI_DragAndDropInfo_GetDragStatus(nullptr); 967 auto ret2 = OH_ArkUI_DragAndDropInfo_GetDragEvent(nullptr); 968 969 /** 970 * @tc.expected: Return expected results. 971 */ 972 EXPECT_EQ(ret1, ArkUI_DragStatus::ARKUI_DRAG_STATUS_UNKNOWN); 973 EXPECT_EQ(ret2, nullptr); 974 } 975 976 /** 977 * @tc.name: DragAndDropTest0031 978 * @tc.desc: Test the OH_ArkUI_SetNodeDragPreview. 979 * @tc.type: FUNC 980 */ 981 HWTEST_F(DragAndDropTest, DragAndDropTest0031, TestSize.Level1) 982 { 983 /** 984 * @tc.steps: step1.set ArkUI_NodeHandle is null, related function is called. 985 * @tc.expected: Return expected results. 986 */ 987 auto ret = OH_ArkUI_SetNodeDragPreview(nullptr, nullptr); 988 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 989 990 /** 991 * @tc.steps: step1.set ArkUI_NodeHandle is not null, related function is called. 992 * @tc.expected: Return expected results. 993 */ 994 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 995 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 996 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 997 ret = OH_ArkUI_SetNodeDragPreview(dragNode, nullptr); 998 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 999 } 1000 1001 /** 1002 * @tc.name: DragAndDropTest0032 1003 * @tc.desc: Test the OH_ArkUI_SetNodeAllowedDropDataTypes. 1004 * @tc.type: FUNC 1005 */ 1006 HWTEST_F(DragAndDropTest, DragAndDropTest0032, TestSize.Level1) 1007 { 1008 /** 1009 * @tc.steps: step1.set ArkUI_NodeHandle is null, related function is called. 1010 */ 1011 auto ret1 = OH_ArkUI_SetNodeAllowedDropDataTypes(nullptr, nullptr, -1); 1012 1013 /** 1014 * @tc.steps: step1.set ArkUI_NodeHandle and typesArray, related function is called. 1015 */ 1016 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 1017 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 1018 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 1019 std::vector<const char *> strlist; 1020 strlist.push_back("general.text"); 1021 strlist.push_back("general.plain-text"); 1022 auto ret2 = OH_ArkUI_SetNodeAllowedDropDataTypes(dragNode, strlist.data(), strlist.size()); 1023 1024 /** 1025 * @tc.expected: Return expected results. 1026 */ 1027 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1028 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1029 } 1030 1031 /** 1032 * @tc.name: DragAndDropTest0033 1033 * @tc.desc: Test the OH_ArkUI_SetDragEventStrictReportWithNode. 1034 * @tc.type: FUNC 1035 */ 1036 HWTEST_F(DragAndDropTest, DragAndDropTest0033, TestSize.Level1) 1037 { 1038 /** 1039 * @tc.steps: step1.set ArkUI_NodeHandle is null, related function is called. 1040 */ 1041 auto ret1 = OH_ArkUI_SetDragEventStrictReportWithNode(nullptr, false); 1042 1043 /** 1044 * @tc.steps: step1.set ArkUI_NodeHandle and typesArray, related function is called. 1045 */ 1046 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 1047 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 1048 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 1049 auto ret2 = OH_ArkUI_SetDragEventStrictReportWithNode(dragNode, true); 1050 1051 /** 1052 * @tc.expected: Return expected results. 1053 */ 1054 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1055 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1056 } 1057 1058 /** 1059 * @tc.name: DragAndDropTest0034 1060 * @tc.desc: Test the OH_ArkUI_SetDragEventStrictReportWithContext. 1061 * @tc.type: FUNC 1062 */ 1063 HWTEST_F(DragAndDropTest, DragAndDropTest0034, TestSize.Level1) 1064 { 1065 /** 1066 * @tc.steps: step1.set ArkUI_NodeHandle is null, related function is called. 1067 */ 1068 auto ret1 = OH_ArkUI_SetDragEventStrictReportWithContext(nullptr, false); 1069 1070 /** 1071 * @tc.steps: step1.set ArkUI_NodeHandle and typesArray, related function is called. 1072 */ 1073 auto uiContext = new ArkUI_Context({ .id = 1 }); 1074 auto ret2 = OH_ArkUI_SetDragEventStrictReportWithContext(uiContext, true); 1075 1076 /** 1077 * @tc.expected: Return expected results. 1078 */ 1079 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1080 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1081 delete uiContext; 1082 } 1083 1084 /** 1085 * @tc.name: DragAndDropTest0035 1086 * @tc.desc: Test the OH_ArkUI_DisallowNodeAnyDropDataTypes. 1087 * @tc.type: FUNC 1088 */ 1089 HWTEST_F(DragAndDropTest, DragAndDropTest0035, TestSize.Level1) 1090 { 1091 /** 1092 * @tc.steps: step1.set ArkUI_ContextHandle is null, related function is called. 1093 */ 1094 auto ret1 = OH_ArkUI_DisallowNodeAnyDropDataTypes(nullptr); 1095 1096 /** 1097 * @tc.steps: step1.set ArkUI_ContextHandle, related function is called. 1098 */ 1099 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 1100 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 1101 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 1102 auto ret2 = OH_ArkUI_DisallowNodeAnyDropDataTypes(dragNode); 1103 1104 /** 1105 * @tc.expected: Return expected results. 1106 */ 1107 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1108 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1109 } 1110 1111 /** 1112 * @tc.name: DragAndDropTest0036 1113 * @tc.desc: Test the OH_ArkUI_AllowNodeAllDropDataTypes. 1114 * @tc.type: FUNC 1115 */ 1116 HWTEST_F(DragAndDropTest, DragAndDropTest0036, TestSize.Level1) 1117 { 1118 /** 1119 * @tc.steps: step1.set ArkUI_ContextHandle is null, related function is called. 1120 */ 1121 auto ret1 = OH_ArkUI_AllowNodeAllDropDataTypes(nullptr); 1122 1123 /** 1124 * @tc.steps: step1.set ArkUI_ContextHandle, related function is called. 1125 */ 1126 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 1127 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 1128 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 1129 auto ret2 = OH_ArkUI_AllowNodeAllDropDataTypes(dragNode); 1130 1131 /** 1132 * @tc.expected: Return expected results. 1133 */ 1134 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1135 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1136 } 1137 1138 /** 1139 * @tc.name: DragAndDropTest0037 1140 * @tc.desc: Test the OH_ArkUI_DragEvent_GetDragResult. 1141 * @tc.type: FUNC 1142 */ 1143 HWTEST_F(DragAndDropTest, DragAndDropTest0037, TestSize.Level1) 1144 { 1145 /** 1146 * @tc.steps: step1.set ArkUI_DragEvent is null, related function is called. 1147 */ 1148 auto ret1 = OH_ArkUI_DragEvent_GetDragResult(nullptr, nullptr); 1149 1150 /** 1151 * @tc.steps: step1.set ArkUI_DragEvent and DragResult, related function is called. 1152 */ 1153 ArkUIDragEvent dragEvent; 1154 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1155 ArkUI_DragResult result; 1156 auto ret2 = OH_ArkUI_DragEvent_GetDragResult(drag_Event, &result); 1157 1158 /** 1159 * @tc.expected: Return expected results. 1160 */ 1161 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1162 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1163 } 1164 1165 /** 1166 * @tc.name: DragAndDropTest0038 1167 * @tc.desc: Test the OH_ArkUI_DragEvent_SetDragResult. 1168 * @tc.type: FUNC 1169 */ 1170 HWTEST_F(DragAndDropTest, DragAndDropTest0038, TestSize.Level1) 1171 { 1172 /** 1173 * @tc.steps: step1.set ArkUI_DragEvent is null, related function is called. 1174 */ 1175 auto ret1 = OH_ArkUI_DragEvent_SetDragResult(nullptr, ArkUI_DragResult::ARKUI_DRAG_RESULT_SUCCESSFUL); 1176 1177 /** 1178 * @tc.steps: step1.set ArkUI_DragEvent and DragResult, related function is called. 1179 */ 1180 ArkUIDragEvent dragEvent; 1181 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1182 auto ret2 = OH_ArkUI_DragEvent_SetDragResult(drag_Event, ArkUI_DragResult::ARKUI_DRAG_RESULT_SUCCESSFUL); 1183 1184 /** 1185 * @tc.expected: Return expected results. 1186 */ 1187 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1188 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1189 } 1190 1191 /** 1192 * @tc.name: DragAndDropTest0039 1193 * @tc.desc: Test the OH_ArkUI_DragEvent_SetSuggestedDropOperation. 1194 * @tc.type: FUNC 1195 */ 1196 HWTEST_F(DragAndDropTest, DragAndDropTest0039, TestSize.Level1) 1197 { 1198 /** 1199 * @tc.steps: step1.set ArkUI_DragEvent is null, related function is called. 1200 */ 1201 auto ret1 = OH_ArkUI_DragEvent_SetSuggestedDropOperation(nullptr, 1202 ArkUI_DropOperation::ARKUI_DROP_OPERATION_COPY); 1203 1204 /** 1205 * @tc.steps: step1.set ArkUI_DragEvent and DropOperation, related function is called. 1206 */ 1207 ArkUIDragEvent dragEvent; 1208 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1209 auto ret2 = OH_ArkUI_DragEvent_SetSuggestedDropOperation(drag_Event, 1210 ArkUI_DropOperation::ARKUI_DROP_OPERATION_COPY); 1211 1212 /** 1213 * @tc.expected: Return expected results. 1214 */ 1215 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1216 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1217 } 1218 1219 /** 1220 * @tc.name: DragAndDropTest0040 1221 * @tc.desc: Test the OH_ArkUI_CancelDataLoading. 1222 * @tc.type: FUNC 1223 */ 1224 HWTEST_F(DragAndDropTest, DragAndDropTest0040, TestSize.Level1) 1225 { 1226 /** 1227 * @tc.steps: step1.set ArkUI_ContextHandle is null, related function is called. 1228 */ 1229 const char* key = "testKey"; 1230 auto ret1 = OH_ArkUI_CancelDataLoading(nullptr, key); 1231 1232 /** 1233 * @tc.expected: Return expected results. 1234 */ 1235 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1236 } 1237 1238 /** 1239 * @tc.name: DragAndDropTest0041 1240 * @tc.desc: Test the OH_ArkUI_DisableDropDataPrefetchOnNode. 1241 * @tc.type: FUNC 1242 */ 1243 HWTEST_F(DragAndDropTest, DragAndDropTest0041, TestSize.Level1) 1244 { 1245 /** 1246 * @tc.steps: step1.set ArkUI_NodeHandle is null, related function is called. 1247 */ 1248 auto ret1 = OH_ArkUI_DisableDropDataPrefetchOnNode(nullptr, false); 1249 1250 /** 1251 * @tc.steps: step1.set ArkUI_NodeHandle, related function is called. 1252 */ 1253 ArkUI_NativeNodeAPI_1 *nodeAPI = nullptr; 1254 OH_ArkUI_GetModuleInterface(ARKUI_NATIVE_NODE, ArkUI_NativeNodeAPI_1, nodeAPI); 1255 auto dragNode = nodeAPI->createNode(ARKUI_NODE_COLUMN); 1256 auto ret2 = OH_ArkUI_DisableDropDataPrefetchOnNode(dragNode, false); 1257 1258 /** 1259 * @tc.expected: Return expected results. 1260 */ 1261 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1262 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_NO_ERROR); 1263 } 1264 1265 /** 1266 * @tc.name: DragAndDropTest0042 1267 * @tc.desc: Test the OH_ArkUI_DragEvent_RequestDragEndPending. 1268 * @tc.type: FUNC 1269 */ 1270 HWTEST_F(DragAndDropTest, DragAndDropTest0042, TestSize.Level1) 1271 { 1272 /** 1273 * @tc.steps: step1.set ArkUI_DragEvent is null, related function is called. 1274 */ 1275 auto ret1 = OH_ArkUI_DragEvent_RequestDragEndPending(nullptr, nullptr); 1276 1277 /** 1278 * @tc.steps: step1.set ArkUI_DragEvent and requestIdentify, related function is called. 1279 */ 1280 ArkUIDragEvent dragEvent; 1281 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1282 int32_t requestIdentify = 0; 1283 auto ret2 = OH_ArkUI_DragEvent_RequestDragEndPending(drag_Event, &requestIdentify); 1284 1285 /** 1286 * @tc.expected: Return expected results. 1287 */ 1288 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1289 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1290 EXPECT_EQ(dragEvent.isDragEndPending, false); 1291 } 1292 1293 /** 1294 * @tc.name: DragAndDropTest0043 1295 * @tc.desc: test set DragEvent property function; 1296 * @tc.type: FUNC 1297 */ 1298 HWTEST_F(DragAndDropTest, DragAndDropTest0043, TestSize.Level1) 1299 { 1300 /** 1301 *@tc.steps : step1.create and set property. 1302 */ 1303 ArkUIDragEvent dragEvent; 1304 dragEvent.displayId = DISPLAYID; 1305 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1306 int32_t displayId = -1; 1307 auto ret1 = OH_ArkUI_DragEvent_GetDisplayId(drag_Event, &displayId); 1308 auto ret2 = OH_ArkUI_DragEvent_GetDisplayId(nullptr, &displayId); 1309 auto ret3 = OH_ArkUI_DragEvent_GetDisplayId(drag_Event, nullptr); 1310 /** 1311 * @tc.expected: Return expected results. 1312 */ 1313 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_NO_ERROR); 1314 EXPECT_EQ(displayId, DISPLAYID); 1315 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1316 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 1317 } 1318 1319 /** 1320 * @tc.name: DragAndDropTest0044 1321 * @tc.desc: Test the OH_ArkUI_DragEvent_GetDragSource. 1322 * @tc.type: FUNC 1323 */ 1324 HWTEST_F(DragAndDropTest, DragAndDropTest0044, TestSize.Level1) 1325 { 1326 /** 1327 * @tc.steps: step1.create DragEvent 1328 */ 1329 char bundleNameError[10]; 1330 int32_t lengthError = 10; 1331 ArkUIDragEvent dragEvent; 1332 char dragEventBundleName[] = "com.example.tdd"; 1333 int32_t err = strcpy_s(dragEvent.bundleName, sizeof(dragEvent.bundleName), dragEventBundleName); 1334 ASSERT_EQ(err, 0); 1335 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1336 1337 /** 1338 * @tc.steps: step2.set bundleNameError length shorter than dragEventBundleName, related function is called. 1339 */ 1340 auto ret1 = OH_ArkUI_DragEvent_GetDragSource(drag_Event, bundleNameError, lengthError); 1341 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1342 1343 /** 1344 * @tc.steps: step3.set ArkUI_DragEvent null, related function is called. 1345 */ 1346 char bundleName[200]; 1347 int32_t length = 200; 1348 auto ret2 = OH_ArkUI_DragEvent_GetDragSource(nullptr, bundleNameError, lengthError); 1349 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1350 1351 /** 1352 * @tc.steps: step3.set bundleName null, related function is called. 1353 */ 1354 auto ret3 = OH_ArkUI_DragEvent_GetDragSource(drag_Event, nullptr, length); 1355 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_PARAM_INVALID); 1356 1357 /** 1358 * @tc.steps: step4.set bundleName not null, related function is called. 1359 */ 1360 auto ret4 = OH_ArkUI_DragEvent_GetDragSource(drag_Event, bundleName, length); 1361 EXPECT_EQ(ret4, ARKUI_ERROR_CODE_NO_ERROR); 1362 EXPECT_EQ(*bundleName, *dragEventBundleName); 1363 } 1364 1365 /** 1366 * @tc.name: DragAndDropTest0045 1367 * @tc.desc: Test the OH_ArkUI_DragEvent_IsRemote. 1368 * @tc.type: FUNC 1369 */ 1370 HWTEST_F(DragAndDropTest, DragAndDropTest0045, TestSize.Level1) 1371 { 1372 /** 1373 * @tc.steps: step1.create DragEvent 1374 */ 1375 bool isRemote = false; 1376 ArkUIDragEvent dragEvent; 1377 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1378 1379 /** 1380 * @tc.steps: step2.set ArkUI_DragEvent null, related function is called. 1381 */ 1382 auto ret1 = OH_ArkUI_DragEvent_IsRemote(nullptr, &isRemote); 1383 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1384 1385 /** 1386 * @tc.steps: step2.set isRemote null, related function is called. 1387 */ 1388 auto ret2 = OH_ArkUI_DragEvent_IsRemote(drag_Event, nullptr); 1389 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1390 1391 /** 1392 * @tc.steps: step3.set isRemote not null, related function is called. 1393 */ 1394 dragEvent.isRemoteDev = true; 1395 auto ret3 = OH_ArkUI_DragEvent_IsRemote(drag_Event, &isRemote); 1396 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_NO_ERROR); 1397 EXPECT_EQ(isRemote, dragEvent.isRemoteDev); 1398 } 1399 1400 /** 1401 * @tc.name: DragAndDropTest0046 1402 * @tc.desc: Test the OH_ArkUI_DragAction_SetDataLoadParams. 1403 * @tc.type: FUNC 1404 */ 1405 HWTEST_F(DragAndDropTest, DragAndDropTest0046, TestSize.Level1) 1406 { 1407 /** 1408 * @tc.steps: step1.create dragAction 1409 */ 1410 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 1411 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 1412 auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK); 1413 auto rootFrameNode = reinterpret_cast<ArkUI_Node*>(rootNode); 1414 ASSERT_NE(rootFrameNode, nullptr); 1415 auto frameNode = reinterpret_cast<NG::FrameNode*>(rootFrameNode->uiNodeHandle); 1416 ASSERT_NE(frameNode, nullptr); 1417 auto context = NG::MockPipelineContext::GetCurrent(); 1418 frameNode->context_ = AceType::RawPtr(context); 1419 auto* dragAction = OH_ArkUI_CreateDragActionWithNode(rootNode); 1420 ASSERT_NE(dragAction, nullptr); 1421 OH_UdmfDataLoadParams* dataLoadParams = OH_UdmfDataLoadParams_Create(); 1422 1423 /** 1424 * @tc.steps: step2.set dragAction null, related function is called. 1425 */ 1426 auto ret1 = OH_ArkUI_DragAction_SetDataLoadParams(nullptr, dataLoadParams); 1427 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1428 1429 /** 1430 * @tc.steps: step3.set dataLoadParams null, related function is called. 1431 */ 1432 auto ret2 = OH_ArkUI_DragAction_SetDataLoadParams(dragAction, nullptr); 1433 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1434 1435 /** 1436 * @tc.steps: step4.set dragAction and dataLoadParams not null, related function is called. 1437 */ 1438 auto ret3 = OH_ArkUI_DragAction_SetDataLoadParams(dragAction, dataLoadParams); 1439 OH_UdmfDataLoadParams_Destroy(dataLoadParams); 1440 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_NO_ERROR); 1441 auto* dragActions = reinterpret_cast<ArkUIDragAction*>(dragAction); 1442 ASSERT_NE(dragAction, nullptr); 1443 EXPECT_EQ(dragActions->useDataLoadParams, true); 1444 OH_ArkUI_DragAction_Dispose(dragAction); 1445 } 1446 1447 /** 1448 * @tc.name: DragAndDropTest0047 1449 * @tc.desc: Test the OH_ArkUI_DragEvent_SetDataLoadParams. 1450 * @tc.type: FUNC 1451 */ 1452 HWTEST_F(DragAndDropTest, DragAndDropTest0047, TestSize.Level1) 1453 { 1454 /** 1455 * @tc.steps: step1.create DragEvent, related function is called. 1456 */ 1457 ArkUIDragEvent dragEvent; 1458 dragEvent.key = "key_string"; 1459 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1460 ASSERT_NE(drag_Event, nullptr); 1461 OH_UdmfDataLoadParams* dataLoadParams = OH_UdmfDataLoadParams_Create(); 1462 ASSERT_NE(dataLoadParams, nullptr); 1463 1464 /** 1465 * @tc.steps: step2.set dragAction null, related function is called. 1466 */ 1467 auto ret1 = OH_ArkUI_DragEvent_SetDataLoadParams(nullptr, dataLoadParams); 1468 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1469 1470 /** 1471 * @tc.steps: step3.set dataLoadParams null, related function is called. 1472 */ 1473 auto ret2 = OH_ArkUI_DragEvent_SetDataLoadParams(drag_Event, nullptr); 1474 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1475 1476 /** 1477 * @tc.steps: step4.set dragAction 、 dataLoadParams not null , related function is called. 1478 */ 1479 OH_UdmfDataLoadInfo* info = OH_UdmfDataLoadInfo_Create(); 1480 OH_UdmfDataLoadInfo_SetRecordCount(info, 100); 1481 OH_UdmfDataLoadParams_SetDataLoadInfo(dataLoadParams, info); 1482 auto ret3 = OH_ArkUI_DragEvent_SetDataLoadParams(drag_Event, dataLoadParams); 1483 OH_UdmfDataLoadInfo_Destroy(info); 1484 OH_UdmfDataLoadParams_Destroy(dataLoadParams); 1485 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_NO_ERROR); 1486 EXPECT_EQ(dragEvent.useDataLoadParams, true); 1487 } 1488 1489 /** 1490 * @tc.name: DragAndDropTest0048 1491 * @tc.desc: test set DragEvent property function; 1492 * @tc.type: FUNC 1493 */ 1494 HWTEST_F(DragAndDropTest, DragAndDropTest0048, TestSize.Level1) 1495 { 1496 /** 1497 *@tc.steps : step1.create and set property. 1498 */ 1499 ArkUIDragEvent dragEvent; 1500 dragEvent.windowX = WINDOW_X; 1501 dragEvent.windowY = WINDOW_Y; 1502 dragEvent.displayX = DISPLAY_X; 1503 dragEvent.displayY = DISPLAY_Y; 1504 dragEvent.globalDisplayX = static_cast<double>(GLOBAL_DISPLAY_X); 1505 dragEvent.globalDisplayY = static_cast<double>(GLOBAL_DISPLAY_Y); 1506 dragEvent.touchPointX = TOUCH_POINT_X; 1507 dragEvent.touchPointY = TOUCH_POINT_Y; 1508 1509 dragEvent.previewRectWidth = PREVIEW_RECT_WIDTH; 1510 dragEvent.previewRectHeight = PREVIEW_RECT_HEIGHT; 1511 dragEvent.velocityX = VELOCITY_X; 1512 dragEvent.velocityY = VELOCITY_Y; 1513 dragEvent.velocity = VELOCITY; 1514 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1515 1516 /** 1517 * @tc.expected: Return expected results. 1518 */ 1519 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToWindow(drag_Event), WINDOW_X); 1520 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToWindow(drag_Event), WINDOW_Y); 1521 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointX(drag_Event), TOUCH_POINT_X); 1522 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointY(drag_Event), TOUCH_POINT_Y); 1523 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToDisplay(drag_Event), DISPLAY_X); 1524 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToDisplay(drag_Event), DISPLAY_Y); 1525 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToGlobalDisplay(drag_Event), GLOBAL_DISPLAY_X); 1526 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToGlobalDisplay(drag_Event), GLOBAL_DISPLAY_Y); 1527 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectWidth(drag_Event), PREVIEW_RECT_WIDTH); 1528 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectHeight(drag_Event), PREVIEW_RECT_HEIGHT); 1529 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityX(drag_Event), VELOCITY_X); 1530 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityY(drag_Event), VELOCITY_Y); 1531 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocity(drag_Event), VELOCITY); 1532 } 1533 1534 /** 1535 * @tc.name: DragAndDropTest0049 1536 * @tc.desc: test set DragEvent property function; 1537 * @tc.type: FUNC 1538 */ 1539 HWTEST_F(DragAndDropTest, DragAndDropTest0049, TestSize.Level1) 1540 { 1541 /** 1542 * @tc.expected: Return expected results. 1543 */ 1544 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToWindow(nullptr), 0.0f); 1545 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToWindow(nullptr), 0.0f); 1546 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointX(nullptr), 0.0f); 1547 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewTouchPointY(nullptr), 0.0f); 1548 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToDisplay(nullptr), 0.0f); 1549 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToDisplay(nullptr), 0.0f); 1550 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointXToGlobalDisplay(nullptr), 0.0f); 1551 EXPECT_EQ(OH_ArkUI_DragEvent_GetTouchPointYToGlobalDisplay(nullptr), 0.0f); 1552 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectWidth(nullptr), 0.0f); 1553 EXPECT_EQ(OH_ArkUI_DragEvent_GetPreviewRectHeight(nullptr), 0.0f); 1554 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityX(nullptr), 0.0f); 1555 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocityY(nullptr), 0.0f); 1556 EXPECT_EQ(OH_ArkUI_DragEvent_GetVelocity(nullptr), 0.0f); 1557 } 1558 1559 /** 1560 * @tc.name: DragAndDropTest0050 1561 * @tc.desc: Test OH_ArkUI_DragEvent_GetUdmfData. 1562 * @tc.type: FUNC 1563 */ 1564 HWTEST_F(DragAndDropTest, DragAndDropTest0050, TestSize.Level1) 1565 { 1566 /** 1567 * @tc.steps: step1.create DragEvent, related function is called. 1568 */ 1569 ArkUIDragEvent dragEvent; 1570 dragEvent.key = "key_string"; 1571 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1572 ASSERT_NE(drag_Event, nullptr); 1573 OH_UdmfData* data = OH_UdmfData_Create(); 1574 ASSERT_NE(data, nullptr); 1575 1576 /** 1577 * @tc.steps: step2.set params null. 1578 */ 1579 int32_t ret = OH_ArkUI_DragEvent_GetUdmfData(nullptr, data); 1580 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1581 1582 ret = OH_ArkUI_DragEvent_GetUdmfData(drag_Event, nullptr); 1583 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1584 1585 /** 1586 * @tc.steps: step2.set params not null, related function is called. 1587 */ 1588 ret = OH_ArkUI_DragEvent_GetUdmfData(drag_Event, data); 1589 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1590 OH_UdmfData_Destroy(data); 1591 } 1592 1593 /** 1594 * @tc.name: DragAndDropTest0051 1595 * @tc.desc: Test OH_ArkUI_DragAction_SetPixelMaps. 1596 * @tc.type: FUNC 1597 */ 1598 HWTEST_F(DragAndDropTest, DragAndDropTest0051, TestSize.Level1) 1599 { 1600 /** 1601 * @tc.steps: step1.create params. 1602 */ 1603 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 1604 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 1605 auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK); 1606 auto rootFrameNode = reinterpret_cast<ArkUI_Node*>(rootNode); 1607 ASSERT_NE(rootFrameNode, nullptr); 1608 auto frameNode = reinterpret_cast<NG::FrameNode*>(rootFrameNode->uiNodeHandle); 1609 ASSERT_NE(frameNode, nullptr); 1610 auto context = NG::MockPipelineContext::GetCurrent(); 1611 frameNode->context_ = AceType::RawPtr(context); 1612 auto* dragAction = OH_ArkUI_CreateDragActionWithNode(rootNode); 1613 ASSERT_NE(dragAction, nullptr); 1614 OH_PixelmapNative* pixelmapArray[2]; 1615 int32_t size = 2; 1616 1617 /** 1618 * @tc.steps: step2.set params null, related function is called. 1619 */ 1620 int32_t ret = OH_ArkUI_DragAction_SetPixelMaps(nullptr, nullptr, 0); 1621 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1622 1623 ret = OH_ArkUI_DragAction_SetPixelMaps(dragAction, nullptr, 0); 1624 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1625 1626 ret = OH_ArkUI_DragAction_SetPixelMaps(dragAction, pixelmapArray, 0); 1627 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1628 1629 /** 1630 * @tc.steps: step2.set params not null, related function is called. 1631 */ 1632 ret = OH_ArkUI_DragAction_SetPixelMaps(dragAction, pixelmapArray, size); 1633 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1634 OH_ArkUI_DragAction_Dispose(dragAction); 1635 } 1636 1637 /** 1638 * @tc.name: DragAndDropTest0052 1639 * @tc.desc: Test OH_ArkUI_DragAction_SetData. 1640 * @tc.type: FUNC 1641 */ 1642 HWTEST_F(DragAndDropTest, DragAndDropTest0052, TestSize.Level1) 1643 { 1644 /** 1645 * @tc.steps: step1.create DragEvent, related function is called. 1646 */ 1647 auto uiContext = new ArkUI_Context({ .id = 1 }); 1648 auto dragAction = OH_ArkUI_CreateDragActionWithContext(uiContext); 1649 EXPECT_NE(dragAction, nullptr); 1650 OH_UdmfData* data = OH_UdmfData_Create(); 1651 ASSERT_NE(data, nullptr); 1652 1653 /** 1654 * @tc.steps: step2.set params null. 1655 */ 1656 int32_t ret = OH_ArkUI_DragAction_SetData(nullptr, data); 1657 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1658 1659 ret = OH_ArkUI_DragAction_SetData(dragAction, nullptr); 1660 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1661 1662 /** 1663 * @tc.steps: step2.set params not null, related function is called. 1664 */ 1665 ret = OH_ArkUI_DragAction_SetData(dragAction, data); 1666 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1667 OH_ArkUI_DragAction_Dispose(dragAction); 1668 OH_UdmfData_Destroy(data); 1669 delete uiContext; 1670 } 1671 1672 /** 1673 * @tc.name: DragAndDropTest0053 1674 * @tc.desc: Test OH_ArkUI_DragEvent_StartDataLoading. 1675 * @tc.type: FUNC 1676 */ 1677 HWTEST_F(DragAndDropTest, DragAndDropTest0053, TestSize.Level1) 1678 { 1679 /** 1680 * @tc.steps: step1.create params. 1681 */ 1682 char key[] = "key_string1"; 1683 OH_UdmfGetDataParams* options = OH_UdmfGetDataParams_Create(); 1684 unsigned int keyLen = 513; 1685 ArkUIDragEvent dragEvent; 1686 dragEvent.key = "key_string"; 1687 dragEvent.isSuitGetData = false; 1688 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1689 ASSERT_NE(drag_Event, nullptr); 1690 1691 /** 1692 * @tc.steps: step2.set params null, related function is called. 1693 */ 1694 int32_t ret = OH_ArkUI_DragEvent_StartDataLoading(nullptr, nullptr, nullptr, 0); 1695 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1696 1697 ret = OH_ArkUI_DragEvent_StartDataLoading(drag_Event, nullptr, nullptr, 0); 1698 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1699 1700 ret = OH_ArkUI_DragEvent_StartDataLoading(drag_Event, options, nullptr, 0); 1701 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1702 1703 ret = OH_ArkUI_DragEvent_StartDataLoading(drag_Event, options, key, 0); 1704 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1705 1706 /** 1707 * @tc.steps: step2.set params not null, related function is called. 1708 */ 1709 ret = OH_ArkUI_DragEvent_StartDataLoading(drag_Event, options, key, keyLen); 1710 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1711 dragEvent.isSuitGetData = true; 1712 drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1713 ASSERT_NE(drag_Event, nullptr); 1714 ret = OH_ArkUI_DragEvent_StartDataLoading(drag_Event, options, key, keyLen); 1715 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1716 OH_UdmfGetDataParams_Destroy(options); 1717 } 1718 1719 /** 1720 * @tc.name: DragAndDropTest0054 1721 * @tc.desc: Test OH_ArkUI_DragEvent_RequestDragEndPending. 1722 * @tc.type: FUNC 1723 */ 1724 HWTEST_F(DragAndDropTest, DragAndDropTest0054, TestSize.Level1) 1725 { 1726 /** 1727 * @tc.steps: step1.create DragEvent, related function is called. 1728 */ 1729 int32_t requestIdentify = 1; 1730 ArkUIDragEvent dragEvent; 1731 dragEvent.key = "key_string"; 1732 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1733 ASSERT_NE(drag_Event, nullptr); 1734 1735 /** 1736 * @tc.steps: step2.set params null. 1737 */ 1738 int32_t ret = OH_ArkUI_DragEvent_RequestDragEndPending(drag_Event, nullptr); 1739 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1740 ret = OH_ArkUI_DragEvent_RequestDragEndPending(nullptr, nullptr); 1741 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1742 1743 /** 1744 * @tc.steps: step2.set params not null, related function is called. 1745 */ 1746 ret = OH_ArkUI_DragEvent_RequestDragEndPending(drag_Event, &requestIdentify); 1747 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1748 } 1749 1750 /** 1751 * @tc.name: DragAndDropTest0055 1752 * @tc.desc: Test OH_ArkUI_NotifyDragResult. 1753 * @tc.type: FUNC 1754 */ 1755 HWTEST_F(DragAndDropTest, DragAndDropTest0055, TestSize.Level1) 1756 { 1757 /** 1758 * @tc.steps: step1.create DragEvent, related function is called. 1759 */ 1760 int32_t requestIdentify = 1; 1761 ArkUI_DragResult result = ARKUI_DRAG_RESULT_SUCCESSFUL; 1762 1763 /** 1764 * @tc.steps: step2.set params null. 1765 */ 1766 int32_t ret = OH_ArkUI_NotifyDragResult(0, result); 1767 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1768 1769 /** 1770 * @tc.steps: step2.set params not null, related function is called. 1771 */ 1772 ret = OH_ArkUI_NotifyDragResult(requestIdentify, result); 1773 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1774 } 1775 1776 /** 1777 * @tc.name: DragAndDropTest0056 1778 * @tc.desc: Test OH_ArkUI_NotifyDragEndPendingDone. 1779 * @tc.type: FUNC 1780 */ 1781 HWTEST_F(DragAndDropTest, DragAndDropTest0056, TestSize.Level1) 1782 { 1783 /** 1784 * @tc.steps: step1.create DragEvent, related function is called. 1785 */ 1786 int32_t requestIdentify = 1; 1787 1788 /** 1789 * @tc.steps: step2.set params null. 1790 */ 1791 int32_t ret = OH_ArkUI_NotifyDragEndPendingDone(0); 1792 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1793 1794 /** 1795 * @tc.steps: step2.set params not null, related function is called. 1796 */ 1797 ret = OH_ArkUI_NotifyDragEndPendingDone(requestIdentify); 1798 EXPECT_EQ(ret, ARKUI_ERROR_CODE_DRAG_DROP_OPERATION_NOT_ALLOWED); 1799 } 1800 1801 /** 1802 * @tc.name: DragAndDropTest0057 1803 * @tc.desc: Test OH_ArkUI_EnableDropDisallowedBadge. 1804 * @tc.type: FUNC 1805 */ 1806 HWTEST_F(DragAndDropTest, DragAndDropTest0057, TestSize.Level1) 1807 { 1808 /** 1809 * @tc.steps: step1.create DragEvent, related function is called. 1810 */ 1811 int32_t requestIdentify = 1; 1812 auto uiContext = new ArkUI_Context({ .id = 1 }); 1813 1814 /** 1815 * @tc.steps: step2.set params null. 1816 */ 1817 int32_t ret = OH_ArkUI_EnableDropDisallowedBadge(nullptr, requestIdentify); 1818 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1819 1820 /** 1821 * @tc.steps: step2.set params not null, related function is called. 1822 */ 1823 ret = OH_ArkUI_EnableDropDisallowedBadge(uiContext, requestIdentify); 1824 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1825 delete uiContext; 1826 } 1827 1828 /** 1829 * @tc.name: DragAndDropTest0058 1830 * @tc.desc: Test OH_ArkUI_DragEvent_SetData. 1831 * @tc.type: FUNC 1832 */ 1833 HWTEST_F(DragAndDropTest, DragAndDropTest0058, TestSize.Level1) 1834 { 1835 /** 1836 * @tc.steps: step1.create and set property. 1837 */ 1838 ArkUIDragEvent dragEvent; 1839 OH_UdmfData* data = OH_UdmfData_Create(); 1840 ASSERT_NE(data, nullptr); 1841 dragEvent.unifiedData = data; 1842 auto* drag_Event = reinterpret_cast<ArkUI_DragEvent*>(&dragEvent); 1843 1844 auto ret1 = OH_ArkUI_DragEvent_SetData(nullptr, data); 1845 auto ret2 = OH_ArkUI_DragEvent_SetData(drag_Event, nullptr); 1846 auto ret3 = OH_ArkUI_DragEvent_SetData(drag_Event, data); 1847 /** 1848 * @tc.expected: Return expected results. 1849 */ 1850 EXPECT_EQ(ret1, ARKUI_ERROR_CODE_PARAM_INVALID); 1851 EXPECT_EQ(ret2, ARKUI_ERROR_CODE_PARAM_INVALID); 1852 EXPECT_EQ(ret3, ARKUI_ERROR_CODE_NO_ERROR); 1853 OH_UdmfData_Destroy(data); 1854 } 1855 } // namespace OHOS::Ace