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 "ui_input_event_test.h" 17 18 using namespace testing; 19 using namespace testing::ext; 20 namespace OHOS::Ace { 21 22 /** 23 * @tc.name: OH_ArkUI_HoverEvent_IsHovered 24 * @tc.desc: test OH_ArkUI_HoverEvent_IsHovered 25 * @tc.type: FUNC 26 */ 27 HWTEST_F(UIInputEventTest, OH_ArkUI_HoverEvent_IsHovered, TestSize.Level1) 28 { 29 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 30 auto result = OH_ArkUI_HoverEvent_IsHovered(nullptr); 31 EXPECT_EQ(result, false); 32 33 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 34 auto hoverEvent = std::make_unique<ArkUIHoverEvent>(); 35 hoverEvent->isHover = true; 36 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 37 EXPECT_EQ(result, false); 38 uiInputEvent->inputEvent = hoverEvent.get(); 39 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 40 EXPECT_EQ(result, true); 41 42 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 43 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 44 EXPECT_EQ(result, false); 45 } 46 47 /** 48 * @tc.name: OH_ArkUI_AxisEvent_SetPropagation 49 * @tc.desc: Test function OH_ArkUI_AxisEvent_SetPropagation 50 * @tc.type: FUNC 51 */ 52 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_SetPropagation, TestSize.Level1) 53 { 54 int32_t ret = OH_ArkUI_AxisEvent_SetPropagation(nullptr, true); 55 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 56 57 ArkUI_UIInputEvent event; 58 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 59 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 60 61 event.eventTypeId = C_AXIS_EVENT_ID; 62 event.inputEvent = nullptr; 63 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 64 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 65 66 ArkUIAxisEvent axisEvent; 67 event.eventTypeId = C_AXIS_EVENT_ID; 68 event.inputEvent = &axisEvent; 69 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 70 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 71 EXPECT_TRUE(axisEvent.propagation); 72 } 73 74 /** 75 * @tc.name: OH_ArkUI_AxisEvent_GetScrollStep 76 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetScrollStep 77 * @tc.type: FUNC 78 */ 79 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetScrollStep, TestSize.Level1) 80 { 81 int32_t step = OH_ArkUI_AxisEvent_GetScrollStep(nullptr); 82 EXPECT_EQ(step, 0); 83 84 OHOS::Ace::AxisEvent aceAxisEvent; 85 aceAxisEvent.scrollStep = 5; 86 ArkUI_UIInputEvent event; 87 event.eventTypeId = AXIS_EVENT_ID; 88 event.inputEvent = &aceAxisEvent; 89 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 90 EXPECT_EQ(step, 5); 91 92 ArkUIAxisEvent axisEvent; 93 axisEvent.scrollStep = 3; 94 event.eventTypeId = C_AXIS_EVENT_ID; 95 event.inputEvent = &axisEvent; 96 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 97 EXPECT_EQ(step, 3); 98 99 event.eventTypeId = C_HOVER_EVENT_ID; 100 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 101 EXPECT_EQ(step, 0); 102 } 103 104 /** 105 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPosition 106 * @tc.desc: Test setting cloned event position 107 * @tc.type: FUNC 108 */ 109 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPosition, TestSize.Level1) 110 { 111 ArkUI_UIInputEvent event; 112 auto ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(nullptr, 0.0f, 0.0f); 113 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 114 115 event.isCloned = false; 116 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 0.0f, 0.0f); 117 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 118 119 event.isCloned = true; 120 event.inputEvent = nullptr; 121 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 0.0f, 0.0f); 122 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 123 124 ArkUITouchEvent touchEvent; 125 touchEvent.actionTouchPoint.nodeX = 0.0f; 126 touchEvent.actionTouchPoint.nodeY = 0.0f; 127 event.inputEvent = &touchEvent; 128 129 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 1.1f, 2.2f); 130 EXPECT_EQ(touchEvent.actionTouchPoint.nodeX, 1.1f); 131 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 132 } 133 134 /** 135 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex 136 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex 137 * @tc.type: FUNC 138 */ 139 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex, TestSize.Level1) 140 { 141 ArkUI_UIInputEvent event; 142 auto ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(nullptr, 0.0f, 0.0f, 1); 143 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 144 145 event.isCloned = false; 146 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 0.0f, 0.0f, 1); 147 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 148 149 event.isCloned = true; 150 event.inputEvent = nullptr; 151 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 0.0f, 0.0f, 1); 152 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 153 154 ArkUITouchEvent touchEvent; 155 touchEvent.touchPointSize = 0; 156 ArkUITouchPoint touchPointes[2]; 157 touchPointes[1].nodeX = 1.0f; 158 touchPointes[1].nodeY = 2.0f; 159 touchEvent.touchPointes = touchPointes; 160 event.inputEvent = &touchEvent; 161 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 1.1f, 2.2f, 1); 162 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 163 164 touchEvent.touchPointSize = 2; 165 event.inputEvent = &touchEvent; 166 167 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 1.1f, 2.2f, 1); 168 EXPECT_EQ(touchPointes[1].nodeX, 1.1f); 169 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 170 } 171 172 /** 173 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventActionType 174 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventActionType 175 * @tc.type: FUNC 176 */ 177 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventActionType, TestSize.Level1) 178 { 179 ArkUI_UIInputEvent event; 180 auto ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(nullptr, 1); 181 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 182 183 event.isCloned = false; 184 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 185 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 186 187 event.isCloned = true; 188 event.inputEvent = nullptr; 189 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 190 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 191 192 ArkUITouchEvent touchEvent; 193 touchEvent.action = 0; 194 event.inputEvent = &touchEvent; 195 196 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 197 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 198 } 199 200 /** 201 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId 202 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId 203 * @tc.type: FUNC 204 */ 205 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId, TestSize.Level1) 206 { 207 ArkUI_UIInputEvent event; 208 auto ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(nullptr, 1); 209 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 210 211 event.isCloned = false; 212 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 213 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 214 215 event.isCloned = true; 216 event.inputEvent = nullptr; 217 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 218 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 219 220 ArkUITouchEvent touchEvent; 221 touchEvent.actionTouchPoint.id = 0; 222 event.inputEvent = &touchEvent; 223 224 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 225 EXPECT_EQ(touchEvent.actionTouchPoint.id, 1); 226 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 227 } 228 229 /** 230 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex 231 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex 232 * @tc.type: FUNC 233 */ 234 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex, TestSize.Level1) 235 { 236 ArkUI_UIInputEvent event; 237 auto ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(nullptr, 1, 1); 238 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 239 240 event.isCloned = false; 241 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 242 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 243 244 event.isCloned = true; 245 event.inputEvent = nullptr; 246 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 247 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 248 249 ArkUITouchEvent touchEvent; 250 touchEvent.touchPointSize = 0; 251 ArkUITouchPoint touchPointes[2]; 252 touchPointes[1].id = 0; 253 touchPointes[1].nodeY = 2.0f; 254 touchEvent.touchPointes = touchPointes; 255 event.inputEvent = &touchEvent; 256 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 257 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 258 259 touchEvent.touchPointSize = 2; 260 event.inputEvent = &touchEvent; 261 262 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 263 EXPECT_EQ(touchPointes[1].id, 1); 264 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 265 } 266 267 /** 268 * @tc.name: OH_ArkUI_UIInputEvent_GetType 269 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetType 270 * @tc.type: FUNC 271 */ 272 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetType, TestSize.Level1) 273 { 274 ArkUI_UIInputEvent event; 275 event.inputType = ARKUI_UIINPUTEVENT_TYPE_MOUSE; 276 auto ret = OH_ArkUI_UIInputEvent_GetType(&event); 277 EXPECT_EQ(ret, ARKUI_UIINPUTEVENT_TYPE_MOUSE); 278 279 ret = OH_ArkUI_UIInputEvent_GetType(nullptr); 280 EXPECT_EQ(ret, 0); 281 } 282 283 /** 284 * @tc.name: OH_ArkUI_UIInputEvent_GetAction 285 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetAction 286 * @tc.type: FUNC 287 */ 288 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction, TestSize.Level1) 289 { 290 ArkUI_UIInputEvent event; 291 auto ret = OH_ArkUI_UIInputEvent_GetAction(nullptr); 292 EXPECT_EQ(ret, -1); 293 294 event.eventTypeId = C_HOVER_EVENT_ID; 295 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 296 EXPECT_EQ(ret, -1); 297 298 event.eventTypeId = C_TOUCH_EVENT_ID; 299 ArkUITouchEvent touchEvent; 300 touchEvent.action = 1; 301 event.inputEvent = &touchEvent; 302 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 303 EXPECT_EQ(ret, 3); 304 event.inputEvent = nullptr; 305 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 306 EXPECT_EQ(ret, -1); 307 308 event.eventTypeId = C_MOUSE_EVENT_ID; 309 ArkUIMouseEvent mouseEvent; 310 mouseEvent.action = 1; 311 event.inputEvent = &mouseEvent; 312 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 313 EXPECT_EQ(ret, 1); 314 event.inputEvent = nullptr; 315 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 316 EXPECT_EQ(ret, -1); 317 } 318 319 /** 320 * @tc.name: OH_ArkUI_UIInputEvent_GetSourceType001 321 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetSourceType 322 * @tc.type: FUNC 323 */ 324 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetSourceType001, TestSize.Level1) 325 { 326 ArkUI_UIInputEvent event; 327 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(nullptr); 328 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 329 EXPECT_EQ(ret, unknown); 330 331 event.eventTypeId = C_CLICK_EVENT_ID; 332 event.inputEvent = nullptr; 333 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 334 EXPECT_EQ(ret, unknown); 335 event.eventTypeId = C_MOUSE_EVENT_ID; 336 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 337 EXPECT_EQ(ret, unknown); 338 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 339 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 340 EXPECT_EQ(ret, unknown); 341 event.eventTypeId = C_HOVER_EVENT_ID; 342 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 343 EXPECT_EQ(ret, unknown); 344 event.eventTypeId = C_KEY_EVENT_ID; 345 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 346 EXPECT_EQ(ret, unknown); 347 } 348 /** 349 * @tc.name: OH_ArkUI_UIInputEvent_GetSourceType002 350 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetSourceType 351 * @tc.type: FUNC 352 */ 353 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetSourceType002, TestSize.Level1) 354 { 355 ArkUI_UIInputEvent event; 356 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 357 358 event.eventTypeId = C_TOUCH_EVENT_ID; 359 event.inputEvent = nullptr; 360 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 361 EXPECT_EQ(ret, unknown); 362 ArkUITouchEvent touchEvent; 363 touchEvent.sourceType = 1; 364 event.inputEvent = &touchEvent; 365 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 366 EXPECT_EQ(ret, 1); 367 368 event.eventTypeId = C_AXIS_EVENT_ID; 369 event.inputEvent = nullptr; 370 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 371 EXPECT_EQ(ret, unknown); 372 ArkUIAxisEvent axisEvent; 373 axisEvent.sourceType = 2; 374 event.inputEvent = &axisEvent; 375 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 376 EXPECT_EQ(ret, 2); 377 378 event.eventTypeId = AXIS_EVENT_ID; 379 event.inputEvent = nullptr; 380 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 381 EXPECT_EQ(ret, unknown); 382 OHOS::Ace::AxisEvent aceAxisEvent; 383 aceAxisEvent.sourceType = SourceType::CROWN; 384 event.inputEvent = &aceAxisEvent; 385 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 386 EXPECT_EQ(ret, static_cast<int32_t>(SourceType::CROWN)); 387 } 388 /** 389 * @tc.name: OH_ArkUI_UIInputEvent_GetToolType001 390 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetToolType 391 * @tc.type: FUNC 392 */ 393 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetToolType001, TestSize.Level1) 394 { 395 ArkUI_UIInputEvent event; 396 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(nullptr); 397 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 398 EXPECT_EQ(ret, unknown); 399 400 event.eventTypeId = C_CLICK_EVENT_ID; 401 event.inputEvent = nullptr; 402 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 403 EXPECT_EQ(ret, unknown); 404 event.eventTypeId = C_MOUSE_EVENT_ID; 405 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 406 EXPECT_EQ(ret, unknown); 407 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 408 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 409 EXPECT_EQ(ret, unknown); 410 event.eventTypeId = C_HOVER_EVENT_ID; 411 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 412 EXPECT_EQ(ret, unknown); 413 event.eventTypeId = C_KEY_EVENT_ID; 414 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 415 EXPECT_EQ(ret, unknown); 416 } 417 418 /** 419 * @tc.name: OH_ArkUI_UIInputEvent_GetToolType002 420 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetToolType 421 * @tc.type: FUNC 422 */ 423 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetToolType002, TestSize.Level1) 424 { 425 ArkUI_UIInputEvent event; 426 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 427 428 event.eventTypeId = C_TOUCH_EVENT_ID; 429 event.inputEvent = nullptr; 430 auto ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 431 EXPECT_EQ(ret, unknown); 432 ArkUITouchEvent touchEvent; 433 touchEvent.actionTouchPoint.toolType = 1; 434 event.inputEvent = &touchEvent; 435 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 436 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(touchEvent.actionTouchPoint.toolType)); 437 438 event.eventTypeId = C_AXIS_EVENT_ID; 439 event.inputEvent = nullptr; 440 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 441 EXPECT_EQ(ret, unknown); 442 ArkUIAxisEvent axisEvent; 443 axisEvent.actionTouchPoint.toolType = 2; 444 event.inputEvent = &axisEvent; 445 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 446 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(axisEvent.actionTouchPoint.toolType)); 447 448 event.eventTypeId = AXIS_EVENT_ID; 449 event.inputEvent = nullptr; 450 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 451 EXPECT_EQ(ret, unknown); 452 OHOS::Ace::AxisEvent aceAxisEvent; 453 aceAxisEvent.sourceTool = SourceTool::JOYSTICK; 454 event.inputEvent = &aceAxisEvent; 455 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 456 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(static_cast<int32_t>(aceAxisEvent.sourceTool))); 457 } 458 459 /** 460 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTime001 461 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTime 462 * @tc.type: FUNC 463 */ 464 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTime001, TestSize.Level1) 465 { 466 ArkUI_UIInputEvent event; 467 auto ret = OH_ArkUI_UIInputEvent_GetEventTime(nullptr); 468 EXPECT_EQ(ret, 0); 469 470 event.eventTypeId = C_CLICK_EVENT_ID; 471 event.inputEvent = nullptr; 472 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 473 EXPECT_EQ(ret, 0); 474 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 475 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 476 EXPECT_EQ(ret, 0); 477 event.eventTypeId = C_HOVER_EVENT_ID; 478 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 479 EXPECT_EQ(ret, 0); 480 481 event.eventTypeId = C_TOUCH_EVENT_ID; 482 event.inputEvent = nullptr; 483 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 484 EXPECT_EQ(ret, 0); 485 ArkUITouchEvent touchEvent; 486 touchEvent.timeStamp = 1; 487 event.inputEvent = &touchEvent; 488 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 489 EXPECT_EQ(ret, 1); 490 491 event.eventTypeId = TOUCH_EVENT_ID; 492 event.inputEvent = nullptr; 493 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 494 EXPECT_EQ(ret, 0); 495 OHOS::Ace::PointerEvent aceTouchEvent; 496 event.inputEvent = &aceTouchEvent; 497 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 498 EXPECT_EQ(ret, aceTouchEvent.time.time_since_epoch().count()); 499 } 500 501 /** 502 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTime002 503 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTime 504 * @tc.type: FUNC 505 */ 506 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTime002, TestSize.Level1) 507 { 508 ArkUI_UIInputEvent event; 509 510 event.eventTypeId = C_MOUSE_EVENT_ID; 511 event.inputEvent = nullptr; 512 auto ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 513 EXPECT_EQ(ret, 0); 514 ArkUIMouseEvent mouseEvent; 515 mouseEvent.timeStamp = 2; 516 event.inputEvent = &mouseEvent; 517 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 518 EXPECT_EQ(ret, 2); 519 520 event.eventTypeId = C_AXIS_EVENT_ID; 521 event.inputEvent = nullptr; 522 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 523 EXPECT_EQ(ret, 0); 524 ArkUIAxisEvent axisEvent; 525 axisEvent.timeStamp = 3; 526 event.inputEvent = &axisEvent; 527 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 528 EXPECT_EQ(ret, 3); 529 530 event.eventTypeId = AXIS_EVENT_ID; 531 event.inputEvent = nullptr; 532 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 533 EXPECT_EQ(ret, 0); 534 OHOS::Ace::PointerEvent aceAxisEvent; 535 event.inputEvent = &aceAxisEvent; 536 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 537 EXPECT_EQ(ret, aceAxisEvent.time.time_since_epoch().count()); 538 539 event.eventTypeId = C_KEY_EVENT_ID; 540 event.inputEvent = nullptr; 541 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 542 EXPECT_EQ(ret, 0); 543 ArkUIKeyEvent keyEvent; 544 keyEvent.timestamp = 4; 545 event.inputEvent = &keyEvent; 546 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 547 EXPECT_EQ(ret, 4); 548 } 549 550 /** 551 * @tc.name: OH_ArkUI_UIInputEvent_GetDeviceId001 552 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetDeviceId 553 * @tc.type: FUNC 554 */ 555 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetDeviceId001, TestSize.Level1) 556 { 557 ArkUI_UIInputEvent event; 558 auto ret = OH_ArkUI_UIInputEvent_GetDeviceId(nullptr); 559 EXPECT_EQ(ret, -1); 560 561 event.eventTypeId = C_CLICK_EVENT_ID; 562 event.inputEvent = nullptr; 563 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 564 EXPECT_EQ(ret, -1); 565 event.eventTypeId = C_KEY_EVENT_ID; 566 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 567 EXPECT_EQ(ret, -1); 568 event.eventTypeId = C_MOUSE_EVENT_ID; 569 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 570 EXPECT_EQ(ret, -1); 571 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 572 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 573 EXPECT_EQ(ret, -1); 574 event.eventTypeId = C_HOVER_EVENT_ID; 575 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 576 EXPECT_EQ(ret, -1); 577 event.eventTypeId = C_TOUCH_EVENT_ID; 578 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 579 EXPECT_EQ(ret, -1); 580 } 581 582 /** 583 * @tc.name: OH_ArkUI_UIInputEvent_GetDeviceId002 584 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetDeviceId 585 * @tc.type: FUNC 586 */ 587 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetDeviceId002, TestSize.Level1) 588 { 589 ArkUI_UIInputEvent event; 590 event.eventTypeId = TOUCH_EVENT_ID; 591 event.inputEvent = nullptr; 592 auto ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 593 EXPECT_EQ(ret, -1); 594 OHOS::Ace::TouchEvent aceTouchEvent; 595 aceTouchEvent.deviceId = 1; 596 event.inputEvent = &aceTouchEvent; 597 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 598 EXPECT_EQ(ret, static_cast<int32_t>(aceTouchEvent.deviceId)); 599 600 event.eventTypeId = C_AXIS_EVENT_ID; 601 event.inputEvent = nullptr; 602 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 603 EXPECT_EQ(ret, -1); 604 ArkUIAxisEvent axisEvent; 605 axisEvent.deviceId = 2; 606 event.inputEvent = &axisEvent; 607 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 608 EXPECT_EQ(ret, static_cast<int32_t>(axisEvent.deviceId)); 609 610 event.eventTypeId = AXIS_EVENT_ID; 611 event.inputEvent = nullptr; 612 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 613 EXPECT_EQ(ret, -1); 614 OHOS::Ace::AxisEvent aceAxisEvent; 615 aceAxisEvent.deviceId = 3; 616 event.inputEvent = &aceAxisEvent; 617 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 618 EXPECT_EQ(ret, static_cast<int32_t>(aceAxisEvent.deviceId)); 619 } 620 621 /** 622 * @tc.name: OH_ArkUI_UIInputEvent_GetPressedKeys 623 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetPressedKeys 624 * @tc.type: FUNC 625 */ 626 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetPressedKeys, TestSize.Level1) 627 { 628 ArkUI_UIInputEvent event; 629 int32_t pressedKeyCodes[3]; 630 int32_t length = 0; 631 auto ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 632 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 633 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, nullptr, &length); 634 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 635 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(nullptr, pressedKeyCodes, &length); 636 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 637 638 ArkUIKeyEvent keyEvent; 639 length = 1; 640 event.inputEvent = nullptr; 641 keyEvent.keyCodesLength = 2; 642 ArkUI_Int32 keyPressedKeyCodes[2] = { 1, 2 }; 643 keyEvent.pressedKeyCodes = keyPressedKeyCodes; 644 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 645 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 646 event.inputEvent = &keyEvent; 647 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 648 EXPECT_EQ(ret, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 649 length = 3; 650 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 651 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 652 } 653 654 /** 655 * @tc.name: OH_ArkUI_PointerEvent_GetPointerCount 656 * @tc.desc: Test OH_ArkUI_PointerEvent_GetPointerCount 657 * @tc.type: FUNC 658 */ 659 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPointerCount, TestSize.Level1) 660 { 661 ArkUI_UIInputEvent event; 662 auto ret = OH_ArkUI_PointerEvent_GetPointerCount(nullptr); 663 EXPECT_EQ(ret, 0); 664 665 event.eventTypeId = C_KEY_EVENT_ID; 666 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 667 EXPECT_EQ(ret, 0); 668 669 event.eventTypeId = C_TOUCH_EVENT_ID; 670 event.inputEvent = nullptr; 671 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 672 EXPECT_EQ(ret, 0); 673 ArkUITouchEvent touchEvent; 674 touchEvent.touchPointSize = 1; 675 event.inputEvent = &touchEvent; 676 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 677 EXPECT_EQ(ret, 1); 678 679 event.eventTypeId = C_MOUSE_EVENT_ID; 680 event.inputEvent = nullptr; 681 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 682 EXPECT_EQ(ret, 0); 683 ArkUIMouseEvent mouseEvent; 684 event.inputEvent = &mouseEvent; 685 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 686 EXPECT_EQ(ret, 1); 687 688 event.eventTypeId = C_MOUSE_EVENT_ID; 689 event.inputEvent = nullptr; 690 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 691 EXPECT_EQ(ret, 0); 692 ArkUIAxisEvent axisEvent; 693 event.inputEvent = &axisEvent; 694 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 695 EXPECT_EQ(ret, 1); 696 697 event.eventTypeId = C_CLICK_EVENT_ID; 698 event.inputEvent = nullptr; 699 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 700 EXPECT_EQ(ret, 0); 701 ArkUIClickEvent clickEvent; 702 clickEvent.clickPointSize = 2; 703 event.inputEvent = &clickEvent; 704 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 705 EXPECT_EQ(ret, 2); 706 } 707 708 /** 709 * @tc.name: OH_ArkUI_PointerEvent_GetPointerId 710 * @tc.desc: Test OH_ArkUI_PointerEvent_GetPointerId 711 * @tc.type: FUNC 712 */ 713 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPointerId, TestSize.Level1) 714 { 715 ArkUI_UIInputEvent event; 716 auto ret = OH_ArkUI_PointerEvent_GetPointerId(nullptr, 0); 717 EXPECT_EQ(ret, 0); 718 719 event.eventTypeId = C_KEY_EVENT_ID; 720 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 721 EXPECT_EQ(ret, 0); 722 723 event.eventTypeId = C_TOUCH_EVENT_ID; 724 event.inputEvent = nullptr; 725 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 726 EXPECT_EQ(ret, 0); 727 ArkUITouchEvent touchEvent; 728 ArkUITouchPoint touchPointes[3]; 729 touchPointes[2].id = 10; 730 touchEvent.touchPointSize = 3; 731 touchEvent.touchPointes = touchPointes; 732 event.inputEvent = &touchEvent; 733 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 2); 734 EXPECT_EQ(ret, 10); 735 736 event.eventTypeId = C_MOUSE_EVENT_ID; 737 event.inputEvent = nullptr; 738 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 739 EXPECT_EQ(ret, 0); 740 ArkUIMouseEvent mouseEvent; 741 mouseEvent.actionTouchPoint.id = 20; 742 event.inputEvent = &mouseEvent; 743 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 744 EXPECT_EQ(ret, 0); 745 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 746 EXPECT_EQ(ret, 20); 747 748 event.eventTypeId = C_AXIS_EVENT_ID; 749 event.inputEvent = nullptr; 750 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 751 EXPECT_EQ(ret, 0); 752 ArkUIAxisEvent axisEvent; 753 axisEvent.actionTouchPoint.id = 30; 754 event.inputEvent = &axisEvent; 755 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 756 EXPECT_EQ(ret, 0); 757 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 758 EXPECT_EQ(ret, 30); 759 } 760 761 /** 762 * @tc.name: OH_ArkUI_PointerEvent_GetX001 763 * @tc.desc: Test OH_ArkUI_PointerEvent_GetX 764 * @tc.type: FUNC 765 */ 766 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetX001, TestSize.Level1) 767 { 768 ArkUI_UIInputEvent event; 769 auto ret = OH_ArkUI_PointerEvent_GetX(nullptr); 770 EXPECT_EQ(ret, 0.0f); 771 772 event.eventTypeId = C_KEY_EVENT_ID; 773 ret = OH_ArkUI_PointerEvent_GetX(&event); 774 EXPECT_EQ(ret, 0.0f); 775 776 event.eventTypeId = C_TOUCH_EVENT_ID; 777 ArkUITouchEvent touchEvent; 778 touchEvent.actionTouchPoint.nodeX = 1.1f; 779 event.inputEvent = nullptr; 780 ret = OH_ArkUI_PointerEvent_GetX(&event); 781 EXPECT_EQ(ret, 0.0f); 782 event.inputEvent = &touchEvent; 783 ret = OH_ArkUI_PointerEvent_GetX(&event); 784 EXPECT_EQ(ret, 1.1f); 785 786 event.eventTypeId = C_MOUSE_EVENT_ID; 787 ArkUIMouseEvent mouseEvent; 788 mouseEvent.actionTouchPoint.nodeX = 2.2f; 789 event.inputEvent = nullptr; 790 ret = OH_ArkUI_PointerEvent_GetX(&event); 791 EXPECT_EQ(ret, 0.0f); 792 event.inputEvent = &mouseEvent; 793 ret = OH_ArkUI_PointerEvent_GetX(&event); 794 EXPECT_EQ(ret, 2.2f); 795 } 796 797 /** 798 * @tc.name: OH_ArkUI_PointerEvent_GetX002 799 * @tc.desc: Test OH_ArkUI_PointerEvent_GetX 800 * @tc.type: FUNC 801 */ 802 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetX002, TestSize.Level1) 803 { 804 ArkUI_UIInputEvent event; 805 event.eventTypeId = C_AXIS_EVENT_ID; 806 ArkUIAxisEvent axisEvent; 807 axisEvent.actionTouchPoint.nodeX = 3.3f; 808 event.inputEvent = nullptr; 809 auto ret = OH_ArkUI_PointerEvent_GetX(&event); 810 EXPECT_EQ(ret, 0.0f); 811 event.inputEvent = &axisEvent; 812 ret = OH_ArkUI_PointerEvent_GetX(&event); 813 EXPECT_EQ(ret, 3.3f); 814 815 event.eventTypeId = TOUCH_EVENT_ID; 816 OHOS::Ace::TouchEvent aceTouchEvent; 817 aceTouchEvent.localX = 4.4f; 818 event.inputEvent = nullptr; 819 ret = OH_ArkUI_PointerEvent_GetX(&event); 820 EXPECT_EQ(ret, 0.0f); 821 event.inputEvent = &aceTouchEvent; 822 ret = OH_ArkUI_PointerEvent_GetX(&event); 823 EXPECT_EQ(ret, 4.4f); 824 825 event.eventTypeId = AXIS_EVENT_ID; 826 OHOS::Ace::AxisEvent aceAxisEvent; 827 aceAxisEvent.localX = 5.5f; 828 event.inputEvent = nullptr; 829 ret = OH_ArkUI_PointerEvent_GetX(&event); 830 EXPECT_EQ(ret, 0.0f); 831 event.inputEvent = &aceAxisEvent; 832 ret = OH_ArkUI_PointerEvent_GetX(&event); 833 EXPECT_EQ(ret, 5.5f); 834 } 835 836 /** 837 * @tc.name: OH_ArkUI_PointerEvent_GetY001 838 * @tc.desc: Test OH_ArkUI_PointerEvent_GetY 839 * @tc.type: FUNC 840 */ 841 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetY001, TestSize.Level1) 842 { 843 ArkUI_UIInputEvent event; 844 auto ret = OH_ArkUI_PointerEvent_GetY(nullptr); 845 EXPECT_EQ(ret, 0.0f); 846 847 event.eventTypeId = C_KEY_EVENT_ID; 848 ret = OH_ArkUI_PointerEvent_GetY(&event); 849 EXPECT_EQ(ret, 0.0f); 850 851 event.eventTypeId = C_TOUCH_EVENT_ID; 852 ArkUITouchEvent touchEvent; 853 touchEvent.actionTouchPoint.nodeY = 10.1f; 854 ret = OH_ArkUI_PointerEvent_GetY(&event); 855 EXPECT_EQ(ret, 0.0f); 856 event.inputEvent = &touchEvent; 857 ret = OH_ArkUI_PointerEvent_GetY(&event); 858 EXPECT_EQ(ret, 10.1f); 859 860 event.eventTypeId = C_MOUSE_EVENT_ID; 861 ArkUIMouseEvent mouseEvent; 862 mouseEvent.actionTouchPoint.nodeY = 20.2f; 863 event.inputEvent = nullptr; 864 ret = OH_ArkUI_PointerEvent_GetY(&event); 865 EXPECT_EQ(ret, 0.0f); 866 event.inputEvent = &mouseEvent; 867 ret = OH_ArkUI_PointerEvent_GetY(&event); 868 EXPECT_EQ(ret, 20.2f); 869 } 870 871 /** 872 * @tc.name: OH_ArkUI_PointerEvent_GetY002 873 * @tc.desc: Test OH_ArkUI_PointerEvent_GetY 874 * @tc.type: FUNC 875 */ 876 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetY002, TestSize.Level1) 877 { 878 ArkUI_UIInputEvent event; 879 880 event.eventTypeId = C_AXIS_EVENT_ID; 881 ArkUIAxisEvent axisEvent; 882 axisEvent.actionTouchPoint.nodeY = 30.3f; 883 event.inputEvent = nullptr; 884 auto ret = OH_ArkUI_PointerEvent_GetY(&event); 885 EXPECT_EQ(ret, 0.0f); 886 event.inputEvent = &axisEvent; 887 ret = OH_ArkUI_PointerEvent_GetY(&event); 888 EXPECT_EQ(ret, 30.3f); 889 890 event.eventTypeId = TOUCH_EVENT_ID; 891 OHOS::Ace::TouchEvent aceTouchEvent; 892 aceTouchEvent.localY = 40.4f; 893 event.inputEvent = nullptr; 894 ret = OH_ArkUI_PointerEvent_GetY(&event); 895 EXPECT_EQ(ret, 0.0f); 896 event.inputEvent = &aceTouchEvent; 897 ret = OH_ArkUI_PointerEvent_GetY(&event); 898 EXPECT_EQ(ret, 40.4f); 899 900 // AXIS_EVENT 类型测试（Ace AxisEvent） 901 event.eventTypeId = AXIS_EVENT_ID; 902 OHOS::Ace::AxisEvent aceAxisEvent; 903 aceAxisEvent.localY = 50.5f; 904 event.inputEvent = nullptr; 905 ret = OH_ArkUI_PointerEvent_GetY(&event); 906 EXPECT_EQ(ret, 0.0f); 907 event.inputEvent = &aceAxisEvent; 908 ret = OH_ArkUI_PointerEvent_GetY(&event); 909 EXPECT_EQ(ret, 50.5f); 910 } 911 912 /** 913 * @tc.name: OH_ArkUI_PointerEvent_GetWindowX001 914 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowX 915 * @tc.type: FUNC 916 */ 917 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowX001, TestSize.Level1) 918 { 919 ArkUI_UIInputEvent event; 920 auto ret = OH_ArkUI_PointerEvent_GetWindowX(nullptr); 921 EXPECT_EQ(ret, 0.0f); 922 923 event.eventTypeId = C_KEY_EVENT_ID; 924 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 925 EXPECT_EQ(ret, 0.0f); 926 927 event.eventTypeId = C_TOUCH_EVENT_ID; 928 ArkUITouchEvent touchEvent; 929 touchEvent.actionTouchPoint.windowX = 100.1f; 930 event.inputEvent = nullptr; 931 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 932 EXPECT_EQ(ret, 0.0f); 933 event.inputEvent = &touchEvent; 934 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 935 EXPECT_EQ(ret, 100.1f); 936 937 event.eventTypeId = C_MOUSE_EVENT_ID; 938 ArkUIMouseEvent mouseEvent; 939 mouseEvent.actionTouchPoint.windowX = 200.2f; 940 event.inputEvent = nullptr; 941 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 942 EXPECT_EQ(ret, 0.0f); 943 event.inputEvent = &mouseEvent; 944 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 945 EXPECT_EQ(ret, 200.2f); 946 } 947 948 /** 949 * @tc.name: OH_ArkUI_PointerEvent_GetWindowX002 950 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowX 951 * @tc.type: FUNC 952 */ 953 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowX002, TestSize.Level1) 954 { 955 ArkUI_UIInputEvent event; 956 957 event.eventTypeId = C_AXIS_EVENT_ID; 958 ArkUIAxisEvent axisEvent; 959 axisEvent.actionTouchPoint.windowX = 300.3f; 960 event.inputEvent = nullptr; 961 auto ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 962 EXPECT_EQ(ret, 0.0f); 963 event.inputEvent = &axisEvent; 964 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 965 EXPECT_EQ(ret, 300.3f); 966 967 event.eventTypeId = TOUCH_EVENT_ID; 968 OHOS::Ace::TouchEvent aceTouchEvent; 969 aceTouchEvent.x = 400.4f; 970 event.inputEvent = nullptr; 971 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 972 EXPECT_EQ(ret, 0.0f); 973 event.inputEvent = &aceTouchEvent; 974 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 975 EXPECT_EQ(ret, 400.4f); 976 977 event.eventTypeId = AXIS_EVENT_ID; 978 OHOS::Ace::AxisEvent aceAxisEvent; 979 aceAxisEvent.x = 500.5f; 980 event.inputEvent = nullptr; 981 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 982 EXPECT_EQ(ret, 0.0f); 983 event.inputEvent = &aceAxisEvent; 984 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 985 EXPECT_EQ(ret, 500.5f); 986 } 987 988 /** 989 * @tc.name: OH_ArkUI_PointerEvent_GetWindowY001 990 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowY 991 * @tc.type: FUNC 992 */ 993 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowY001, TestSize.Level1) 994 { 995 ArkUI_UIInputEvent event; 996 auto ret = OH_ArkUI_PointerEvent_GetWindowY(nullptr); 997 EXPECT_EQ(ret, 0.0f); 998 999 event.eventTypeId = C_KEY_EVENT_ID; 1000 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1001 EXPECT_EQ(ret, 0.0f); 1002 1003 event.eventTypeId = C_TOUCH_EVENT_ID; 1004 ArkUITouchEvent touchEvent; 1005 touchEvent.actionTouchPoint.windowY = 100.1f; 1006 event.inputEvent = nullptr; 1007 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1008 EXPECT_EQ(ret, 0.0f); 1009 event.inputEvent = &touchEvent; 1010 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1011 EXPECT_EQ(ret, 100.1f); 1012 1013 event.eventTypeId = C_MOUSE_EVENT_ID; 1014 ArkUIMouseEvent mouseEvent; 1015 mouseEvent.actionTouchPoint.windowY = 200.2f; 1016 event.inputEvent = nullptr; 1017 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1018 EXPECT_EQ(ret, 0.0f); 1019 event.inputEvent = &mouseEvent; 1020 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1021 EXPECT_EQ(ret, 200.2f); 1022 } 1023 1024 /** 1025 * @tc.name: OH_ArkUI_PointerEvent_GetWindowY002 1026 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowY 1027 * @tc.type: FUNC 1028 */ 1029 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowY002, TestSize.Level1) 1030 { 1031 ArkUI_UIInputEvent event; 1032 event.eventTypeId = C_AXIS_EVENT_ID; 1033 ArkUIAxisEvent axisEvent; 1034 axisEvent.actionTouchPoint.windowY = 300.3f; 1035 event.inputEvent = nullptr; 1036 auto ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1037 EXPECT_EQ(ret, 0.0f); 1038 event.inputEvent = &axisEvent; 1039 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1040 EXPECT_EQ(ret, 300.3f); 1041 1042 event.eventTypeId = TOUCH_EVENT_ID; 1043 OHOS::Ace::TouchEvent aceTouchEvent; 1044 aceTouchEvent.y = 400.4f; 1045 event.inputEvent = nullptr; 1046 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1047 EXPECT_EQ(ret, 0.0f); 1048 event.inputEvent = &aceTouchEvent; 1049 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1050 EXPECT_EQ(ret, 400.4f); 1051 1052 event.eventTypeId = AXIS_EVENT_ID; 1053 OHOS::Ace::AxisEvent aceAxisEvent; 1054 aceAxisEvent.y = 500.5f; 1055 event.inputEvent = nullptr; 1056 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1057 EXPECT_EQ(ret, 0.0f); 1058 event.inputEvent = &aceAxisEvent; 1059 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1060 EXPECT_EQ(ret, 500.5f); 1061 } 1062 1063 /** 1064 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX001 1065 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayX 1066 * @tc.type: FUNC 1067 */ 1068 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX001, TestSize.Level1) 1069 { 1070 ArkUI_UIInputEvent event; 1071 auto ret = OH_ArkUI_PointerEvent_GetDisplayX(nullptr); 1072 EXPECT_EQ(ret, 0.0f); 1073 1074 event.eventTypeId = C_KEY_EVENT_ID; 1075 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1076 EXPECT_EQ(ret, 0.0f); 1077 1078 event.eventTypeId = C_TOUCH_EVENT_ID; 1079 ArkUITouchEvent touchEvent; 1080 touchEvent.actionTouchPoint.screenX = 100.1f; 1081 event.inputEvent = nullptr; 1082 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1083 EXPECT_EQ(ret, 0.0f); 1084 event.inputEvent = &touchEvent; 1085 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1086 EXPECT_EQ(ret, 100.1f); 1087 1088 event.eventTypeId = C_MOUSE_EVENT_ID; 1089 ArkUIMouseEvent mouseEvent; 1090 mouseEvent.actionTouchPoint.screenX = 200.2f; 1091 event.inputEvent = nullptr; 1092 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1093 EXPECT_EQ(ret, 0.0f); 1094 event.inputEvent = &mouseEvent; 1095 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1096 EXPECT_EQ(ret, 200.2f); 1097 } 1098 1099 /** 1100 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX002 1101 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayX 1102 * @tc.type: FUNC 1103 */ 1104 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX002, TestSize.Level1) 1105 { 1106 ArkUI_UIInputEvent event; 1107 event.eventTypeId = C_AXIS_EVENT_ID; 1108 ArkUIAxisEvent axisEvent; 1109 axisEvent.actionTouchPoint.screenX = 300.3f; 1110 event.inputEvent = nullptr; 1111 auto ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1112 EXPECT_EQ(ret, 0.0f); 1113 event.inputEvent = &axisEvent; 1114 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1115 EXPECT_EQ(ret, 300.3f); 1116 1117 event.eventTypeId = TOUCH_EVENT_ID; 1118 OHOS::Ace::TouchEvent aceTouchEvent; 1119 aceTouchEvent.screenX = 400.4f; 1120 event.inputEvent = nullptr; 1121 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1122 EXPECT_EQ(ret, 0.0f); 1123 event.inputEvent = &aceTouchEvent; 1124 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1125 EXPECT_EQ(ret, 400.4f); 1126 1127 event.eventTypeId = AXIS_EVENT_ID; 1128 OHOS::Ace::AxisEvent aceAxisEvent; 1129 aceAxisEvent.screenX = 500.5f; 1130 event.inputEvent = nullptr; 1131 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1132 EXPECT_EQ(ret, 0.0f); 1133 event.inputEvent = &aceAxisEvent; 1134 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1135 EXPECT_EQ(ret, 500.5f); 1136 } 1137 1138 /** 1139 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayY001 1140 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayY 1141 * @tc.type: FUNC 1142 */ 1143 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayY001, TestSize.Level1) 1144 { 1145 ArkUI_UIInputEvent event; 1146 auto ret = OH_ArkUI_PointerEvent_GetDisplayY(nullptr); 1147 EXPECT_EQ(ret, 0.0f); 1148 1149 event.eventTypeId = C_KEY_EVENT_ID; 1150 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1151 EXPECT_EQ(ret, 0.0f); 1152 1153 event.eventTypeId = C_TOUCH_EVENT_ID; 1154 ArkUITouchEvent touchEvent; 1155 touchEvent.actionTouchPoint.screenY = 100.1f; 1156 event.inputEvent = nullptr; 1157 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1158 EXPECT_EQ(ret, 0.0f); 1159 event.inputEvent = &touchEvent; 1160 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1161 EXPECT_EQ(ret, 100.1f); 1162 1163 event.eventTypeId = C_MOUSE_EVENT_ID; 1164 ArkUIMouseEvent mouseEvent; 1165 mouseEvent.actionTouchPoint.screenY = 200.2f; 1166 event.inputEvent = nullptr; 1167 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1168 EXPECT_EQ(ret, 0.0f); 1169 event.inputEvent = &mouseEvent; 1170 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1171 EXPECT_EQ(ret, 200.2f); 1172 } 1173 1174 /** 1175 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayY002 1176 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayY 1177 * @tc.type: FUNC 1178 */ 1179 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayY002, TestSize.Level1) 1180 { 1181 ArkUI_UIInputEvent event; 1182 event.eventTypeId = C_AXIS_EVENT_ID; 1183 ArkUIAxisEvent axisEvent; 1184 axisEvent.actionTouchPoint.screenY = 300.3f; 1185 event.inputEvent = nullptr; 1186 auto ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1187 EXPECT_EQ(ret, 0.0f); 1188 event.inputEvent = &axisEvent; 1189 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1190 EXPECT_EQ(ret, 300.3f); 1191 1192 event.eventTypeId = TOUCH_EVENT_ID; 1193 OHOS::Ace::TouchEvent aceTouchEvent; 1194 aceTouchEvent.screenY = 400.4f; 1195 event.inputEvent = nullptr; 1196 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1197 EXPECT_EQ(ret, 0.0f); 1198 event.inputEvent = &aceTouchEvent; 1199 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1200 EXPECT_EQ(ret, 400.4f); 1201 1202 event.eventTypeId = AXIS_EVENT_ID; 1203 OHOS::Ace::AxisEvent aceAxisEvent; 1204 aceAxisEvent.screenY = 500.5f; 1205 event.inputEvent = nullptr; 1206 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1207 EXPECT_EQ(ret, 0.0f); 1208 event.inputEvent = &aceAxisEvent; 1209 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1210 EXPECT_EQ(ret, 500.5f); 1211 } 1212 /** 1213 * @tc.name: OH_ArkUI_PointerEvent_GetXByIndex 1214 * @tc.desc: Test OH_ArkUI_PointerEvent_GetXByIndex 1215 * @tc.type: FUNC 1216 */ 1217 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetXByIndex, TestSize.Level1) 1218 { 1219 ArkUI_UIInputEvent event; 1220 auto ret = OH_ArkUI_PointerEvent_GetXByIndex(nullptr, 0); 1221 EXPECT_EQ(ret, 0); 1222 1223 event.eventTypeId = C_KEY_EVENT_ID; 1224 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1225 EXPECT_EQ(ret, 0); 1226 1227 event.eventTypeId = C_TOUCH_EVENT_ID; 1228 event.inputEvent = nullptr; 1229 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1230 EXPECT_EQ(ret, 0); 1231 ArkUITouchEvent touchEvent; 1232 ArkUITouchPoint touchPointes[3]; 1233 touchPointes[2].nodeX = 10; 1234 touchEvent.touchPointSize = 3; 1235 touchEvent.touchPointes = touchPointes; 1236 event.inputEvent = &touchEvent; 1237 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 2); 1238 EXPECT_EQ(ret, 10); 1239 1240 event.eventTypeId = C_MOUSE_EVENT_ID; 1241 event.inputEvent = nullptr; 1242 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1243 EXPECT_EQ(ret, 0); 1244 ArkUIMouseEvent mouseEvent; 1245 mouseEvent.actionTouchPoint.nodeX = 20; 1246 event.inputEvent = &mouseEvent; 1247 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1248 EXPECT_EQ(ret, 0); 1249 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1250 EXPECT_EQ(ret, 20); 1251 1252 event.eventTypeId = C_AXIS_EVENT_ID; 1253 event.inputEvent = nullptr; 1254 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1255 EXPECT_EQ(ret, 0); 1256 ArkUIAxisEvent axisEvent; 1257 axisEvent.actionTouchPoint.nodeX = 30; 1258 event.inputEvent = &axisEvent; 1259 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1260 EXPECT_EQ(ret, 0); 1261 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1262 EXPECT_EQ(ret, 30); 1263 } 1264 1265 /** 1266 * @tc.name: OH_ArkUI_PointerEvent_GetYByIndex 1267 * @tc.desc: Test OH_ArkUI_PointerEvent_GetYByIndex 1268 * @tc.type: FUNC 1269 */ 1270 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetYByIndex, TestSize.Level1) 1271 { 1272 ArkUI_UIInputEvent event; 1273 auto ret = OH_ArkUI_PointerEvent_GetYByIndex(nullptr, 0); 1274 EXPECT_EQ(ret, 0); 1275 1276 event.eventTypeId = C_KEY_EVENT_ID; 1277 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1278 EXPECT_EQ(ret, 0); 1279 1280 event.eventTypeId = C_TOUCH_EVENT_ID; 1281 event.inputEvent = nullptr; 1282 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1283 EXPECT_EQ(ret, 0); 1284 ArkUITouchEvent touchEvent; 1285 ArkUITouchPoint touchPointes[3]; 1286 touchPointes[2].nodeY = 10; 1287 touchEvent.touchPointSize = 3; 1288 touchEvent.touchPointes = touchPointes; 1289 event.inputEvent = &touchEvent; 1290 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 2); 1291 EXPECT_EQ(ret, 10); 1292 1293 event.eventTypeId = C_MOUSE_EVENT_ID; 1294 event.inputEvent = nullptr; 1295 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1296 EXPECT_EQ(ret, 0); 1297 ArkUIMouseEvent mouseEvent; 1298 mouseEvent.actionTouchPoint.nodeY = 20; 1299 event.inputEvent = &mouseEvent; 1300 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1301 EXPECT_EQ(ret, 0); 1302 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1303 EXPECT_EQ(ret, 20); 1304 1305 event.eventTypeId = C_AXIS_EVENT_ID; 1306 event.inputEvent = nullptr; 1307 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1308 EXPECT_EQ(ret, 0); 1309 ArkUIAxisEvent axisEvent; 1310 axisEvent.actionTouchPoint.nodeY = 30; 1311 event.inputEvent = &axisEvent; 1312 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1313 EXPECT_EQ(ret, 0); 1314 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1315 EXPECT_EQ(ret, 30); 1316 } 1317 1318 /** 1319 * @tc.name: OH_ArkUI_PointerEvent_GetWindowXByIndex 1320 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowXByIndex 1321 * @tc.type: FUNC 1322 */ 1323 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowXByIndex, TestSize.Level1) 1324 { 1325 ArkUI_UIInputEvent event; 1326 auto ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(nullptr, 0); 1327 EXPECT_EQ(ret, 0); 1328 1329 event.eventTypeId = C_KEY_EVENT_ID; 1330 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1331 EXPECT_EQ(ret, 0); 1332 1333 event.eventTypeId = C_TOUCH_EVENT_ID; 1334 event.inputEvent = nullptr; 1335 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1336 EXPECT_EQ(ret, 0); 1337 ArkUITouchEvent touchEvent; 1338 ArkUITouchPoint touchPointes[3]; 1339 touchPointes[2].windowX = 10; 1340 touchEvent.touchPointSize = 3; 1341 touchEvent.touchPointes = touchPointes; 1342 event.inputEvent = &touchEvent; 1343 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 2); 1344 EXPECT_EQ(ret, 10); 1345 1346 event.eventTypeId = C_MOUSE_EVENT_ID; 1347 event.inputEvent = nullptr; 1348 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1349 EXPECT_EQ(ret, 0); 1350 ArkUIMouseEvent mouseEvent; 1351 mouseEvent.actionTouchPoint.windowX = 20; 1352 event.inputEvent = &mouseEvent; 1353 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1354 EXPECT_EQ(ret, 0); 1355 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1356 EXPECT_EQ(ret, 20); 1357 1358 event.eventTypeId = C_AXIS_EVENT_ID; 1359 event.inputEvent = nullptr; 1360 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1361 EXPECT_EQ(ret, 0); 1362 ArkUIAxisEvent axisEvent; 1363 axisEvent.actionTouchPoint.windowX = 30; 1364 event.inputEvent = &axisEvent; 1365 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1366 EXPECT_EQ(ret, 0); 1367 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1368 EXPECT_EQ(ret, 30); 1369 } 1370 1371 /** 1372 * @tc.name: OH_ArkUI_PointerEvent_GetWindowYByIndex 1373 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowYByIndex 1374 * @tc.type: FUNC 1375 */ 1376 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowYByIndex, TestSize.Level1) 1377 { 1378 ArkUI_UIInputEvent event; 1379 auto ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(nullptr, 0); 1380 EXPECT_EQ(ret, 0); 1381 1382 event.eventTypeId = C_KEY_EVENT_ID; 1383 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1384 EXPECT_EQ(ret, 0); 1385 1386 event.eventTypeId = C_TOUCH_EVENT_ID; 1387 event.inputEvent = nullptr; 1388 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1389 EXPECT_EQ(ret, 0); 1390 ArkUITouchEvent touchEvent; 1391 ArkUITouchPoint touchPointes[3]; 1392 touchPointes[2].windowY = 10; 1393 touchEvent.touchPointSize = 3; 1394 touchEvent.touchPointes = touchPointes; 1395 event.inputEvent = &touchEvent; 1396 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 2); 1397 EXPECT_EQ(ret, 10); 1398 1399 event.eventTypeId = C_MOUSE_EVENT_ID; 1400 event.inputEvent = nullptr; 1401 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1402 EXPECT_EQ(ret, 0); 1403 ArkUIMouseEvent mouseEvent; 1404 mouseEvent.actionTouchPoint.windowY = 20; 1405 event.inputEvent = &mouseEvent; 1406 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1407 EXPECT_EQ(ret, 0); 1408 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1409 EXPECT_EQ(ret, 20); 1410 1411 event.eventTypeId = C_AXIS_EVENT_ID; 1412 event.inputEvent = nullptr; 1413 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1414 EXPECT_EQ(ret, 0); 1415 ArkUIAxisEvent axisEvent; 1416 axisEvent.actionTouchPoint.windowY = 30; 1417 event.inputEvent = &axisEvent; 1418 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1419 EXPECT_EQ(ret, 0); 1420 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1421 EXPECT_EQ(ret, 30); 1422 } 1423 1424 /** 1425 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayXByIndex 1426 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayXByIndex 1427 * @tc.type: FUNC 1428 */ 1429 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayXByIndex, TestSize.Level1) 1430 { 1431 ArkUI_UIInputEvent event; 1432 auto ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(nullptr, 0); 1433 EXPECT_EQ(ret, 0); 1434 1435 event.eventTypeId = C_KEY_EVENT_ID; 1436 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1437 EXPECT_EQ(ret, 0); 1438 1439 event.eventTypeId = C_TOUCH_EVENT_ID; 1440 event.inputEvent = nullptr; 1441 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1442 EXPECT_EQ(ret, 0); 1443 ArkUITouchEvent touchEvent; 1444 ArkUITouchPoint touchPointes[3]; 1445 touchPointes[2].screenX = 10; 1446 touchEvent.touchPointSize = 3; 1447 touchEvent.touchPointes = touchPointes; 1448 event.inputEvent = &touchEvent; 1449 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 2); 1450 EXPECT_EQ(ret, 10); 1451 1452 event.eventTypeId = C_MOUSE_EVENT_ID; 1453 event.inputEvent = nullptr; 1454 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1455 EXPECT_EQ(ret, 0); 1456 ArkUIMouseEvent mouseEvent; 1457 mouseEvent.actionTouchPoint.screenX = 20; 1458 event.inputEvent = &mouseEvent; 1459 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1460 EXPECT_EQ(ret, 0); 1461 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1462 EXPECT_EQ(ret, 20); 1463 1464 event.eventTypeId = C_AXIS_EVENT_ID; 1465 event.inputEvent = nullptr; 1466 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1467 EXPECT_EQ(ret, 0); 1468 ArkUIAxisEvent axisEvent; 1469 axisEvent.actionTouchPoint.screenX = 30; 1470 event.inputEvent = &axisEvent; 1471 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1472 EXPECT_EQ(ret, 0); 1473 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1474 EXPECT_EQ(ret, 30); 1475 } 1476 1477 /** 1478 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayYByIndex 1479 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayYByIndex 1480 * @tc.type: FUNC 1481 */ 1482 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayYByIndex, TestSize.Level1) 1483 { 1484 ArkUI_UIInputEvent event; 1485 auto ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(nullptr, 0); 1486 EXPECT_EQ(ret, 0); 1487 1488 event.eventTypeId = C_KEY_EVENT_ID; 1489 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1490 EXPECT_EQ(ret, 0); 1491 1492 event.eventTypeId = C_TOUCH_EVENT_ID; 1493 event.inputEvent = nullptr; 1494 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1495 EXPECT_EQ(ret, 0); 1496 ArkUITouchEvent touchEvent; 1497 ArkUITouchPoint touchPointes[3]; 1498 touchPointes[2].screenY = 10; 1499 touchEvent.touchPointSize = 3; 1500 touchEvent.touchPointes = touchPointes; 1501 event.inputEvent = &touchEvent; 1502 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 2); 1503 EXPECT_EQ(ret, 10); 1504 1505 event.eventTypeId = C_MOUSE_EVENT_ID; 1506 event.inputEvent = nullptr; 1507 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1508 EXPECT_EQ(ret, 0); 1509 ArkUIMouseEvent mouseEvent; 1510 mouseEvent.actionTouchPoint.screenY = 20; 1511 event.inputEvent = &mouseEvent; 1512 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1513 EXPECT_EQ(ret, 0); 1514 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1515 EXPECT_EQ(ret, 20); 1516 1517 event.eventTypeId = C_AXIS_EVENT_ID; 1518 event.inputEvent = nullptr; 1519 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1520 EXPECT_EQ(ret, 0); 1521 ArkUIAxisEvent axisEvent; 1522 axisEvent.actionTouchPoint.screenY = 30; 1523 event.inputEvent = &axisEvent; 1524 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1525 EXPECT_EQ(ret, 0); 1526 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1527 EXPECT_EQ(ret, 30); 1528 } 1529 1530 /** 1531 * @tc.name: OH_ArkUI_PointerEvent_GetPressure 1532 * @tc.desc: Test OH_ArkUI_PointerEvent_GetPressure 1533 * @tc.type: FUNC 1534 */ 1535 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressure, TestSize.Level1) 1536 { 1537 ArkUI_UIInputEvent event; 1538 auto ret = OH_ArkUI_PointerEvent_GetPressure(nullptr, 0); 1539 EXPECT_EQ(ret, 0.0f); 1540 1541 event.eventTypeId = C_KEY_EVENT_ID; 1542 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1543 EXPECT_EQ(ret, 0.0f); 1544 1545 event.eventTypeId = C_TOUCH_EVENT_ID; 1546 event.inputEvent = nullptr; 1547 ArkUITouchEvent touchEvent; 1548 ArkUITouchPoint pointes[3] = { 0, 1, 2 }; 1549 pointes[2].pressure = 1.1f; 1550 touchEvent.touchPointes = pointes; 1551 touchEvent.touchPointSize = -1; 1552 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1553 EXPECT_EQ(ret, 0.0f); 1554 event.inputEvent = &touchEvent; 1555 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1556 EXPECT_EQ(ret, 0.0f); 1557 touchEvent.touchPointSize = 3; 1558 event.inputEvent = &touchEvent; 1559 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1560 EXPECT_EQ(ret, 1.1f); 1561 1562 event.eventTypeId = C_MOUSE_EVENT_ID; 1563 event.inputEvent = nullptr; 1564 ArkUIMouseEvent mouseEvent; 1565 mouseEvent.actionTouchPoint.pressure = 2.2f; 1566 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1567 event.inputEvent = &mouseEvent; 1568 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1569 EXPECT_EQ(ret, 2.2f); 1570 1571 event.eventTypeId = C_CLICK_EVENT_ID; 1572 event.inputEvent = nullptr; 1573 ArkUIClickEvent clickEvent; 1574 clickEvent.pressure = 3.3f; 1575 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1576 event.inputEvent = &clickEvent; 1577 ret = OH_ArkUI_PointerEvent_GetPressure(&event, 0); 1578 EXPECT_EQ(ret, 3.3f); 1579 } 1580 1581 /** 1582 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX 1583 * @tc.desc: Test OH_ArkUI_PointerEvent_GetTiltX 1584 * @tc.type: FUNC 1585 */ 1586 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX, TestSize.Level1) 1587 { 1588 ArkUI_UIInputEvent event; 1589 auto ret = OH_ArkUI_PointerEvent_GetTiltX(nullptr, 0); 1590 EXPECT_EQ(ret, 0.0f); 1591 1592 event.eventTypeId = C_KEY_EVENT_ID; 1593 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1594 EXPECT_EQ(ret, 0.0f); 1595 1596 event.eventTypeId = C_TOUCH_EVENT_ID; 1597 event.inputEvent = nullptr; 1598 ArkUITouchEvent touchEvent; 1599 ArkUITouchPoint pointes[3] = { 0, 1, 2 }; 1600 pointes[2].tiltX = 1.1f; 1601 touchEvent.touchPointes = pointes; 1602 touchEvent.touchPointSize = -1; 1603 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1604 EXPECT_EQ(ret, 0.0f); 1605 event.inputEvent = &touchEvent; 1606 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1607 EXPECT_EQ(ret, 0.0f); 1608 touchEvent.touchPointSize = 3; 1609 event.inputEvent = &touchEvent; 1610 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1611 EXPECT_EQ(ret, 1.1f); 1612 1613 event.eventTypeId = C_HOVER_EVENT_ID; 1614 event.inputEvent = nullptr; 1615 ArkUIHoverEvent hoverEvent; 1616 hoverEvent.tiltX = 2.2f; 1617 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1618 event.inputEvent = &hoverEvent; 1619 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1620 EXPECT_EQ(ret, 2.2f); 1621 1622 event.eventTypeId = C_CLICK_EVENT_ID; 1623 event.inputEvent = nullptr; 1624 ArkUIClickEvent clickEvent; 1625 clickEvent.tiltX = 3.3f; 1626 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1627 event.inputEvent = &clickEvent; 1628 ret = OH_ArkUI_PointerEvent_GetTiltX(&event, 0); 1629 EXPECT_EQ(ret, 3.3f); 1630 } 1631 1632 /** 1633 * @tc.name: OH_ArkUI_PointerEvent_GetTiltY 1634 * @tc.desc: Test OH_ArkUI_PointerEvent_GetTiltY 1635 * @tc.type: FUNC 1636 */ 1637 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltY, TestSize.Level1) 1638 { 1639 ArkUI_UIInputEvent event; 1640 auto ret = OH_ArkUI_PointerEvent_GetTiltY(nullptr, 0); 1641 EXPECT_EQ(ret, 0.0f); 1642 1643 event.eventTypeId = C_KEY_EVENT_ID; 1644 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1645 EXPECT_EQ(ret, 0.0f); 1646 1647 event.eventTypeId = C_TOUCH_EVENT_ID; 1648 event.inputEvent = nullptr; 1649 ArkUITouchEvent touchEvent; 1650 ArkUITouchPoint pointes[3] = { 0, 1, 2 }; 1651 pointes[2].tiltY = 1.1f; 1652 touchEvent.touchPointes = pointes; 1653 touchEvent.touchPointSize = -1; 1654 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1655 EXPECT_EQ(ret, 0.0f); 1656 event.inputEvent = &touchEvent; 1657 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1658 EXPECT_EQ(ret, 0.0f); 1659 touchEvent.touchPointSize = 3; 1660 event.inputEvent = &touchEvent; 1661 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1662 EXPECT_EQ(ret, 1.1f); 1663 1664 event.eventTypeId = C_HOVER_EVENT_ID; 1665 event.inputEvent = nullptr; 1666 ArkUIHoverEvent hoverEvent; 1667 hoverEvent.tiltY = 2.2f; 1668 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1669 event.inputEvent = &hoverEvent; 1670 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1671 EXPECT_EQ(ret, 2.2f); 1672 1673 event.eventTypeId = C_CLICK_EVENT_ID; 1674 event.inputEvent = nullptr; 1675 ArkUIClickEvent clickEvent; 1676 clickEvent.tiltY = 3.3f; 1677 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1678 event.inputEvent = &clickEvent; 1679 ret = OH_ArkUI_PointerEvent_GetTiltY(&event, 0); 1680 EXPECT_EQ(ret, 3.3f); 1681 } 1682 1683 /** 1684 * @tc.name: OH_ArkUI_PointerEvent_GetRollAngle 1685 * @tc.desc: Test OH_ArkUI_PointerEvent_GetRollAngle 1686 * @tc.type: FUNC 1687 */ 1688 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetRollAngle, TestSize.Level1) 1689 { 1690 ArkUI_UIInputEvent event; 1691 double rollAngle = 2.0; 1692 auto ret = OH_ArkUI_PointerEvent_GetRollAngle(nullptr, &rollAngle); 1693 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1694 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, nullptr); 1695 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1696 1697 event.eventTypeId = C_KEY_EVENT_ID; 1698 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1699 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1700 1701 event.eventTypeId = C_TOUCH_EVENT_ID; 1702 event.inputEvent = nullptr; 1703 ArkUITouchEvent touchEvent; 1704 touchEvent.actionTouchPoint.rollAngle = 3.0; 1705 ArkUITouchPoint pointes[3]; 1706 pointes[2].rollAngle = 4.0; 1707 touchEvent.touchPointes = pointes; 1708 touchEvent.touchPointSize = 0; 1709 touchEvent.subKind = ON_AXIS; 1710 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1711 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1712 event.inputEvent = &touchEvent; 1713 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1714 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1715 touchEvent.touchPointSize = 3; 1716 event.inputEvent = &touchEvent; 1717 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1718 EXPECT_EQ(rollAngle, 4.0); 1719 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1720 touchEvent.subKind = ON_HOVER_MOVE; 1721 event.inputEvent = &touchEvent; 1722 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1723 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1724 EXPECT_EQ(rollAngle, 3.0); 1725 1726 event.eventTypeId = C_HOVER_EVENT_ID; 1727 event.inputEvent = nullptr; 1728 ArkUIHoverEvent hoverEvent; 1729 hoverEvent.rollAngle = 2.2; 1730 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1731 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1732 event.inputEvent = &hoverEvent; 1733 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1734 EXPECT_EQ(rollAngle, 2.2); 1735 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1736 } 1737 } // namespace OHOS::Ace 1738