1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "ui_input_event_test.h" 17 18 #include "node_model.h" 19 20 using namespace testing; 21 using namespace testing::ext; 22 namespace OHOS::Ace { 23 namespace { 24 constexpr int32_t ARKUI_DEVICE_ID = 1; 25 constexpr uint64_t ARKUI_TIME = 20; 26 constexpr ArkUI_Int32 AXIS_UPDATE = 2; 27 constexpr float ARKUI_X = 2.0; 28 constexpr float ARKUI_Y = 3.0; 29 constexpr float ARKUI_WIDTH = 2.0; 30 constexpr float ARKUI_HEIGHT = 3.0; 31 constexpr double ARKUI_TILTX = 2.0; 32 constexpr double ARKUI_TILTY = 3.0; 33 constexpr double ARKUI_PRESSURE = 1.0; 34 constexpr int32_t ARKUI_SOURCETYPE = 1; 35 constexpr int32_t ARKUI_TOOLTYPE = 7; 36 constexpr int32_t ARKUI_ACTIONTYPE = 1; 37 constexpr int32_t ARKUI_ACTIONTYPE_SET = 0; 38 constexpr int32_t ARKUI_FINGERID = 1; 39 constexpr int32_t ARKUI_FINGERID_SET = 0; 40 constexpr ArkUI_Uint64 ARKUI_MODIFIERKEYSTATE = 1; 41 constexpr ArkUI_Uint32 ARKUI_POINTERCOUNTER = 2; 42 } // namespace 43 /** 44 * @tc.name: UIInputEventTest001 45 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 46 * @tc.type: FUNC 47 */ 48 HWTEST_F(UIInputEventTest, UIInputEventTest001, TestSize.Level1) 49 { 50 /** 51 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 52 */ 53 ArkUI_NodeEvent nodeEvent; 54 ArkUINodeEvent event; 55 ArkUI_UIInputEvent uiInputEvent; 56 event.kind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 57 event.focusAxisEvent.subKind = ArkUIEventSubKind::ON_FOCUS_AXIS; 58 event.focusAxisEvent.absXValue = 0.5; 59 event.focusAxisEvent.absYValue = 0.5; 60 event.focusAxisEvent.absZValue = 0.5; 61 event.focusAxisEvent.absRzValue = 0.5; 62 event.focusAxisEvent.absHat0XValue = 1; 63 event.focusAxisEvent.absHat0YValue = 1; 64 event.focusAxisEvent.absBrakeValue = 0.5; 65 event.focusAxisEvent.absGasValue = 0.5; 66 event.focusAxisEvent.sourceType = static_cast<int32_t>(SourceType::MOUSE); 67 event.focusAxisEvent.toolType = static_cast<int32_t>(SourceTool::JOYSTICK); 68 event.focusAxisEvent.deviceId = ARKUI_DEVICE_ID; 69 event.focusAxisEvent.timeStamp = ARKUI_TIME; 70 uiInputEvent.inputEvent = &event.focusAxisEvent; 71 uiInputEvent.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 72 nodeEvent.origin = &uiInputEvent; 73 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 74 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 75 76 /** 77 * @tc.steps: step2. call functions. 78 */ 79 auto absXValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_X); 80 auto absYValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_Y); 81 auto absZValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_Z); 82 auto absRzValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_RZ); 83 auto absHat0XValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_HAT0X); 84 auto absHat0YValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_HAT0Y); 85 auto absBrakeValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_BRAKE); 86 auto absGasValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_GAS); 87 auto diviceId = OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent); 88 auto time = OH_ArkUI_UIInputEvent_GetEventTime(inputEvent); 89 auto sourceType = OH_ArkUI_UIInputEvent_GetSourceType(inputEvent); 90 auto toolType = OH_ArkUI_UIInputEvent_GetToolType(inputEvent); 91 92 /** 93 * @tc.expected: Return expected results. 94 */ 95 EXPECT_EQ(absXValue, 0.5); 96 EXPECT_EQ(absYValue, 0.5); 97 EXPECT_EQ(absZValue, 0.5); 98 EXPECT_EQ(absRzValue, 0.5); 99 EXPECT_EQ(absHat0XValue, 1); 100 EXPECT_EQ(absHat0YValue, 1); 101 EXPECT_EQ(absBrakeValue, 0.5); 102 EXPECT_EQ(absGasValue, 0.5); 103 EXPECT_EQ(diviceId, ARKUI_DEVICE_ID); 104 EXPECT_EQ(time, ARKUI_TIME); 105 EXPECT_EQ(sourceType, UI_INPUT_EVENTT_SOURCE_TYPE_MOUSE); 106 EXPECT_EQ(toolType, UI_INPUT_EVENT_TOOL_TYPE_JOYSTICK); 107 } 108 109 /** 110 * @tc.name: NativeTouchEventTest001 111 * @tc.desc: Test OH_ArkUI_PointerEvent_GetChangedPointerId function. 112 * @tc.type: FUNC 113 */ 114 HWTEST_F(UIInputEventTest, NativeTouchEventTest001, TestSize.Level1) 115 { 116 /** 117 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 118 */ 119 ArkUI_NodeEvent nodeEvent; 120 ArkUINodeEvent event; 121 ArkUI_UIInputEvent uiInputEvent; 122 event.touchEvent.changedPointerId = 1; 123 event.touchEvent.touchPointSize = 1; 124 uint32_t pointerIndex = 0; 125 uiInputEvent.inputEvent = &event.touchEvent; 126 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 127 nodeEvent.origin = &uiInputEvent; 128 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 129 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 130 131 /** 132 * @tc.steps: step2. call functions. 133 */ 134 auto changed_PointerId = OH_ArkUI_PointerEvent_GetChangedPointerId(inputEvent, &pointerIndex); 135 136 /** 137 * @tc.expected: Return expected results. 138 */ 139 EXPECT_EQ(changed_PointerId, ArkUI_ErrorCode::ARKUI_ERROR_CODE_NO_ERROR); 140 EXPECT_EQ(pointerIndex, 1); 141 } 142 143 /** 144 * @tc.name: AxisEventGetActionTest001 145 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 146 * @tc.type: FUNC 147 */ 148 HWTEST_F(UIInputEventTest, AxisEventGetActionTest001, TestSize.Level1) 149 { 150 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 151 EXPECT_NE(uiInputEvent, nullptr); 152 auto event = std::make_unique<OHOS::Ace::AxisEvent>(); 153 EXPECT_NE(event, nullptr); 154 155 event->action = AxisAction::BEGIN; 156 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 157 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 158 159 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 160 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_BEGIN); 161 } 162 163 /** 164 * @tc.name: AxisEventGetActionTest002 165 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 166 * @tc.type: FUNC 167 */ 168 HWTEST_F(UIInputEventTest, AxisEventGetActionTest002, TestSize.Level1) 169 { 170 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 171 EXPECT_NE(uiInputEvent, nullptr); 172 auto event = std::make_unique<ArkUIAxisEvent>(); 173 EXPECT_NE(event, nullptr); 174 175 event->action = AXIS_UPDATE; 176 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 177 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 178 179 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 180 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_UPDATE); 181 } 182 183 /** 184 * @tc.name: AxisEventGetActionTest003 185 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisActionfunction. 186 * @tc.type: FUNC 187 */ 188 HWTEST_F(UIInputEventTest, AxisEventGetActionTest003, TestSize.Level1) 189 { 190 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 191 EXPECT_NE(uiInputEvent, nullptr); 192 auto event = std::make_unique<ArkUIAxisEvent>(); 193 EXPECT_NE(event, nullptr); 194 195 event->action = AXIS_UPDATE; 196 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 197 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 198 199 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 200 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 201 202 action = OH_ArkUI_AxisEvent_GetAxisAction(nullptr); 203 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 204 } 205 206 /** 207 * @tc.name: AxisEventGetActionTest004 208 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 209 * @tc.type: FUNC 210 */ 211 HWTEST_F(UIInputEventTest, AxisEventGetActionTest004, TestSize.Level1) 212 { 213 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 214 EXPECT_NE(uiInputEvent, nullptr); 215 216 uiInputEvent->inputEvent = nullptr; 217 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 218 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 219 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 220 221 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 222 action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 223 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 224 } 225 226 /** 227 * @tc.name: CapiInputTest001 228 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 229 * @tc.type: FUNC 230 */ 231 HWTEST_F(UIInputEventTest, CapiInputTest001, TestSize.Level1) 232 { 233 /** 234 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 235 */ 236 ArkUI_NodeEvent nodeEvent; 237 ArkUINodeEvent event; 238 ArkUI_UIInputEvent uiInputEvent; 239 event.kind = ArkUIEventCategory::CLICK_EVENT; 240 event.clickEvent.subKind = ArkUIEventSubKind::ON_CLICK_EVENT; 241 event.clickEvent.localX = ARKUI_X; 242 event.clickEvent.localY = ARKUI_Y; 243 event.clickEvent.timestamp = ARKUI_TIME; 244 event.clickEvent.sourceType = ARKUI_SOURCETYPE; 245 event.clickEvent.windowX = ARKUI_X; 246 event.clickEvent.windowY = ARKUI_Y; 247 event.clickEvent.displayX = ARKUI_X; 248 event.clickEvent.displayY = ARKUI_Y; 249 event.clickEvent.targetPositionX = ARKUI_X; 250 event.clickEvent.targetPositionY = ARKUI_Y; 251 event.clickEvent.targetGlobalPositionX = ARKUI_X; 252 event.clickEvent.targetGlobalPositionY = ARKUI_Y; 253 uiInputEvent.inputEvent = &event.clickEvent; 254 uiInputEvent.eventTypeId = C_CLICK_EVENT_ID; 255 nodeEvent.origin = &uiInputEvent; 256 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 257 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 258 259 /** 260 * @tc.expected: Return expected results. 261 */ 262 EXPECT_EQ(OH_ArkUI_PointerEvent_GetX(inputEvent), ARKUI_X); 263 EXPECT_EQ(OH_ArkUI_PointerEvent_GetY(inputEvent), ARKUI_Y); 264 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTime(inputEvent), ARKUI_TIME); 265 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 266 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowX(inputEvent), ARKUI_X); 267 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowY(inputEvent), ARKUI_Y); 268 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayX(inputEvent), ARKUI_X); 269 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayY(inputEvent), ARKUI_Y); 270 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 271 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 272 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 273 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 274 } 275 276 /** 277 * @tc.name: CapiInputTest002 278 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 279 * @tc.type: FUNC 280 */ 281 HWTEST_F(UIInputEventTest, CapiInputTest002, TestSize.Level1) 282 { 283 /** 284 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 285 */ 286 ArkUI_NodeEvent nodeEvent; 287 ArkUINodeEvent event; 288 ArkUI_UIInputEvent uiInputEvent; 289 event.kind = ArkUIEventCategory::CLICK_EVENT; 290 event.clickEvent.subKind = ArkUIEventSubKind::ON_CLICK_EVENT; 291 event.clickEvent.width = ARKUI_WIDTH; 292 event.clickEvent.height = ARKUI_HEIGHT; 293 event.clickEvent.tiltX = ARKUI_TILTX; 294 event.clickEvent.tiltY = ARKUI_TILTY; 295 event.clickEvent.pressure = ARKUI_PRESSURE; 296 event.clickEvent.toolType = ARKUI_TOOLTYPE; 297 event.clickEvent.deviceId = ARKUI_DEVICE_ID; 298 event.clickEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 299 event.clickEvent.clickPointSize = ARKUI_POINTERCOUNTER; 300 uiInputEvent.inputEvent = &event.clickEvent; 301 uiInputEvent.eventTypeId = C_CLICK_EVENT_ID; 302 nodeEvent.origin = &uiInputEvent; 303 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 304 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 305 306 /** 307 * @tc.expected: Return expected results. 308 */ 309 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_WIDTH); 310 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_HEIGHT); 311 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltX(inputEvent, 0), ARKUI_TILTX); 312 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltY(inputEvent, 0), ARKUI_TILTY); 313 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), ARKUI_PRESSURE); 314 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 315 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 316 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 317 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerCount(inputEvent), ARKUI_POINTERCOUNTER); 318 } 319 320 /** 321 * @tc.name: CapiInputTest003 322 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 323 * @tc.type: FUNC 324 */ 325 HWTEST_F(UIInputEventTest, CapiInputTest003, TestSize.Level1) 326 { 327 /** 328 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 329 */ 330 ArkUI_NodeEvent nodeEvent; 331 ArkUINodeEvent event; 332 ArkUI_UIInputEvent uiInputEvent; 333 event.kind = ArkUIEventCategory::HOVER_EVENT; 334 event.hoverEvent.subKind = ON_HOVER_EVENT; 335 event.hoverEvent.isHover = true; 336 // width height x y globalx globaly 337 event.hoverEvent.targetPositionX = ARKUI_X; 338 event.hoverEvent.targetPositionY = ARKUI_Y; 339 event.hoverEvent.targetGlobalPositionX = ARKUI_X; 340 event.hoverEvent.targetGlobalPositionY = ARKUI_Y; 341 event.hoverEvent.width = ARKUI_WIDTH; 342 event.hoverEvent.height = ARKUI_HEIGHT; 343 // deviceid 344 event.hoverEvent.deviceId = ARKUI_DEVICE_ID; 345 // modifierkeystates 346 event.hoverEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 347 // timestamp 348 event.hoverEvent.timeStamp = ARKUI_TIME; 349 // sourcetool 350 event.hoverEvent.toolType = ARKUI_TOOLTYPE; 351 // source 352 event.hoverEvent.sourceType = ARKUI_SOURCETYPE; 353 // tiltX tiltY 354 event.hoverEvent.tiltX = ARKUI_TILTX; 355 event.hoverEvent.tiltY = ARKUI_TILTY; 356 // stoppropagation 357 event.hoverEvent.stopPropagation = false; 358 uiInputEvent.inputEvent = &event.hoverEvent; 359 uiInputEvent.eventTypeId = C_HOVER_EVENT_ID; 360 nodeEvent.origin = &uiInputEvent; 361 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 362 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 363 364 /** 365 * @tc.expected: Return expected results. 366 */ 367 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTime(inputEvent), ARKUI_TIME); 368 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 369 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 370 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 371 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 372 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 373 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 374 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 375 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltX(inputEvent, 0), ARKUI_TILTX); 376 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltY(inputEvent, 0), ARKUI_TILTY); 377 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 378 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 379 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 380 EXPECT_TRUE(OH_ArkUI_HoverEvent_IsHovered(inputEvent)); 381 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(inputEvent->inputEvent); 382 EXPECT_FALSE(hoverEvent->stopPropagation); 383 OH_ArkUI_PointerEvent_SetStopPropagation(inputEvent, true); 384 EXPECT_TRUE(hoverEvent->stopPropagation); 385 } 386 387 /** 388 * @tc.name: CapiInputTest004 389 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 390 * @tc.type: FUNC 391 */ 392 HWTEST_F(UIInputEventTest, CapiInputTest004, TestSize.Level1) 393 { 394 /** 395 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 396 */ 397 ArkUI_NodeEvent nodeEvent; 398 ArkUINodeEvent event; 399 ArkUI_UIInputEvent uiInputEvent; 400 event.kind = TOUCH_EVENT; 401 // width height x y globalx globaly 402 event.touchEvent.targetPositionX = ARKUI_X; 403 event.touchEvent.targetPositionY = ARKUI_Y; 404 event.touchEvent.targetGlobalPositionX = ARKUI_X; 405 event.touchEvent.targetGlobalPositionY = ARKUI_Y; 406 event.touchEvent.width = ARKUI_WIDTH; 407 event.touchEvent.height = ARKUI_HEIGHT; 408 // deviceid 409 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 410 // modifierkeystates 411 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 412 uiInputEvent.inputEvent = &event.touchEvent; 413 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 414 nodeEvent.origin = &uiInputEvent; 415 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 416 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 417 418 /** 419 * @tc.expected: Return expected results. 420 */ 421 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 422 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 423 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 424 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 425 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 426 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 427 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 428 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 429 } 430 431 /** 432 * @tc.name: CapiInputTest005 433 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 434 * @tc.type: FUNC 435 */ 436 HWTEST_F(UIInputEventTest, CapiInputTest005, TestSize.Level1) 437 { 438 /** 439 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 440 */ 441 ArkUI_NodeEvent nodeEvent; 442 ArkUINodeEvent event; 443 ArkUI_UIInputEvent uiInputEvent; 444 event.kind = MOUSE_INPUT_EVENT; 445 event.mouseEvent.subKind = ON_MOUSE; 446 // width height x y globalx globaly 447 event.mouseEvent.targetPositionX = ARKUI_X; 448 event.mouseEvent.targetPositionY = ARKUI_Y; 449 event.mouseEvent.targetGlobalPositionX = ARKUI_X; 450 event.mouseEvent.targetGlobalPositionY = ARKUI_Y; 451 event.mouseEvent.width = ARKUI_WIDTH; 452 event.mouseEvent.height = ARKUI_HEIGHT; 453 // deviceid 454 event.mouseEvent.deviceId = ARKUI_DEVICE_ID; 455 // modifierkeystates 456 event.mouseEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 457 // pressure 458 event.mouseEvent.actionTouchPoint.pressure = ARKUI_PRESSURE; 459 // toolType 460 event.mouseEvent.actionTouchPoint.toolType = ARKUI_TOOLTYPE; 461 // source 462 event.mouseEvent.sourceType = ARKUI_SOURCETYPE; 463 // stoppropagation 464 event.mouseEvent.stopPropagation = false; 465 uiInputEvent.inputEvent = &event.mouseEvent; 466 uiInputEvent.eventTypeId = C_MOUSE_EVENT_ID; 467 nodeEvent.origin = &uiInputEvent; 468 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 469 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 470 471 /** 472 * @tc.expected: Return expected results. 473 */ 474 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 475 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 476 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 477 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 478 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 479 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 480 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 481 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 482 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), ARKUI_PRESSURE); 483 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 484 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 485 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(inputEvent->inputEvent); 486 EXPECT_FALSE(mouseEvent->stopPropagation); 487 OH_ArkUI_PointerEvent_SetStopPropagation(inputEvent, true); 488 EXPECT_TRUE(mouseEvent->stopPropagation); 489 } 490 491 /** 492 * @tc.name: CapiInputTest006 493 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 494 * @tc.type: FUNC 495 */ 496 HWTEST_F(UIInputEventTest, CapiInputTest006, TestSize.Level1) 497 { 498 /** 499 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 500 */ 501 ArkUI_NodeEvent nodeEvent; 502 ArkUINodeEvent event; 503 ArkUI_UIInputEvent uiInputEvent; 504 event.kind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 505 event.focusAxisEvent.subKind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 506 // width height x y globalx globaly 507 event.focusAxisEvent.targetPositionX = ARKUI_X; 508 event.focusAxisEvent.targetPositionY = ARKUI_Y; 509 event.focusAxisEvent.targetGlobalPositionX = ARKUI_X; 510 event.focusAxisEvent.targetGlobalPositionY = ARKUI_Y; 511 event.focusAxisEvent.width = ARKUI_WIDTH; 512 event.focusAxisEvent.height = ARKUI_HEIGHT; 513 // deviceid 514 event.focusAxisEvent.deviceId = ARKUI_DEVICE_ID; 515 // modifierkeystates 516 event.focusAxisEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 517 uiInputEvent.inputEvent = &event.focusAxisEvent; 518 uiInputEvent.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 519 nodeEvent.origin = &uiInputEvent; 520 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 521 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 522 523 /** 524 * @tc.expected: Return expected results. 525 */ 526 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 527 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 528 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 529 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 530 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 531 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 532 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 533 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 534 } 535 536 /** 537 * @tc.name: CapiInputTest007 538 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 539 * @tc.type: FUNC 540 */ 541 HWTEST_F(UIInputEventTest, CapiInputTest007, TestSize.Level1) 542 { 543 /** 544 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 545 */ 546 ArkUI_NodeEvent nodeEvent; 547 ArkUINodeEvent event; 548 ArkUI_UIInputEvent uiInputEvent; 549 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 550 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 551 // deviceid 552 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 553 // modifierkeystates 554 event.keyEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 555 uiInputEvent.inputEvent = &event.mouseEvent; 556 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 557 nodeEvent.origin = &uiInputEvent; 558 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 559 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 560 561 /** 562 * @tc.expected: Return expected results. 563 */ 564 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 565 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 566 } 567 568 /** 569 * @tc.name: CapiInputTest008 570 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 571 * @tc.type: FUNC 572 */ 573 HWTEST_F(UIInputEventTest, CapiInputTest008, TestSize.Level1) 574 { 575 /** 576 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 577 */ 578 ArkUI_NodeEvent nodeEvent; 579 ArkUINodeEvent event; 580 ArkUI_UIInputEvent uiInputEvent; 581 event.kind = TOUCH_EVENT; 582 // width height x y globalx globaly 583 event.touchEvent.targetPositionX = ARKUI_X; 584 event.touchEvent.targetPositionY = ARKUI_Y; 585 event.touchEvent.targetGlobalPositionX = ARKUI_X; 586 event.touchEvent.targetGlobalPositionY = ARKUI_Y; 587 event.touchEvent.width = ARKUI_WIDTH; 588 event.touchEvent.height = ARKUI_HEIGHT; 589 // deviceid 590 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 591 // modifierkeystates 592 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 593 event.touchEvent.subKind = ON_HOVER_MOVE; 594 event.touchEvent.actionTouchPoint.id = 1; 595 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 596 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 597 event.touchEvent.actionTouchPoint.windowX = ARKUI_X; 598 event.touchEvent.actionTouchPoint.windowY = ARKUI_Y; 599 event.touchEvent.actionTouchPoint.screenX = ARKUI_X; 600 event.touchEvent.actionTouchPoint.screenY = ARKUI_Y; 601 event.touchEvent.actionTouchPoint.globalDisplayX = ARKUI_X; 602 event.touchEvent.actionTouchPoint.globalDisplayY = ARKUI_Y; 603 604 uiInputEvent.inputEvent = &event.touchEvent; 605 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 606 nodeEvent.origin = &uiInputEvent; 607 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 608 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 609 610 /** 611 * @tc.expected: Return expected results. 612 */ 613 EXPECT_EQ(OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0), ARKUI_X); 614 EXPECT_EQ(OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0), ARKUI_Y); 615 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowXByIndex(inputEvent, 0), ARKUI_X); 616 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowYByIndex(inputEvent, 0), ARKUI_Y); 617 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayXByIndex(inputEvent, 0), ARKUI_X); 618 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayYByIndex(inputEvent, 0), ARKUI_Y); 619 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(inputEvent, 0), ARKUI_X); 620 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(inputEvent, 0), ARKUI_Y); 621 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0), 1); 622 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerCount(inputEvent), 1); 623 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), 0); 624 625 EXPECT_EQ(OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 1), 0); 626 EXPECT_EQ(OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 1), 0); 627 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowXByIndex(inputEvent, 1), 0); 628 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowYByIndex(inputEvent, 1), 0); 629 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayXByIndex(inputEvent, 1), 0); 630 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayYByIndex(inputEvent, 1), 0); 631 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(inputEvent, 1), 0); 632 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(inputEvent, 1), 0); 633 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 1), 0); 634 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 1), 0); 635 } 636 637 /** 638 * @tc.name: CapiInputTest009 639 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 640 * @tc.type: FUNC 641 */ 642 HWTEST_F(UIInputEventTest, CapiInputTest009, TestSize.Level1) 643 { 644 /** 645 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 646 */ 647 ArkUI_NodeEvent nodeEvent; 648 ArkUINodeEvent event; 649 ArkUI_UIInputEvent uiInputEvent; 650 event.kind = TOUCH_EVENT; 651 event.touchEvent.subKind = ON_HOVER_EVENT; 652 653 uiInputEvent.inputEvent = nullptr; 654 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 655 nodeEvent.origin = &uiInputEvent; 656 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 657 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 658 659 /** 660 * @tc.expected: Return expected results. 661 */ 662 EXPECT_EQ(OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0), 0); 663 EXPECT_EQ(OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0), 0); 664 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowXByIndex(inputEvent, 0), 0); 665 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowYByIndex(inputEvent, 0), 0); 666 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayXByIndex(inputEvent, 0), 0); 667 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayYByIndex(inputEvent, 0), 0); 668 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(inputEvent, 0), 0); 669 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(inputEvent, 0), 0); 670 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0), 0); 671 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerCount(inputEvent), 0); 672 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), 0); 673 } 674 675 /** 676 * @tc.name: CapiInputTest010 677 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 678 * @tc.type: FUNC 679 */ 680 HWTEST_F(UIInputEventTest, CapiInputTest010, TestSize.Level1) 681 { 682 /** 683 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 684 */ 685 ArkUI_NodeEvent nodeEvent; 686 ArkUINodeEvent event; 687 ArkUI_UIInputEvent uiInputEvent; 688 event.kind = TOUCH_EVENT; 689 event.touchEvent.subKind = ON_HOVER_EVENT; 690 691 uiInputEvent.inputEvent = &event.touchEvent; 692 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 693 nodeEvent.origin = &uiInputEvent; 694 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 695 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 696 697 /** 698 * @tc.expected: Return expected results. 699 */ 700 EXPECT_EQ(OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0), 0); 701 EXPECT_EQ(OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0), 0); 702 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowXByIndex(inputEvent, 0), 0); 703 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowYByIndex(inputEvent, 0), 0); 704 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayXByIndex(inputEvent, 0), 0); 705 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayYByIndex(inputEvent, 0), 0); 706 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(inputEvent, 0), 0); 707 EXPECT_EQ(OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(inputEvent, 0), 0); 708 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0), 0); 709 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerCount(inputEvent), 0); 710 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), 0); 711 } 712 713 /** 714 * @tc.name: CapiInputTest011 715 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 716 * @tc.type: FUNC 717 */ 718 HWTEST_F(UIInputEventTest, CapiInputTest011, TestSize.Level1) 719 { 720 /** 721 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 722 */ 723 ArkUI_NodeEvent nodeEvent; 724 ArkUINodeEvent event; 725 ArkUI_UIInputEvent uiInputEvent; 726 event.kind = TOUCH_EVENT; 727 event.touchEvent.subKind = ON_HOVER_MOVE; 728 event.touchEvent.actionTouchPoint.tiltX = ARKUI_X; 729 event.touchEvent.actionTouchPoint.tiltY = ARKUI_Y; 730 731 uiInputEvent.inputEvent = &event.touchEvent; 732 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 733 nodeEvent.origin = &uiInputEvent; 734 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 735 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 736 737 /** 738 * @tc.expected: Return expected results. 739 */ 740 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltX(inputEvent, 0), ARKUI_X); 741 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltY(inputEvent, 0), ARKUI_Y); 742 } 743 744 /** 745 * @tc.name: PointerEventGetInteractionHandTest001 746 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 747 * @tc.type: FUNC 748 */ 749 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest001, TestSize.Level1) 750 { 751 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 752 EXPECT_NE(uiInputEvent, nullptr); 753 754 uiInputEvent->inputEvent = nullptr; 755 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 756 757 ArkUI_InteractionHand *hand = nullptr; 758 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(uiInputEvent.get(), hand); 759 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 760 } 761 762 /** 763 * @tc.name: PointerEventGetInteractionHandTest002 764 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 765 * @tc.type: FUNC 766 */ 767 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest002, TestSize.Level1) 768 { 769 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 770 EXPECT_NE(uiInputEvent, nullptr); 771 772 uiInputEvent->inputEvent = nullptr; 773 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 774 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 775 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(uiInputEvent.get(), &hand); 776 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 777 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 778 } 779 780 /** 781 * @tc.name: PointerEventGetInteractionHandTest003 782 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 783 * @tc.type: FUNC 784 */ 785 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest003, TestSize.Level1) 786 { 787 ArkUINodeEvent event; 788 ArkUI_UIInputEvent uiInputEvent; 789 event.touchEvent.actionTouchPoint.operatingHand = ARKUI_EVENT_HAND_LEFT; 790 uiInputEvent.inputEvent = &event.touchEvent; 791 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 792 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 793 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(&uiInputEvent, &hand); 794 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 795 EXPECT_EQ(hand, ARKUI_EVENT_HAND_LEFT); 796 } 797 798 /** 799 * @tc.name: PointerEventGetInteractionHandTest004 800 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 801 * @tc.type: FUNC 802 */ 803 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest004, TestSize.Level1) 804 { 805 ArkUINodeEvent event; 806 ArkUI_UIInputEvent uiInputEvent; 807 event.touchEvent.actionTouchPoint.operatingHand = ARKUI_EVENT_HAND_RIGHT; 808 uiInputEvent.inputEvent = &event.touchEvent; 809 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 810 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 811 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(&uiInputEvent, &hand); 812 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 813 EXPECT_EQ(hand, ARKUI_EVENT_HAND_RIGHT); 814 } 815 816 /** 817 * @tc.name: PointerEventGetInteractionHandByIndexTest001 818 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 819 * @tc.type: FUNC 820 */ 821 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest001, TestSize.Level1) 822 { 823 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 824 EXPECT_NE(uiInputEvent, nullptr); 825 826 uiInputEvent->inputEvent = nullptr; 827 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 828 ArkUI_InteractionHand *hand = nullptr; 829 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, hand); 830 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 831 } 832 833 /** 834 * @tc.name: PointerEventGetInteractionHandByIndexTest002 835 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 836 * @tc.type: FUNC 837 */ 838 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest002, TestSize.Level1) 839 { 840 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 841 EXPECT_NE(uiInputEvent, nullptr); 842 843 uiInputEvent->inputEvent = nullptr; 844 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 845 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 846 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, &hand); 847 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 848 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 849 } 850 851 /** 852 * @tc.name: PointerEventGetInteractionHandByIndexTest003 853 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 854 * @tc.type: FUNC 855 */ 856 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest003, TestSize.Level1) 857 { 858 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 859 EXPECT_NE(uiInputEvent, nullptr); 860 861 uiInputEvent->inputEvent = nullptr; 862 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 863 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 864 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, &hand); 865 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 866 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 867 } 868 869 /** 870 * @tc.name: PointerEventGetInteractionHandByIndexTest004 871 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 872 * @tc.type: FUNC 873 */ 874 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest004, TestSize.Level1) 875 { 876 ArkUINodeEvent event; 877 ArkUI_UIInputEvent uiInputEvent; 878 ArkUITouchPoint points[2]; // 2 points 879 points[0].operatingHand = ARKUI_EVENT_HAND_LEFT; 880 points[1].operatingHand = ARKUI_EVENT_HAND_RIGHT; 881 event.touchEvent.touchPointes = points; 882 event.touchEvent.touchPointSize = 2; // 2 points 883 uiInputEvent.inputEvent = &event.touchEvent; 884 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 885 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 886 int32_t result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 0, &hand); 887 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 888 EXPECT_EQ(hand, ARKUI_EVENT_HAND_LEFT); 889 890 hand = ARKUI_EVENT_HAND_NONE; 891 result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 1, &hand); 892 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 893 EXPECT_EQ(hand, ARKUI_EVENT_HAND_RIGHT); 894 895 hand = ARKUI_EVENT_HAND_NONE; 896 // 2 is out of range 897 result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 2, &hand); 898 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 899 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 900 } 901 902 /** 903 * @tc.name: AxisEventScrollStepTest001 904 * @tc.desc: Test OH_ArkUI_AxisEvent_GetScrollStep function. 905 * @tc.type: FUNC 906 */ 907 HWTEST_F(UIInputEventTest, AxisEventScrollStepTest001, TestSize.Level1) 908 { 909 /** 910 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 911 */ 912 ArkUI_NodeEvent nodeEvent; 913 ArkUINodeEvent event; 914 ArkUI_UIInputEvent uiInputEvent; 915 event.kind = ArkUIEventCategory::AXIS_EVENT; 916 event.axisEvent.subKind = ArkUIEventSubKind::ON_AXIS; 917 event.axisEvent.timeStamp = ARKUI_TIME; 918 event.axisEvent.scrollStep = 3; 919 uiInputEvent.inputEvent = &event.axisEvent; 920 uiInputEvent.eventTypeId = C_AXIS_EVENT_ID; 921 nodeEvent.origin = &uiInputEvent; 922 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 923 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 924 925 /** 926 * @tc.steps: step2. call functions. 927 */ 928 auto scroll_step = OH_ArkUI_AxisEvent_GetScrollStep(inputEvent); 929 930 /** 931 * @tc.expected: Return expected results. 932 */ 933 EXPECT_EQ(scroll_step, 3); 934 } 935 936 /** 937 * @tc.name: AxisEventToolTypeTest001 938 * @tc.desc: Test OH_ArkUI_AxisEvent_GetScrollStep function. 939 * @tc.type: FUNC 940 */ 941 HWTEST_F(UIInputEventTest, AxisEventToolTypeTest001, TestSize.Level1) 942 { 943 /** 944 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 945 */ 946 ArkUI_NodeEvent nodeEvent; 947 ArkUINodeEvent event; 948 ArkUI_UIInputEvent uiInputEvent; 949 event.kind = ArkUIEventCategory::AXIS_EVENT; 950 event.axisEvent.subKind = ArkUIEventSubKind::ON_AXIS; 951 event.axisEvent.timeStamp = ARKUI_TIME; 952 event.axisEvent.actionTouchPoint.toolType = ARKUI_TOOLTYPE; 953 uiInputEvent.inputEvent = &event.axisEvent; 954 uiInputEvent.eventTypeId = C_AXIS_EVENT_ID; 955 nodeEvent.origin = &uiInputEvent; 956 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 957 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 958 /** 959 * @tc.steps: step2. call functions. 960 */ 961 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 962 } 963 964 /* 965 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY001 966 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 967 * @tc.type: FUNC 968 */ 969 HWTEST_F(UIInputEventTest, MouseEventGetRawDeltaY001, TestSize.Level1) 970 { 971 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 972 EXPECT_NE(uiInputEvent, nullptr); 973 auto event = std::make_unique<ArkUIMouseEvent>(); 974 EXPECT_NE(event, nullptr); 975 976 event->rawDeltaY = 5.0; 977 uiInputEvent->inputEvent = event.get(); 978 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 979 980 auto action = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 981 EXPECT_EQ(action, 5.0); 982 } 983 984 /** 985 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY002 986 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 987 * @tc.type: FUNC 988 */ 989 HWTEST_F(UIInputEventTest, MouseEventGetRawDeltaY002, TestSize.Level1) 990 { 991 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 992 EXPECT_NE(uiInputEvent, nullptr); 993 auto event = std::make_unique<ArkUIMouseEvent>(); 994 EXPECT_NE(event, nullptr); 995 996 event->rawDeltaY = 5.0; 997 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 998 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 999 1000 auto action = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 1001 EXPECT_EQ(action, 0.0); 1002 } 1003 1004 /** 1005 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY003 1006 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1007 * @tc.type: FUNC 1008 */ 1009 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY003, TestSize.Level1) 1010 { 1011 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1012 event->eventTypeId = C_TOUCH_EVENT_ID; 1013 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1014 EXPECT_EQ(result, 0.0); 1015 } 1016 1017 /** 1018 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY004 1019 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1020 * @tc.type: FUNC 1021 */ 1022 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY004, TestSize.Level1) 1023 { 1024 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1025 event->eventTypeId = TOUCH_EVENT_ID; 1026 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1027 EXPECT_EQ(result, 0.0); 1028 } 1029 1030 /** 1031 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY005 1032 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1033 * @tc.type: FUNC 1034 */ 1035 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY005, TestSize.Level1) 1036 { 1037 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1038 event->eventTypeId = C_MOUSE_EVENT_ID; 1039 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1040 EXPECT_EQ(result, 0.0); 1041 } 1042 1043 /** 1044 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY006 1045 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1046 * @tc.type: FUNC 1047 */ 1048 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY006, TestSize.Level1) 1049 { 1050 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1051 event->eventTypeId = C_AXIS_EVENT_ID; 1052 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1053 EXPECT_EQ(result, 0.0); 1054 } 1055 1056 /** 1057 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY007 1058 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1059 * @tc.type: FUNC 1060 */ 1061 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY007, TestSize.Level1) 1062 { 1063 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1064 event->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 1065 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1066 EXPECT_EQ(result, 0.0); 1067 } 1068 1069 /** 1070 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY008 1071 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1072 * @tc.type: FUNC 1073 */ 1074 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY008, TestSize.Level1) 1075 { 1076 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1077 event->eventTypeId = C_HOVER_EVENT_ID; 1078 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1079 EXPECT_EQ(result, 0.0); 1080 } 1081 1082 /** 1083 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY009 1084 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1085 * @tc.type: FUNC 1086 */ 1087 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY009, TestSize.Level1) 1088 { 1089 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1090 event->eventTypeId = C_CLICK_EVENT_ID; 1091 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1092 EXPECT_EQ(result, 0.0); 1093 } 1094 1095 /** 1096 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons001 1097 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 1098 * @tc.type: FUNC 1099 */ 1100 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons001, TestSize.Level1) 1101 { 1102 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1103 EXPECT_NE(uiInputEvent, nullptr); 1104 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1105 auto event = std::make_unique<ArkUIMouseEvent>(); 1106 event->pressedButtonsLength = 0; 1107 EXPECT_NE(event, nullptr); 1108 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 1109 int32_t pressedButtons[] = {5, 5, 5}; 1110 int32_t length = 1; 1111 1112 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 1113 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 1114 } 1115 1116 /** 1117 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons002 1118 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 1119 * @tc.type: FUNC 1120 */ 1121 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons002, TestSize.Level1) 1122 { 1123 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1124 EXPECT_NE(uiInputEvent, nullptr); 1125 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1126 auto event = std::make_unique<ArkUIMouseEvent>(); 1127 event->pressedButtonsLength = 6; 1128 EXPECT_NE(event, nullptr); 1129 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 1130 int32_t pressedButtons[] = {5, 5, 5}; 1131 int32_t length = 1; 1132 1133 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 1134 EXPECT_EQ(result, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 1135 } 1136 1137 /** 1138 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons003 1139 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 1140 * @tc.type: FUNC 1141 */ 1142 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons003, TestSize.Level1) 1143 { 1144 int32_t length = 1; 1145 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(nullptr, nullptr, &length); 1146 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1147 } 1148 1149 /** 1150 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons004 1151 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 1152 * @tc.type: FUNC 1153 */ 1154 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons004, TestSize.Level1) 1155 { 1156 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1157 EXPECT_NE(uiInputEvent, nullptr); 1158 uiInputEvent->inputEvent = nullptr; 1159 int32_t pressedButtons[] = {5, 5, 5}; 1160 int32_t length = 1; 1161 1162 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 1163 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1164 } 1165 1166 /** 1167 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId001 1168 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1169 * @tc.type: FUNC 1170 */ 1171 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId001, TestSize.Level1) 1172 { 1173 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(nullptr); 1174 EXPECT_EQ(result, 0); 1175 } 1176 1177 /** 1178 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId002 1179 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1180 * @tc.type: FUNC 1181 */ 1182 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId002, TestSize.Level1) 1183 { 1184 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1185 event->eventTypeId = C_MOUSE_EVENT_ID; 1186 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1187 mouseEvent->targetDisplayId = 1; 1188 event->inputEvent = mouseEvent.get(); 1189 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1190 EXPECT_EQ(result, 1); 1191 } 1192 1193 /** 1194 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId003 1195 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1196 * @tc.type: FUNC 1197 */ 1198 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId003, TestSize.Level1) 1199 { 1200 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1201 event->eventTypeId = C_TOUCH_EVENT_ID; 1202 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1203 touchEvent->targetDisplayId = 2; 1204 event->inputEvent = touchEvent.get(); 1205 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1206 EXPECT_EQ(result, 2); 1207 } 1208 1209 /** 1210 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId004 1211 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1212 * @tc.type: FUNC 1213 */ 1214 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId004, TestSize.Level1) 1215 { 1216 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1217 event->eventTypeId = C_AXIS_EVENT_ID; 1218 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1219 axisEvent->targetDisplayId = 3; 1220 event->inputEvent = axisEvent.get(); 1221 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1222 EXPECT_EQ(result, 3); 1223 } 1224 1225 /** 1226 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId005 1227 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1228 * @tc.type: FUNC 1229 */ 1230 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId005, TestSize.Level1) 1231 { 1232 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1233 event->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 1234 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 1235 focusAxisEvent->targetDisplayId = 4; 1236 event->inputEvent = focusAxisEvent.get(); 1237 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1238 EXPECT_EQ(result, 4); 1239 } 1240 1241 /** 1242 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId006 1243 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1244 * @tc.type: FUNC 1245 */ 1246 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId006, TestSize.Level1) 1247 { 1248 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1249 event->eventTypeId = AXIS_EVENT_ID; 1250 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1251 EXPECT_EQ(result, 0); 1252 } 1253 1254 /** 1255 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId007 1256 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 1257 * @tc.type: FUNC 1258 */ 1259 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId007, TestSize.Level1) 1260 { 1261 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1262 event->eventTypeId = C_AXIS_EVENT_ID; 1263 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1264 axisEvent->targetDisplayId = 0; 1265 event->inputEvent = axisEvent.get(); 1266 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 1267 EXPECT_EQ(result, 0); 1268 } 1269 1270 /** 1271 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX001 1272 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1273 * @tc.type: FUNC 1274 */ 1275 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX001, TestSize.Level1) 1276 { 1277 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(nullptr); 1278 EXPECT_EQ(result, 0.0); 1279 } 1280 1281 /** 1282 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX002 1283 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1284 * @tc.type: FUNC 1285 */ 1286 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX002, TestSize.Level1) 1287 { 1288 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1289 event->eventTypeId = C_MOUSE_EVENT_ID; 1290 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1291 EXPECT_EQ(result, 0.0); 1292 } 1293 1294 /** 1295 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX003 1296 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1297 * @tc.type: FUNC 1298 */ 1299 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX003, TestSize.Level1) 1300 { 1301 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1302 event->eventTypeId = C_MOUSE_EVENT_ID; 1303 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1304 mouseEvent->rawDeltaX = 1; 1305 event->inputEvent = mouseEvent.get(); 1306 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1307 EXPECT_EQ(result, 1); 1308 } 1309 1310 /** 1311 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX004 1312 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1313 * @tc.type: FUNC 1314 */ 1315 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX004, TestSize.Level1) 1316 { 1317 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1318 event->eventTypeId = AXIS_EVENT_ID; 1319 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1320 EXPECT_EQ(result, 0.0); 1321 } 1322 1323 /** 1324 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX005 1325 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1326 * @tc.type: FUNC 1327 */ 1328 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX005, TestSize.Level1) 1329 { 1330 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1331 event->eventTypeId = C_TOUCH_EVENT_ID; 1332 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1333 EXPECT_EQ(result, 0.0); 1334 } 1335 1336 /** 1337 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX006 1338 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1339 * @tc.type: FUNC 1340 */ 1341 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX006, TestSize.Level1) 1342 { 1343 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1344 event->eventTypeId = TOUCH_EVENT_ID; 1345 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1346 EXPECT_EQ(result, 0.0); 1347 } 1348 1349 /** 1350 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX007 1351 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1352 * @tc.type: FUNC 1353 */ 1354 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX007, TestSize.Level1) 1355 { 1356 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1357 event->eventTypeId = AXIS_EVENT_ID; 1358 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1359 EXPECT_EQ(result, 0.0); 1360 } 1361 1362 /** 1363 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX008 1364 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1365 * @tc.type: FUNC 1366 */ 1367 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX008, TestSize.Level1) 1368 { 1369 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1370 event->eventTypeId = C_CLICK_EVENT_ID; 1371 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1372 EXPECT_EQ(result, 0.0); 1373 } 1374 1375 /** 1376 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX009 1377 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1378 * @tc.type: FUNC 1379 */ 1380 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX009, TestSize.Level1) 1381 { 1382 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1383 event->eventTypeId = C_HOVER_EVENT_ID; 1384 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1385 EXPECT_EQ(result, 0.0); 1386 } 1387 1388 /** 1389 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX0010 1390 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1391 * @tc.type: FUNC 1392 */ 1393 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX0010, TestSize.Level1) 1394 { 1395 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1396 event->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 1397 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1398 EXPECT_EQ(result, 0.0); 1399 } 1400 1401 /** 1402 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex001 1403 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1404 * @tc.type: FUNC 1405 */ 1406 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex001, TestSize.Level1) 1407 { 1408 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(nullptr, 0); 1409 EXPECT_EQ(result, 0); 1410 } 1411 1412 /** 1413 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex002 1414 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1415 * @tc.type: FUNC 1416 */ 1417 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex002, TestSize.Level1) 1418 { 1419 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1420 event->eventTypeId = C_TOUCH_EVENT_ID; 1421 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), -1); 1422 EXPECT_EQ(result, 0); 1423 } 1424 1425 /** 1426 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex003 1427 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1428 * @tc.type: FUNC 1429 */ 1430 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex003, TestSize.Level1) 1431 { 1432 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1433 event->eventTypeId = C_TOUCH_EVENT_ID; 1434 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1435 EXPECT_EQ(result, 0); 1436 } 1437 1438 /** 1439 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex004 1440 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1441 * @tc.type: FUNC 1442 */ 1443 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex004, TestSize.Level1) 1444 { 1445 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1446 event->eventTypeId = C_TOUCH_EVENT_ID; 1447 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1448 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), -2); 1449 EXPECT_EQ(result, 0); 1450 } 1451 1452 /** 1453 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex005 1454 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1455 * @tc.type: FUNC 1456 */ 1457 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex005, TestSize.Level1) 1458 { 1459 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1460 event->eventTypeId = C_TOUCH_EVENT_ID; 1461 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1462 ArkUITouchPoint touchPoint; 1463 touchPoint.pressedTime = 20; 1464 touchEvent->touchPointes = &touchPoint; 1465 touchEvent->touchPointSize = 2; 1466 event->inputEvent = touchEvent.get(); 1467 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1468 EXPECT_EQ(result, 20); 1469 } 1470 1471 /** 1472 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex006 1473 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1474 * @tc.type: FUNC 1475 */ 1476 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex006, TestSize.Level1) 1477 { 1478 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1479 event->eventTypeId = AXIS_EVENT_ID; 1480 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1481 EXPECT_EQ(result, 0); 1482 } 1483 1484 /** 1485 * @tc.name: OH_ArkUI_PointerEvent_GetTouchAreaWidth 1486 * @tc.desc: test OH_ArkUI_PointerEvent_GetTouchAreaWidth 1487 * @tc.type: FUNC 1488 */ 1489 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTouchAreaWidth, TestSize.Level1) 1490 { 1491 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1492 auto result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(nullptr, 0); 1493 EXPECT_EQ(result, 0); 1494 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1495 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1496 EXPECT_EQ(result, 0); 1497 1498 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1499 uiInputEvent->inputEvent = nullptr; 1500 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1501 EXPECT_EQ(result, 0); 1502 1503 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1504 touchEvent->touchPointSize = 0; 1505 uiInputEvent->inputEvent = touchEvent.get(); 1506 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1507 EXPECT_EQ(result, 0); 1508 1509 touchEvent->touchPointSize = 2; 1510 ArkUITouchPoint touchPointes[2]; 1511 touchPointes[1].contactAreaWidth = 1.0; 1512 touchEvent->touchPointes = touchPointes; 1513 uiInputEvent->inputEvent = touchEvent.get(); 1514 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1515 EXPECT_EQ(result, 1); 1516 } 1517 1518 /** 1519 * @tc.name: OH_ArkUI_PointerEvent_GetTouchAreaHeight 1520 * @tc.desc: test OH_ArkUI_PointerEvent_GetTouchAreaHeight 1521 * @tc.type: FUNC 1522 */ 1523 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTouchAreaHeight, TestSize.Level1) 1524 { 1525 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1526 auto result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(nullptr, 0); 1527 EXPECT_EQ(result, 0); 1528 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1529 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1530 EXPECT_EQ(result, 0); 1531 1532 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1533 uiInputEvent->inputEvent = nullptr; 1534 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1535 EXPECT_EQ(result, 0); 1536 1537 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1538 touchEvent->touchPointSize = 0; 1539 uiInputEvent->inputEvent = touchEvent.get(); 1540 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1541 EXPECT_EQ(result, 0); 1542 1543 touchEvent->touchPointSize = 2; 1544 ArkUITouchPoint touchPointes[2]; 1545 touchPointes[1].contactAreaHeight = 1.0; 1546 touchEvent->touchPointes = touchPointes; 1547 uiInputEvent->inputEvent = touchEvent.get(); 1548 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1549 EXPECT_EQ(result, 1); 1550 } 1551 1552 /** 1553 * @tc.name: OH_ArkUI_PointerEvent_GetChangedPointerId 1554 * @tc.desc: test OH_ArkUI_PointerEvent_GetChangedPointerId 1555 * @tc.type: FUNC 1556 */ 1557 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetChangedPointerId, TestSize.Level1) 1558 { 1559 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1560 auto result = OH_ArkUI_PointerEvent_GetChangedPointerId(nullptr, 0); 1561 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1562 1563 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1564 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1565 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1566 1567 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1568 uiInputEvent->inputEvent = nullptr; 1569 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1570 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1571 1572 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1573 touchEvent->touchPointSize = 0; 1574 uiInputEvent->inputEvent = touchEvent.get(); 1575 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1576 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1577 } 1578 1579 /** 1580 * @tc.name: OH_ArkUI_PointerEvent_GetHistorySize 1581 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistorySize 1582 * @tc.type: FUNC 1583 */ 1584 1585 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistorySize, TestSize.Level1) 1586 { 1587 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1588 auto result = OH_ArkUI_PointerEvent_GetHistorySize(nullptr); 1589 EXPECT_EQ(result, 0); 1590 1591 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1592 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1593 EXPECT_EQ(result, 0); 1594 1595 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1596 uiInputEvent->inputEvent = nullptr; 1597 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1598 EXPECT_EQ(result, 0); 1599 1600 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1601 ArkUIHistoryTouchEvent events[2]; 1602 touchEvent->historyEvents = events; 1603 touchEvent->historySize = 1; 1604 uiInputEvent->inputEvent = touchEvent.get(); 1605 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1606 EXPECT_EQ(result, 1); 1607 } 1608 1609 /** 1610 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryEventTime 1611 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryEventTime 1612 * @tc.type: FUNC 1613 */ 1614 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryEventTime, TestSize.Level1) 1615 { 1616 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1617 auto result = OH_ArkUI_PointerEvent_GetHistoryEventTime(nullptr, 0); 1618 EXPECT_EQ(result, 0); 1619 1620 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1621 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 0); 1622 EXPECT_EQ(result, 0); 1623 1624 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1625 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1626 ArkUIHistoryTouchEvent events[2]; 1627 events[1].timeStamp = 1; 1628 touchEvent->historyEvents = events; 1629 touchEvent->historySize = 2; 1630 uiInputEvent->inputEvent = touchEvent.get(); 1631 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1632 EXPECT_EQ(result, 1); 1633 1634 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), -1); 1635 EXPECT_EQ(result, 0); 1636 1637 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 10); 1638 EXPECT_EQ(result, 0); 1639 1640 touchEvent->historyEvents = nullptr; 1641 uiInputEvent->inputEvent = touchEvent.get(); 1642 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1643 EXPECT_EQ(result, 0); 1644 1645 uiInputEvent->inputEvent = nullptr; 1646 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1647 EXPECT_EQ(result, 0); 1648 } 1649 1650 /** 1651 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPointerCount 1652 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPointerCount 1653 * @tc.type: FUNC 1654 */ 1655 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPointerCount, TestSize.Level1) 1656 { 1657 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1658 auto result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(nullptr, 0); 1659 EXPECT_EQ(result, 0); 1660 1661 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1662 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 0); 1663 EXPECT_EQ(result, 0); 1664 1665 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1666 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1667 ArkUIHistoryTouchEvent events[2]; 1668 events[1].touchPointSize = 1; 1669 touchEvent->historyEvents = events; 1670 touchEvent->historySize = 2; 1671 uiInputEvent->inputEvent = touchEvent.get(); 1672 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1673 EXPECT_EQ(result, 1); 1674 1675 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), -1); 1676 EXPECT_EQ(result, 0); 1677 1678 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 10); 1679 EXPECT_EQ(result, 0); 1680 1681 touchEvent->historyEvents = nullptr; 1682 uiInputEvent->inputEvent = touchEvent.get(); 1683 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1684 EXPECT_EQ(result, 0); 1685 1686 uiInputEvent->inputEvent = nullptr; 1687 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1688 EXPECT_EQ(result, 0); 1689 } 1690 1691 /** 1692 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPointerId 1693 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPointerId 1694 * @tc.type: FUNC 1695 */ 1696 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPointerId, TestSize.Level1) 1697 { 1698 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1699 auto result = OH_ArkUI_PointerEvent_GetHistoryPointerId(nullptr, 0, 0); 1700 EXPECT_EQ(result, 0); 1701 1702 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1703 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 0, 0); 1704 EXPECT_EQ(result, 0); 1705 1706 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1707 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1708 ArkUIHistoryTouchEvent events[2]; 1709 ArkUITouchPoint pointes[2]; 1710 events[1].touchPointSize = 2; 1711 pointes[1].id = 20; 1712 events[1].touchPointes = pointes; 1713 touchEvent->historyEvents = events; 1714 touchEvent->historySize = 2; 1715 uiInputEvent->inputEvent = touchEvent.get(); 1716 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 1, 1); 1717 EXPECT_EQ(result, 20); 1718 1719 uiInputEvent->inputEvent = nullptr; 1720 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 1, 1); 1721 EXPECT_EQ(result, 0); 1722 } 1723 1724 /** 1725 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryX 1726 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryX 1727 * @tc.type: FUNC 1728 */ 1729 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryX, TestSize.Level1) 1730 { 1731 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1732 auto result = OH_ArkUI_PointerEvent_GetHistoryX(nullptr, 0, 0); 1733 EXPECT_EQ(result, 0); 1734 1735 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1736 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 0, 0); 1737 EXPECT_EQ(result, 0); 1738 1739 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1740 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1741 ArkUIHistoryTouchEvent events[2]; 1742 ArkUITouchPoint pointes[2]; 1743 events[1].touchPointSize = 2; 1744 pointes[1].nodeX = 20; 1745 events[1].touchPointes = pointes; 1746 touchEvent->historyEvents = events; 1747 touchEvent->historySize = 2; 1748 uiInputEvent->inputEvent = touchEvent.get(); 1749 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 1, 1); 1750 EXPECT_EQ(result, 20); 1751 1752 uiInputEvent->inputEvent = nullptr; 1753 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 1, 1); 1754 EXPECT_EQ(result, 0); 1755 } 1756 1757 /** 1758 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryY 1759 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryY 1760 * @tc.type: FUNC 1761 */ 1762 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryY, TestSize.Level1) 1763 { 1764 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1765 auto result = OH_ArkUI_PointerEvent_GetHistoryY(nullptr, 0, 0); 1766 EXPECT_EQ(result, 0); 1767 1768 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1769 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 0, 0); 1770 EXPECT_EQ(result, 0); 1771 1772 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1773 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1774 ArkUIHistoryTouchEvent events[2]; 1775 ArkUITouchPoint pointes[2]; 1776 events[1].touchPointSize = 2; 1777 pointes[1].nodeY = 20; 1778 events[1].touchPointes = pointes; 1779 touchEvent->historyEvents = events; 1780 touchEvent->historySize = 2; 1781 uiInputEvent->inputEvent = touchEvent.get(); 1782 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 1, 1); 1783 EXPECT_EQ(result, 20); 1784 1785 uiInputEvent->inputEvent = nullptr; 1786 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 1, 1); 1787 EXPECT_EQ(result, 0); 1788 } 1789 1790 /** 1791 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryWindowX 1792 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryWindowX 1793 * @tc.type: FUNC 1794 */ 1795 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryWindowX, TestSize.Level1) 1796 { 1797 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1798 auto result = OH_ArkUI_PointerEvent_GetHistoryWindowX(nullptr, 0, 0); 1799 EXPECT_EQ(result, 0); 1800 1801 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1802 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 0, 0); 1803 EXPECT_EQ(result, 0); 1804 1805 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1806 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1807 ArkUIHistoryTouchEvent events[2]; 1808 ArkUITouchPoint pointes[2]; 1809 events[1].touchPointSize = 2; 1810 pointes[1].windowX = 20; 1811 events[1].touchPointes = pointes; 1812 touchEvent->historyEvents = events; 1813 touchEvent->historySize = 2; 1814 uiInputEvent->inputEvent = touchEvent.get(); 1815 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 1, 1); 1816 EXPECT_EQ(result, 20); 1817 1818 uiInputEvent->inputEvent = nullptr; 1819 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 1, 1); 1820 EXPECT_EQ(result, 0); 1821 } 1822 1823 /** 1824 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryWindowY 1825 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryWindowY 1826 * @tc.type: FUNC 1827 */ 1828 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryWindowY, TestSize.Level1) 1829 { 1830 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1831 auto result = OH_ArkUI_PointerEvent_GetHistoryWindowY(nullptr, 0, 0); 1832 EXPECT_EQ(result, 0); 1833 1834 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1835 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 0, 0); 1836 EXPECT_EQ(result, 0); 1837 1838 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1839 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1840 ArkUIHistoryTouchEvent events[2]; 1841 ArkUITouchPoint pointes[2]; 1842 events[1].touchPointSize = 2; 1843 pointes[1].windowY = 20; 1844 events[1].touchPointes = pointes; 1845 touchEvent->historyEvents = events; 1846 touchEvent->historySize = 2; 1847 uiInputEvent->inputEvent = touchEvent.get(); 1848 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 1, 1); 1849 EXPECT_EQ(result, 20); 1850 1851 uiInputEvent->inputEvent = nullptr; 1852 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 1, 1); 1853 EXPECT_EQ(result, 0); 1854 } 1855 1856 /** 1857 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryDisplayX 1858 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryDisplayX 1859 * @tc.type: FUNC 1860 */ 1861 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryDisplayX, TestSize.Level1) 1862 { 1863 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1864 auto result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(nullptr, 0, 0); 1865 EXPECT_EQ(result, 0); 1866 1867 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1868 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 0, 0); 1869 EXPECT_EQ(result, 0); 1870 1871 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1872 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1873 ArkUIHistoryTouchEvent events[2]; 1874 ArkUITouchPoint pointes[2]; 1875 events[1].touchPointSize = 2; 1876 pointes[1].screenX = 20; 1877 events[1].touchPointes = pointes; 1878 touchEvent->historyEvents = events; 1879 touchEvent->historySize = 2; 1880 uiInputEvent->inputEvent = touchEvent.get(); 1881 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 1, 1); 1882 EXPECT_EQ(result, 20); 1883 1884 uiInputEvent->inputEvent = nullptr; 1885 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 1, 1); 1886 EXPECT_EQ(result, 0); 1887 } 1888 1889 /** 1890 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryDisplayY 1891 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryDisplayY 1892 * @tc.type: FUNC 1893 */ 1894 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryDisplayY, TestSize.Level1) 1895 { 1896 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1897 auto result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(nullptr, 0, 0); 1898 EXPECT_EQ(result, 0); 1899 1900 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1901 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 0, 0); 1902 EXPECT_EQ(result, 0); 1903 1904 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1905 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1906 ArkUIHistoryTouchEvent events[2]; 1907 ArkUITouchPoint pointes[2]; 1908 events[1].touchPointSize = 2; 1909 pointes[1].screenY = 20; 1910 events[1].touchPointes = pointes; 1911 touchEvent->historyEvents = events; 1912 touchEvent->historySize = 2; 1913 uiInputEvent->inputEvent = touchEvent.get(); 1914 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 1, 1); 1915 EXPECT_EQ(result, 20); 1916 1917 uiInputEvent->inputEvent = nullptr; 1918 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 1, 1); 1919 EXPECT_EQ(result, 0); 1920 } 1921 1922 /** 1923 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPressure 1924 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPressure 1925 * @tc.type: FUNC 1926 */ 1927 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPressure, TestSize.Level1) 1928 { 1929 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1930 auto result = OH_ArkUI_PointerEvent_GetHistoryPressure(nullptr, 0, 0); 1931 EXPECT_EQ(result, 0); 1932 1933 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1934 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 0, 0); 1935 EXPECT_EQ(result, 0); 1936 1937 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1938 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1939 ArkUIHistoryTouchEvent events[2]; 1940 ArkUITouchPoint pointes[2]; 1941 events[1].touchPointSize = 2; 1942 pointes[1].pressure = 20; 1943 events[1].touchPointes = pointes; 1944 touchEvent->historyEvents = events; 1945 touchEvent->historySize = 2; 1946 uiInputEvent->inputEvent = touchEvent.get(); 1947 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 1, 1); 1948 EXPECT_EQ(result, 20); 1949 1950 uiInputEvent->inputEvent = nullptr; 1951 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 1, 1); 1952 EXPECT_EQ(result, 0); 1953 } 1954 1955 /** 1956 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTiltX 1957 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTiltX 1958 * @tc.type: FUNC 1959 */ 1960 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTiltX, TestSize.Level1) 1961 { 1962 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1963 auto result = OH_ArkUI_PointerEvent_GetHistoryTiltX(nullptr, 0, 0); 1964 EXPECT_EQ(result, 0); 1965 1966 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1967 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 0, 0); 1968 EXPECT_EQ(result, 0); 1969 1970 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1971 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1972 ArkUIHistoryTouchEvent events[2]; 1973 ArkUITouchPoint pointes[2]; 1974 events[1].touchPointSize = 2; 1975 pointes[1].tiltX = 20; 1976 events[1].touchPointes = pointes; 1977 touchEvent->historyEvents = events; 1978 touchEvent->historySize = 2; 1979 uiInputEvent->inputEvent = touchEvent.get(); 1980 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 1, 1); 1981 EXPECT_EQ(result, 20); 1982 1983 uiInputEvent->inputEvent = nullptr; 1984 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 1, 1); 1985 EXPECT_EQ(result, 0); 1986 } 1987 1988 /** 1989 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTiltY 1990 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTiltY 1991 * @tc.type: FUNC 1992 */ 1993 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTiltY, TestSize.Level1) 1994 { 1995 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1996 auto result = OH_ArkUI_PointerEvent_GetHistoryTiltY(nullptr, 0, 0); 1997 EXPECT_EQ(result, 0); 1998 1999 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2000 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 0, 0); 2001 EXPECT_EQ(result, 0); 2002 2003 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2004 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2005 ArkUIHistoryTouchEvent events[2]; 2006 ArkUITouchPoint pointes[2]; 2007 events[1].touchPointSize = 2; 2008 pointes[1].tiltY = 20; 2009 events[1].touchPointes = pointes; 2010 touchEvent->historyEvents = events; 2011 touchEvent->historySize = 2; 2012 uiInputEvent->inputEvent = touchEvent.get(); 2013 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 1, 1); 2014 EXPECT_EQ(result, 20); 2015 2016 uiInputEvent->inputEvent = nullptr; 2017 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 1, 1); 2018 EXPECT_EQ(result, 0); 2019 } 2020 2021 /** 2022 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth 2023 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth 2024 * @tc.type: FUNC 2025 */ 2026 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth, TestSize.Level1) 2027 { 2028 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2029 auto result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(nullptr, 0, 0); 2030 EXPECT_EQ(result, 0); 2031 2032 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2033 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 0, 0); 2034 EXPECT_EQ(result, 0); 2035 2036 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2037 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2038 ArkUIHistoryTouchEvent events[2]; 2039 ArkUITouchPoint pointes[2]; 2040 events[1].touchPointSize = 2; 2041 pointes[1].contactAreaWidth = 20; 2042 events[1].touchPointes = pointes; 2043 touchEvent->historyEvents = events; 2044 touchEvent->historySize = 2; 2045 uiInputEvent->inputEvent = touchEvent.get(); 2046 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 1, 1); 2047 EXPECT_EQ(result, 20); 2048 2049 uiInputEvent->inputEvent = nullptr; 2050 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 1, 1); 2051 EXPECT_EQ(result, 0); 2052 } 2053 2054 /** 2055 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight 2056 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight 2057 * @tc.type: FUNC 2058 */ 2059 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight, TestSize.Level1) 2060 { 2061 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2062 auto result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(nullptr, 0, 0); 2063 EXPECT_EQ(result, 0); 2064 2065 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2066 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 0, 0); 2067 EXPECT_EQ(result, 0); 2068 2069 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2070 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2071 ArkUIHistoryTouchEvent events[2]; 2072 ArkUITouchPoint pointes[2]; 2073 events[1].touchPointSize = 2; 2074 pointes[1].contactAreaHeight = 20; 2075 events[1].touchPointes = pointes; 2076 touchEvent->historyEvents = events; 2077 touchEvent->historySize = 2; 2078 uiInputEvent->inputEvent = touchEvent.get(); 2079 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 1, 1); 2080 EXPECT_EQ(result, 20); 2081 2082 uiInputEvent->inputEvent = nullptr; 2083 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 1, 1); 2084 EXPECT_EQ(result, 0); 2085 } 2086 2087 /** 2088 * @tc.name: OH_ArkUI_AxisEvent_GetVerticalAxisValue 2089 * @tc.desc: test OH_ArkUI_AxisEvent_GetVerticalAxisValue 2090 * @tc.type: FUNC 2091 */ 2092 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetVerticalAxisValue, TestSize.Level1) 2093 { 2094 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2095 auto result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(nullptr); 2096 EXPECT_EQ(result, 0.0); 2097 2098 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2099 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2100 EXPECT_EQ(result, 0.0); 2101 2102 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2103 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 2104 axisEvent->verticalAxis = 1.1; 2105 uiInputEvent->inputEvent = nullptr; 2106 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2107 EXPECT_EQ(result, 0.0); 2108 2109 uiInputEvent->inputEvent = axisEvent.get(); 2110 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2111 EXPECT_EQ(result, 1.1); 2112 2113 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2114 2115 uiInputEvent->inputEvent = nullptr; 2116 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2117 EXPECT_EQ(result, 0.0); 2118 2119 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 2120 cAxisEvent->verticalAxis = 1.1; 2121 uiInputEvent->inputEvent = cAxisEvent.get(); 2122 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2123 EXPECT_EQ(result, 1.1); 2124 } 2125 2126 /** 2127 * @tc.name: OH_ArkUI_AxisEvent_GetHorizontalAxisValue 2128 * @tc.desc: test OH_ArkUI_AxisEvent_GetHorizontalAxisValue 2129 * @tc.type: FUNC 2130 */ 2131 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetHorizontalAxisValue, TestSize.Level1) 2132 { 2133 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2134 auto result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(nullptr); 2135 EXPECT_EQ(result, 0.0); 2136 2137 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2138 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 2139 EXPECT_EQ(result, 0.0); 2140 2141 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2142 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 2143 axisEvent->horizontalAxis = 1.1; 2144 uiInputEvent->inputEvent = nullptr; 2145 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 2146 EXPECT_EQ(result, 0.0); 2147 2148 uiInputEvent->inputEvent = axisEvent.get(); 2149 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 2150 EXPECT_EQ(result, 1.1); 2151 2152 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2153 uiInputEvent->inputEvent = nullptr; 2154 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 2155 EXPECT_EQ(result, 0.0); 2156 2157 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 2158 cAxisEvent->verticalAxis = 1.1; 2159 uiInputEvent->inputEvent = cAxisEvent.get(); 2160 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 2161 EXPECT_EQ(result, 1.1); 2162 } 2163 2164 /** 2165 * @tc.name: OH_ArkUI_AxisEvent_GetPinchAxisScaleValue 2166 * @tc.desc: test OH_ArkUI_AxisEvent_GetPinchAxisScaleValue 2167 * @tc.type: FUNC 2168 */ 2169 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetPinchAxisScaleValue, TestSize.Level1) 2170 { 2171 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2172 auto result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(nullptr); 2173 EXPECT_EQ(result, 0.0); 2174 2175 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2176 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 2177 EXPECT_EQ(result, 0.0); 2178 2179 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2180 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 2181 axisEvent->pinchAxisScale = 1.1; 2182 uiInputEvent->inputEvent = nullptr; 2183 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 2184 EXPECT_EQ(result, 0.0); 2185 2186 uiInputEvent->inputEvent = axisEvent.get(); 2187 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 2188 EXPECT_EQ(result, 1.1); 2189 2190 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2191 uiInputEvent->inputEvent = nullptr; 2192 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 2193 EXPECT_EQ(result, 0.0); 2194 2195 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 2196 cAxisEvent->pinchAxisScale = 1.1; 2197 uiInputEvent->inputEvent = cAxisEvent.get(); 2198 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 2199 EXPECT_EQ(result, 1.1); 2200 } 2201 2202 /** 2203 * @tc.name: OH_ArkUI_PointerEvent_SetInterceptHitTestMode 2204 * @tc.desc: test OH_ArkUI_PointerEvent_SetInterceptHitTestMode 2205 * @tc.type: FUNC 2206 */ 2207 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetInterceptHitTestMode, TestSize.Level1) 2208 { 2209 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2210 auto mode = HTM_TRANSPARENT; 2211 auto result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(nullptr, mode); 2212 int32_t ERROR_CODE_PARAM_INVALID = 401; 2213 int32_t ERROR_CODE_NO_ERROR = 0; 2214 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 2215 2216 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2217 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2218 touchEvent->interceptResult = 0; 2219 uiInputEvent->inputEvent = touchEvent.get(); 2220 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 2221 EXPECT_EQ(touchEvent->interceptResult, static_cast<int32_t>(HTM_TRANSPARENT)); 2222 EXPECT_EQ(result, ERROR_CODE_NO_ERROR); 2223 2224 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2225 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2226 mouseEvent->interceptResult = 0; 2227 uiInputEvent->inputEvent = nullptr; 2228 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 2229 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 2230 2231 uiInputEvent->inputEvent = mouseEvent.get(); 2232 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 2233 EXPECT_EQ(touchEvent->interceptResult, static_cast<int32_t>(HTM_TRANSPARENT)); 2234 2235 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2236 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 2237 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 2238 } 2239 2240 /** 2241 * @tc.name: OH_ArkUI_PointerEvent_SetStopPropagation 2242 * @tc.desc: test OH_ArkUI_PointerEvent_SetStopPropagation 2243 * @tc.type: FUNC 2244 */ 2245 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetStopPropagation, TestSize.Level1) 2246 { 2247 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2248 auto stopPropagation = true; 2249 auto result = OH_ArkUI_PointerEvent_SetStopPropagation(nullptr, true); 2250 int32_t ERROR_CODE_PARAM_INVALID = 401; 2251 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 2252 2253 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2254 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2255 touchEvent->stopPropagation = false; 2256 uiInputEvent->inputEvent = touchEvent.get(); 2257 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 2258 EXPECT_EQ(touchEvent->stopPropagation, stopPropagation); 2259 2260 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2261 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2262 mouseEvent->stopPropagation = false; 2263 uiInputEvent->inputEvent = mouseEvent.get(); 2264 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 2265 EXPECT_EQ(mouseEvent->stopPropagation, stopPropagation); 2266 2267 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 2268 auto hoverEvent = std::make_unique<ArkUIHoverEvent>(); 2269 hoverEvent->stopPropagation = false; 2270 uiInputEvent->inputEvent = hoverEvent.get(); 2271 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 2272 EXPECT_EQ(hoverEvent->stopPropagation, stopPropagation); 2273 2274 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2275 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 2276 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 2277 } 2278 2279 /** 2280 * @tc.name: OH_ArkUI_MouseEvent_GetMouseButton 2281 * @tc.desc: test OH_ArkUI_MouseEvent_GetMouseButton 2282 * @tc.type: FUNC 2283 */ 2284 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetMouseButton, TestSize.Level1) 2285 { 2286 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2287 auto result = OH_ArkUI_MouseEvent_GetMouseButton(nullptr); 2288 EXPECT_EQ(result, -1); 2289 2290 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2291 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 2292 EXPECT_EQ(result, -1); 2293 2294 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2295 mouseEvent->button = 2; 2296 uiInputEvent->inputEvent = mouseEvent.get(); 2297 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 2298 EXPECT_EQ(result, 2); 2299 2300 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2301 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 2302 EXPECT_EQ(result, -1); 2303 } 2304 2305 /** 2306 * @tc.name: OH_ArkUI_MouseEvent_GetMouseAction 2307 * @tc.desc: test OH_ArkUI_MouseEvent_GetMouseAction 2308 * @tc.type: FUNC 2309 */ 2310 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetMouseAction, TestSize.Level1) 2311 { 2312 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2313 auto result = OH_ArkUI_MouseEvent_GetMouseAction(nullptr); 2314 EXPECT_EQ(result, -1); 2315 2316 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2317 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 2318 EXPECT_EQ(result, -1); 2319 2320 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2321 mouseEvent->action = 2; 2322 uiInputEvent->inputEvent = mouseEvent.get(); 2323 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 2324 EXPECT_EQ(result, 2); 2325 2326 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2327 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 2328 EXPECT_EQ(result, -1); 2329 } 2330 2331 /** 2332 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex 2333 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 2334 * @tc.type: FUNC 2335 */ 2336 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex, TestSize.Level1) 2337 { 2338 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2339 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(nullptr, 0); 2340 EXPECT_EQ(result, 0); 2341 2342 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2343 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 0); 2344 EXPECT_EQ(result, 0); 2345 2346 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2347 touchEvent->touchPointSize = 2; 2348 ArkUITouchPoint touchPointes[2]; 2349 touchPointes[1].pressedTime = 1; 2350 touchEvent->touchPointes = touchPointes; 2351 uiInputEvent->inputEvent = touchEvent.get(); 2352 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 1); 2353 EXPECT_EQ(result, 1); 2354 2355 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2356 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 1); 2357 EXPECT_EQ(result, 0); 2358 } 2359 2360 /** 2361 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX 2362 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 2363 * @tc.type: FUNC 2364 */ 2365 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX, TestSize.Level1) 2366 { 2367 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2368 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(nullptr); 2369 EXPECT_EQ(result, 0.0f); 2370 2371 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2372 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 2373 EXPECT_EQ(result, 0.0f); 2374 2375 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2376 mouseEvent->rawDeltaX = 2.0f; 2377 uiInputEvent->inputEvent = mouseEvent.get(); 2378 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 2379 EXPECT_EQ(result, 2.0f); 2380 2381 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2382 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 2383 EXPECT_EQ(result, 0.0f); 2384 } 2385 2386 /** 2387 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY 2388 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 2389 * @tc.type: FUNC 2390 */ 2391 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY, TestSize.Level1) 2392 { 2393 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2394 auto result = OH_ArkUI_MouseEvent_GetRawDeltaY(nullptr); 2395 EXPECT_EQ(result, 0.0f); 2396 2397 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2398 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2399 EXPECT_EQ(result, 0.0f); 2400 2401 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2402 mouseEvent->rawDeltaY = 2.0f; 2403 uiInputEvent->inputEvent = mouseEvent.get(); 2404 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2405 EXPECT_EQ(result, 2.0f); 2406 2407 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2408 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2409 EXPECT_EQ(result, 0.0f); 2410 } 2411 2412 /** 2413 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId 2414 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 2415 * @tc.type: FUNC 2416 */ 2417 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId, TestSize.Level1) 2418 { 2419 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2420 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(nullptr); 2421 EXPECT_EQ(result, 0); 2422 2423 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2424 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2425 mouseEvent->targetDisplayId = 1; 2426 uiInputEvent->inputEvent = mouseEvent.get(); 2427 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2428 EXPECT_EQ(result, 1); 2429 2430 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2431 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2432 touchEvent->targetDisplayId = 2; 2433 uiInputEvent->inputEvent = touchEvent.get(); 2434 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2435 EXPECT_EQ(result, 2); 2436 2437 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2438 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 2439 axisEvent->targetDisplayId = 3; 2440 uiInputEvent->inputEvent = axisEvent.get(); 2441 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2442 EXPECT_EQ(result, 3); 2443 2444 uiInputEvent->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2445 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 2446 focusAxisEvent->targetDisplayId = 4; 2447 uiInputEvent->inputEvent = focusAxisEvent.get(); 2448 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2449 EXPECT_EQ(result, 4); 2450 2451 uiInputEvent->eventTypeId = TOUCH_EVENT_ID; 2452 auto ohosTouchEvent = std::make_unique<OHOS::Ace::TouchEvent>(); 2453 ohosTouchEvent->targetDisplayId = 5; 2454 uiInputEvent->inputEvent = ohosTouchEvent.get(); 2455 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2456 EXPECT_EQ(result, 5); 2457 2458 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2459 auto ohosAxisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 2460 ohosAxisEvent->targetDisplayId = 6; 2461 uiInputEvent->inputEvent = ohosAxisEvent.get(); 2462 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2463 EXPECT_EQ(result, 6); 2464 2465 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 2466 auto ohosHoverEvent = std::make_unique<ArkUIHoverEvent>(); 2467 ohosHoverEvent->targetDisplayId = 7; 2468 uiInputEvent->inputEvent = ohosHoverEvent.get(); 2469 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2470 EXPECT_EQ(result, 7); 2471 } 2472 2473 /** 2474 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId008 2475 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 2476 * @tc.type: FUNC 2477 */ 2478 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId008, TestSize.Level1) 2479 { 2480 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2481 uiInputEvent->eventTypeId = C_CLICK_EVENT_ID; 2482 auto ohosClickEvent = std::make_unique<ArkUIClickEvent>(); 2483 ohosClickEvent->targetDisplayId = 8; 2484 uiInputEvent->inputEvent = ohosClickEvent.get(); 2485 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2486 EXPECT_EQ(result, 8); 2487 2488 uiInputEvent->eventTypeId = C_KEY_EVENT_ID; 2489 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2490 EXPECT_EQ(result, 0); 2491 } 2492 2493 /** 2494 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons 2495 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 2496 * @tc.type: FUNC 2497 */ 2498 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetPressedButtons, TestSize.Level1) 2499 { 2500 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2501 int32_t pressedButtons[1] = { 0 }; 2502 int32_t length = 1; 2503 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2504 uiInputEvent->inputEvent = nullptr; 2505 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2506 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2507 2508 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2509 mouseEvent->pressedButtonsLength = 2; 2510 uiInputEvent->inputEvent = mouseEvent.get(); 2511 2512 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2513 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2514 EXPECT_EQ(result, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 2515 2516 mouseEvent->pressedButtonsLength = 1; 2517 ArkUI_Int32 mousePressedButtons[1] = { 3 }; 2518 mouseEvent->pressedButtons = mousePressedButtons; 2519 uiInputEvent->inputEvent = mouseEvent.get(); 2520 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2521 EXPECT_EQ(pressedButtons[0], 3); 2522 2523 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2524 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2525 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2526 2527 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, nullptr); 2528 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2529 2530 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), nullptr, nullptr); 2531 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2532 2533 result = OH_ArkUI_MouseEvent_GetPressedButtons(nullptr, nullptr, nullptr); 2534 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2535 } 2536 2537 /** 2538 * @tc.name: OH_ArkUI_FocusAxisEvent_GetAxisValue 2539 * @tc.desc: test OH_ArkUI_FocusAxisEvent_GetAxisValue 2540 * @tc.type: FUNC 2541 */ 2542 HWTEST_F(UIInputEventTest, OH_ArkUI_FocusAxisEvent_GetAxisValue, TestSize.Level1) 2543 { 2544 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2545 int32_t axis = 100; 2546 auto result = OH_ArkUI_FocusAxisEvent_GetAxisValue(nullptr, axis); 2547 EXPECT_EQ(result, 0.0); 2548 2549 uiInputEvent->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2550 result = OH_ArkUI_FocusAxisEvent_GetAxisValue(nullptr, axis); 2551 EXPECT_EQ(result, 0.0); 2552 2553 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 2554 uiInputEvent->inputEvent = focusAxisEvent.get(); 2555 EXPECT_EQ(result, 0.0); 2556 } 2557 2558 /** 2559 * @tc.name: OH_ArkUI_FocusAxisEvent_SetStopPropagation 2560 * @tc.desc: Test function OH_ArkUI_FocusAxisEvent_SetStopPropagation. 2561 * @tc.type: FUNC 2562 */ 2563 HWTEST_F(UIInputEventTest, OH_ArkUI_FocusAxisEvent_SetStopPropagation, TestSize.Level1) 2564 { 2565 int32_t ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(nullptr, true); 2566 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 2567 2568 ArkUI_UIInputEvent event; 2569 event.eventTypeId = C_TOUCH_EVENT_ID; 2570 ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(&event, true); 2571 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 2572 2573 ArkUIFocusAxisEvent focusAxisEvent; 2574 focusAxisEvent.stopPropagation = false; 2575 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2576 event.inputEvent = &focusAxisEvent; 2577 ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(&event, true); 2578 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 2579 EXPECT_TRUE(focusAxisEvent.stopPropagation); 2580 } 2581 2582 /** 2583 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetWidth001 2584 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetWidth. 2585 * @tc.type: FUNC 2586 */ 2587 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetWidth001, TestSize.Level1) 2588 { 2589 float width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(nullptr); 2590 EXPECT_EQ(width, 0.0f); 2591 ArkUI_UIInputEvent event; 2592 2593 ArkUITouchEvent touchEvent; 2594 touchEvent.width = 10.0f; 2595 event.eventTypeId = C_TOUCH_EVENT_ID; 2596 event.inputEvent = nullptr; 2597 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2598 EXPECT_EQ(width, 0.0f); 2599 event.inputEvent = &touchEvent; 2600 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2601 EXPECT_EQ(width, 10.0f); 2602 2603 OHOS::Ace::TouchEvent aceTouchEvent; 2604 aceTouchEvent.width = 20.0f; 2605 event.eventTypeId = TOUCH_EVENT_ID; 2606 event.inputEvent = nullptr; 2607 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2608 EXPECT_EQ(width, 0.0f); 2609 event.inputEvent = &aceTouchEvent; 2610 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2611 EXPECT_EQ(width, 20.0f); 2612 2613 OHOS::Ace::AxisEvent aceAxisEvent; 2614 aceAxisEvent.width = 30.0f; 2615 event.eventTypeId = AXIS_EVENT_ID; 2616 event.inputEvent = nullptr; 2617 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2618 EXPECT_EQ(width, 0.0f); 2619 event.inputEvent = &aceAxisEvent; 2620 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2621 EXPECT_EQ(width, 30.0f); 2622 2623 ArkUIMouseEvent mouseEvent; 2624 mouseEvent.width = 40.0f; 2625 event.eventTypeId = C_MOUSE_EVENT_ID; 2626 event.inputEvent = nullptr; 2627 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2628 EXPECT_EQ(width, 0.0f); 2629 event.inputEvent = &mouseEvent; 2630 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2631 EXPECT_EQ(width, 40.0f); 2632 } 2633 2634 /** 2635 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetWidth002 2636 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetWidth. 2637 * @tc.type: FUNC 2638 */ 2639 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetWidth002, TestSize.Level1) 2640 { 2641 float width = 1.0f; 2642 ArkUI_UIInputEvent event; 2643 2644 ArkUIAxisEvent axisEvent; 2645 axisEvent.width = 50.0f; 2646 event.eventTypeId = C_AXIS_EVENT_ID; 2647 event.inputEvent = nullptr; 2648 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2649 EXPECT_EQ(width, 0.0f); 2650 event.inputEvent = &axisEvent; 2651 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2652 EXPECT_EQ(width, 50.0f); 2653 2654 ArkUIFocusAxisEvent focusAxisEvent; 2655 focusAxisEvent.width = 60.0f; 2656 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2657 event.inputEvent = nullptr; 2658 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2659 EXPECT_EQ(width, 0.0f); 2660 event.inputEvent = &focusAxisEvent; 2661 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2662 EXPECT_EQ(width, 60.0f); 2663 2664 ArkUIHoverEvent hoverEvent; 2665 hoverEvent.width = 70.0f; 2666 event.eventTypeId = C_HOVER_EVENT_ID; 2667 event.inputEvent = nullptr; 2668 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2669 EXPECT_EQ(width, 0.0f); 2670 event.inputEvent = &hoverEvent; 2671 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2672 EXPECT_EQ(width, 70.0f); 2673 2674 ArkUIClickEvent clickEvent; 2675 clickEvent.width = 80.0f; 2676 event.eventTypeId = C_CLICK_EVENT_ID; 2677 event.inputEvent = nullptr; 2678 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2679 EXPECT_EQ(width, 0.0f); 2680 event.inputEvent = &clickEvent; 2681 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2682 EXPECT_EQ(width, 80.0f); 2683 } 2684 2685 /** 2686 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetHeight001 2687 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetHeight. 2688 * @tc.type: FUNC 2689 */ 2690 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetHeight001, TestSize.Level1) 2691 { 2692 float height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(nullptr); 2693 EXPECT_EQ(height, 0.0f); 2694 2695 ArkUI_UIInputEvent event; 2696 2697 ArkUITouchEvent touchEvent; 2698 touchEvent.height = 15.0f; 2699 event.eventTypeId = C_TOUCH_EVENT_ID; 2700 event.inputEvent = nullptr; 2701 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2702 EXPECT_EQ(height, 0.0f); 2703 event.inputEvent = &touchEvent; 2704 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2705 EXPECT_EQ(height, 15.0f); 2706 2707 OHOS::Ace::TouchEvent aceTouchEvent; 2708 aceTouchEvent.height = 25.0f; 2709 event.eventTypeId = TOUCH_EVENT_ID; 2710 event.inputEvent = nullptr; 2711 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2712 EXPECT_EQ(height, 0.0f); 2713 event.inputEvent = &aceTouchEvent; 2714 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2715 EXPECT_EQ(height, 25.0f); 2716 2717 OHOS::Ace::AxisEvent aceAxisEvent; 2718 aceAxisEvent.height = 35.0f; 2719 event.eventTypeId = AXIS_EVENT_ID; 2720 event.inputEvent = nullptr; 2721 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2722 EXPECT_EQ(height, 0.0f); 2723 event.inputEvent = &aceAxisEvent; 2724 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2725 EXPECT_EQ(height, 35.0f); 2726 2727 ArkUIMouseEvent mouseEvent; 2728 mouseEvent.height = 45.0f; 2729 event.eventTypeId = C_MOUSE_EVENT_ID; 2730 event.inputEvent = nullptr; 2731 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2732 EXPECT_EQ(height, 0.0f); 2733 event.inputEvent = &mouseEvent; 2734 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2735 EXPECT_EQ(height, 45.0f); 2736 } 2737 2738 /** 2739 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetHeight002 2740 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetHeight. 2741 * @tc.type: FUNC 2742 */ 2743 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetHeight002, TestSize.Level1) 2744 { 2745 float height = 1.0f; 2746 ArkUI_UIInputEvent event; 2747 ArkUIAxisEvent axisEvent; 2748 axisEvent.height = 55.0f; 2749 event.eventTypeId = C_AXIS_EVENT_ID; 2750 event.inputEvent = nullptr; 2751 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2752 EXPECT_EQ(height, 0.0f); 2753 event.inputEvent = &axisEvent; 2754 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2755 EXPECT_EQ(height, 55.0f); 2756 2757 ArkUIFocusAxisEvent focusAxisEvent; 2758 focusAxisEvent.height = 65.0f; 2759 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2760 event.inputEvent = nullptr; 2761 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2762 EXPECT_EQ(height, 0.0f); 2763 event.inputEvent = &focusAxisEvent; 2764 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2765 EXPECT_EQ(height, 65.0f); 2766 2767 ArkUIHoverEvent hoverEvent; 2768 hoverEvent.height = 75.0f; 2769 event.eventTypeId = C_HOVER_EVENT_ID; 2770 event.inputEvent = nullptr; 2771 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2772 EXPECT_EQ(height, 0.0f); 2773 event.inputEvent = &hoverEvent; 2774 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2775 EXPECT_EQ(height, 75.0f); 2776 2777 ArkUIClickEvent clickEvent; 2778 clickEvent.height = 85.0f; 2779 event.eventTypeId = C_CLICK_EVENT_ID; 2780 event.inputEvent = nullptr; 2781 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2782 EXPECT_EQ(height, 0.0f); 2783 event.inputEvent = &clickEvent; 2784 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2785 EXPECT_EQ(height, 85.0f); 2786 } 2787 2788 /** 2789 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionX001 2790 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionX. 2791 * @tc.type: FUNC 2792 */ 2793 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionX001, TestSize.Level1) 2794 { 2795 float positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(nullptr); 2796 EXPECT_EQ(positionX, 0.0f); 2797 2798 ArkUI_UIInputEvent event; 2799 2800 ArkUITouchEvent touchEvent; 2801 touchEvent.targetPositionX = 100.5f; 2802 event.eventTypeId = C_TOUCH_EVENT_ID; 2803 event.inputEvent = nullptr; 2804 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2805 EXPECT_EQ(positionX, 0.0f); 2806 event.inputEvent = &touchEvent; 2807 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2808 EXPECT_EQ(positionX, 100.5f); 2809 2810 OHOS::Ace::TouchEvent aceTouchEvent; 2811 aceTouchEvent.targetPositionX = 200.5f; 2812 event.eventTypeId = TOUCH_EVENT_ID; 2813 event.inputEvent = nullptr; 2814 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2815 EXPECT_EQ(positionX, 0.0f); 2816 event.inputEvent = &aceTouchEvent; 2817 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2818 EXPECT_EQ(positionX, 200.5f); 2819 2820 OHOS::Ace::AxisEvent aceAxisEvent; 2821 aceAxisEvent.targetPositionX = 300.5f; 2822 event.eventTypeId = AXIS_EVENT_ID; 2823 event.inputEvent = nullptr; 2824 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2825 EXPECT_EQ(positionX, 0.0f); 2826 event.inputEvent = &aceAxisEvent; 2827 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2828 EXPECT_EQ(positionX, 300.5f); 2829 2830 ArkUIMouseEvent mouseEvent; 2831 mouseEvent.targetPositionX = 400.5f; 2832 event.eventTypeId = C_MOUSE_EVENT_ID; 2833 event.inputEvent = nullptr; 2834 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2835 EXPECT_EQ(positionX, 0.0f); 2836 event.inputEvent = &mouseEvent; 2837 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2838 EXPECT_EQ(positionX, 400.5f); 2839 } 2840 2841 /** 2842 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionX002 2843 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionX. 2844 * @tc.type: FUNC 2845 */ 2846 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionX002, TestSize.Level1) 2847 { 2848 float positionX = 1.0f; 2849 ArkUI_UIInputEvent event; 2850 2851 ArkUIAxisEvent axisEvent; 2852 axisEvent.targetPositionX = 500.5f; 2853 event.eventTypeId = C_AXIS_EVENT_ID; 2854 event.inputEvent = nullptr; 2855 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2856 EXPECT_EQ(positionX, 0.0f); 2857 event.inputEvent = &axisEvent; 2858 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2859 EXPECT_EQ(positionX, 500.5f); 2860 2861 ArkUIFocusAxisEvent focusAxisEvent; 2862 focusAxisEvent.targetPositionX = 600.5f; 2863 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2864 event.inputEvent = nullptr; 2865 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2866 EXPECT_EQ(positionX, 0.0f); 2867 event.inputEvent = &focusAxisEvent; 2868 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2869 EXPECT_EQ(positionX, 600.5f); 2870 2871 ArkUIHoverEvent hoverEvent; 2872 hoverEvent.targetPositionX = 700.5f; 2873 event.eventTypeId = C_HOVER_EVENT_ID; 2874 event.inputEvent = nullptr; 2875 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2876 EXPECT_EQ(positionX, 0.0f); 2877 event.inputEvent = &hoverEvent; 2878 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2879 EXPECT_EQ(positionX, 700.5f); 2880 2881 ArkUIClickEvent clickEvent; 2882 clickEvent.targetPositionX = 800.5f; 2883 event.eventTypeId = C_CLICK_EVENT_ID; 2884 event.inputEvent = nullptr; 2885 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2886 EXPECT_EQ(positionX, 0.0f); 2887 event.inputEvent = &clickEvent; 2888 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2889 EXPECT_EQ(positionX, 800.5f); 2890 } 2891 2892 /** 2893 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionY001 2894 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionY. 2895 * @tc.type: FUNC 2896 */ 2897 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionY001, TestSize.Level1) 2898 { 2899 float positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(nullptr); 2900 EXPECT_EQ(positionY, 0.0f); 2901 2902 ArkUI_UIInputEvent event; 2903 2904 ArkUITouchEvent touchEvent; 2905 touchEvent.targetPositionY = 150.5f; 2906 event.eventTypeId = C_TOUCH_EVENT_ID; 2907 event.inputEvent = nullptr; 2908 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2909 EXPECT_EQ(positionY, 0.0f); 2910 event.inputEvent = &touchEvent; 2911 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2912 EXPECT_EQ(positionY, 150.5f); 2913 2914 OHOS::Ace::TouchEvent aceTouchEvent; 2915 aceTouchEvent.targetPositionY = 250.5f; 2916 event.eventTypeId = TOUCH_EVENT_ID; 2917 event.inputEvent = nullptr; 2918 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2919 EXPECT_EQ(positionY, 0.0f); 2920 event.inputEvent = &aceTouchEvent; 2921 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2922 EXPECT_EQ(positionY, 250.5f); 2923 2924 OHOS::Ace::AxisEvent aceAxisEvent; 2925 aceAxisEvent.targetPositionY = 350.5f; 2926 event.eventTypeId = AXIS_EVENT_ID; 2927 event.inputEvent = nullptr; 2928 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2929 EXPECT_EQ(positionY, 0.0f); 2930 event.inputEvent = &aceAxisEvent; 2931 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2932 EXPECT_EQ(positionY, 350.5f); 2933 2934 ArkUIMouseEvent mouseEvent; 2935 mouseEvent.targetPositionY = 450.5f; 2936 event.eventTypeId = C_MOUSE_EVENT_ID; 2937 event.inputEvent = nullptr; 2938 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2939 EXPECT_EQ(positionY, 0.0f); 2940 event.inputEvent = &mouseEvent; 2941 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2942 EXPECT_EQ(positionY, 450.5f); 2943 } 2944 2945 /** 2946 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionY002 2947 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionY. 2948 * @tc.type: FUNC 2949 */ 2950 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionY002, TestSize.Level1) 2951 { 2952 float positionY = 1.0f; 2953 ArkUI_UIInputEvent event; 2954 2955 ArkUIAxisEvent axisEvent; 2956 axisEvent.targetPositionY = 550.5f; 2957 event.eventTypeId = C_AXIS_EVENT_ID; 2958 event.inputEvent = nullptr; 2959 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2960 EXPECT_EQ(positionY, 0.0f); 2961 event.inputEvent = &axisEvent; 2962 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2963 EXPECT_EQ(positionY, 550.5f); 2964 2965 ArkUIFocusAxisEvent focusAxisEvent; 2966 focusAxisEvent.targetPositionY = 650.5f; 2967 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2968 event.inputEvent = nullptr; 2969 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2970 EXPECT_EQ(positionY, 0.0f); 2971 event.inputEvent = &focusAxisEvent; 2972 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2973 EXPECT_EQ(positionY, 650.5f); 2974 2975 ArkUIHoverEvent hoverEvent; 2976 hoverEvent.targetPositionY = 750.5f; 2977 event.eventTypeId = C_HOVER_EVENT_ID; 2978 event.inputEvent = nullptr; 2979 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2980 EXPECT_EQ(positionY, 0.0f); 2981 event.inputEvent = &hoverEvent; 2982 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2983 EXPECT_EQ(positionY, 750.5f); 2984 2985 ArkUIClickEvent clickEvent; 2986 clickEvent.targetPositionY = 850.5f; 2987 event.eventTypeId = C_CLICK_EVENT_ID; 2988 event.inputEvent = nullptr; 2989 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2990 EXPECT_EQ(positionY, 0.0f); 2991 event.inputEvent = &clickEvent; 2992 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2993 EXPECT_EQ(positionY, 850.5f); 2994 } 2995 2996 /** 2997 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX001 2998 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX 2999 * @tc.type: FUNC 3000 */ 3001 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX001, TestSize.Level1) 3002 { 3003 float positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(nullptr); 3004 EXPECT_EQ(positionX, 0.0f); 3005 3006 ArkUI_UIInputEvent event; 3007 3008 ArkUITouchEvent touchEvent; 3009 touchEvent.targetGlobalPositionX = 1234.56f; 3010 event.eventTypeId = C_TOUCH_EVENT_ID; 3011 event.inputEvent = nullptr; 3012 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3013 EXPECT_EQ(positionX, 0.0f); 3014 event.inputEvent = &touchEvent; 3015 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3016 EXPECT_EQ(positionX, 1234.56f); 3017 3018 OHOS::Ace::TouchEvent aceTouchEvent; 3019 aceTouchEvent.targetGlobalPositionX = 2345.67f; 3020 event.eventTypeId = TOUCH_EVENT_ID; 3021 event.inputEvent = nullptr; 3022 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3023 EXPECT_EQ(positionX, 0.0f); 3024 event.inputEvent = &aceTouchEvent; 3025 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3026 EXPECT_EQ(positionX, 2345.67f); 3027 3028 OHOS::Ace::AxisEvent aceAxisEvent; 3029 aceAxisEvent.targetGlobalPositionX = 3456.78f; 3030 event.eventTypeId = AXIS_EVENT_ID; 3031 event.inputEvent = nullptr; 3032 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3033 EXPECT_EQ(positionX, 0.0f); 3034 event.inputEvent = &aceAxisEvent; 3035 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3036 EXPECT_EQ(positionX, 3456.78f); 3037 3038 ArkUIMouseEvent mouseEvent; 3039 mouseEvent.targetGlobalPositionX = 4567.89f; 3040 event.eventTypeId = C_MOUSE_EVENT_ID; 3041 event.inputEvent = nullptr; 3042 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3043 EXPECT_EQ(positionX, 0.0f); 3044 event.inputEvent = &mouseEvent; 3045 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3046 EXPECT_EQ(positionX, 4567.89f); 3047 } 3048 /** 3049 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX002 3050 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX 3051 * @tc.type: FUNC 3052 */ 3053 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX002, TestSize.Level1) 3054 { 3055 float positionX = 1.0f; 3056 ArkUI_UIInputEvent event; 3057 3058 ArkUIAxisEvent axisEvent; 3059 axisEvent.targetGlobalPositionX = 5678.90f; 3060 event.eventTypeId = C_AXIS_EVENT_ID; 3061 event.inputEvent = nullptr; 3062 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3063 EXPECT_EQ(positionX, 0.0f); 3064 event.inputEvent = &axisEvent; 3065 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3066 EXPECT_EQ(positionX, 5678.90f); 3067 3068 ArkUIFocusAxisEvent focusAxisEvent; 3069 focusAxisEvent.targetGlobalPositionX = 6789.01f; 3070 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 3071 event.inputEvent = nullptr; 3072 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3073 EXPECT_EQ(positionX, 0.0f); 3074 event.inputEvent = &focusAxisEvent; 3075 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3076 EXPECT_EQ(positionX, 6789.01f); 3077 3078 ArkUIHoverEvent hoverEvent; 3079 hoverEvent.targetGlobalPositionX = 7890.12f; 3080 event.eventTypeId = C_HOVER_EVENT_ID; 3081 event.inputEvent = nullptr; 3082 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3083 EXPECT_EQ(positionX, 0.0f); 3084 event.inputEvent = &hoverEvent; 3085 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3086 EXPECT_EQ(positionX, 7890.12f); 3087 3088 ArkUIClickEvent clickEvent; 3089 clickEvent.targetGlobalPositionX = 8901.23f; 3090 event.eventTypeId = C_CLICK_EVENT_ID; 3091 event.inputEvent = nullptr; 3092 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3093 EXPECT_EQ(positionX, 0.0f); 3094 event.inputEvent = &clickEvent; 3095 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 3096 EXPECT_EQ(positionX, 8901.23f); 3097 } 3098 3099 /** 3100 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY001 3101 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY 3102 * @tc.type: FUNC 3103 */ 3104 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY001, TestSize.Level1) 3105 { 3106 float positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(nullptr); 3107 EXPECT_EQ(positionY, 0.0f); 3108 3109 ArkUI_UIInputEvent event; 3110 3111 ArkUITouchEvent touchEvent; 3112 touchEvent.targetGlobalPositionY = 1122.33f; 3113 event.eventTypeId = C_TOUCH_EVENT_ID; 3114 event.inputEvent = nullptr; 3115 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3116 EXPECT_EQ(positionY, 0.0f); 3117 event.inputEvent = &touchEvent; 3118 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3119 EXPECT_EQ(positionY, 1122.33f); 3120 3121 OHOS::Ace::TouchEvent aceTouchEvent; 3122 aceTouchEvent.targetGlobalPositionY = 2233.44f; 3123 event.eventTypeId = TOUCH_EVENT_ID; 3124 event.inputEvent = nullptr; 3125 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3126 EXPECT_EQ(positionY, 0.0f); 3127 event.inputEvent = &aceTouchEvent; 3128 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3129 EXPECT_EQ(positionY, 2233.44f); 3130 3131 OHOS::Ace::AxisEvent aceAxisEvent; 3132 aceAxisEvent.targetGlobalPositionY = 3344.55f; 3133 event.eventTypeId = AXIS_EVENT_ID; 3134 event.inputEvent = nullptr; 3135 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3136 EXPECT_EQ(positionY, 0.0f); 3137 event.inputEvent = &aceAxisEvent; 3138 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3139 EXPECT_EQ(positionY, 3344.55f); 3140 3141 ArkUIMouseEvent mouseEvent; 3142 mouseEvent.targetGlobalPositionY = 4455.66f; 3143 event.eventTypeId = C_MOUSE_EVENT_ID; 3144 event.inputEvent = nullptr; 3145 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3146 EXPECT_EQ(positionY, 0.0f); 3147 event.inputEvent = &mouseEvent; 3148 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3149 EXPECT_EQ(positionY, 4455.66f); 3150 } 3151 3152 /** 3153 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY002 3154 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY 3155 * @tc.type: FUNC 3156 */ 3157 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY002, TestSize.Level1) 3158 { 3159 float positionY = 1.0f; 3160 ArkUI_UIInputEvent event; 3161 3162 ArkUIAxisEvent axisEvent; 3163 axisEvent.targetGlobalPositionY = 5566.77f; 3164 event.eventTypeId = C_AXIS_EVENT_ID; 3165 event.inputEvent = nullptr; 3166 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3167 EXPECT_EQ(positionY, 0.0f); 3168 event.inputEvent = &axisEvent; 3169 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3170 EXPECT_EQ(positionY, 5566.77f); 3171 3172 ArkUIFocusAxisEvent focusAxisEvent; 3173 focusAxisEvent.targetGlobalPositionY = 6677.88f; 3174 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 3175 event.inputEvent = nullptr; 3176 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3177 EXPECT_EQ(positionY, 0.0f); 3178 event.inputEvent = &focusAxisEvent; 3179 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3180 EXPECT_EQ(positionY, 6677.88f); 3181 3182 ArkUIHoverEvent hoverEvent; 3183 hoverEvent.targetGlobalPositionY = 7788.99f; 3184 event.eventTypeId = C_HOVER_EVENT_ID; 3185 event.inputEvent = nullptr; 3186 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3187 EXPECT_EQ(positionY, 0.0f); 3188 event.inputEvent = &hoverEvent; 3189 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3190 EXPECT_EQ(positionY, 7788.99f); 3191 3192 ArkUIClickEvent clickEvent; 3193 clickEvent.targetGlobalPositionY = 8899.00f; 3194 event.eventTypeId = C_CLICK_EVENT_ID; 3195 event.inputEvent = nullptr; 3196 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3197 EXPECT_EQ(positionY, 0.0f); 3198 event.inputEvent = &clickEvent; 3199 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 3200 EXPECT_EQ(positionY, 8899.00f); 3201 } 3202 3203 /** 3204 * @tc.name: OH_ArkUI_PointerEvent_CreateClonedEvent001 3205 * @tc.desc: Test OH_ArkUI_PointerEvent_CreateClonedEvent 3206 * @tc.type: FUNC 3207 */ 3208 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_CreateClonedEvent001, TestSize.Level1) 3209 { 3210 ArkUI_UIInputEvent* inputEvent = nullptr; 3211 ArkUI_UIInputEvent* clonedEvent; 3212 int32_t res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3213 EXPECT_EQ(res, 401); 3214 inputEvent = new ArkUI_UIInputEvent(); 3215 inputEvent->inputEvent = nullptr; 3216 res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3217 EXPECT_EQ(res, 0); 3218 ArkUITouchEvent* touchEvent = new ArkUITouchEvent(); 3219 inputEvent->inputEvent = touchEvent; 3220 inputEvent->isCloned = false; 3221 res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3222 EXPECT_EQ(res, 0); 3223 inputEvent->isCloned = true; 3224 res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3225 EXPECT_EQ(res, 0); 3226 ArkUI_NodeEvent nodeEvent; 3227 ArkUINodeEvent event; 3228 ArkUI_UIInputEvent uiInputEvent1; 3229 event.touchEvent.changedPointerId = 1; 3230 event.touchEvent.touchPointSize = 1; 3231 uiInputEvent1.inputEvent = &event.touchEvent; 3232 uiInputEvent1.eventTypeId = C_TOUCH_EVENT_ID; 3233 nodeEvent.origin = &uiInputEvent1; 3234 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3235 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3236 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3237 3238 touchEvent->target.id = touchEvenInput->target.id; 3239 touchEvent->target.type = touchEvenInput->target.type; 3240 touchEvent->target.area = touchEvenInput->target.area; 3241 touchEvent->target.origin = touchEvenInput->target.origin; 3242 touchEvent->action = touchEvenInput->action; 3243 touchEvent->changedPointerId = touchEvenInput->changedPointerId; 3244 touchEvent->actionTouchPoint = touchEvenInput->actionTouchPoint; 3245 touchEvent->timeStamp = touchEvenInput->timeStamp; 3246 touchEvent->sourceType = touchEvenInput->sourceType; 3247 touchEvent->targetDisplayId = touchEvenInput->targetDisplayId; 3248 touchEvent->deviceId = touchEvenInput->deviceId; 3249 res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3250 EXPECT_EQ(res, 401); 3251 } 3252 3253 /** 3254 * @tc.name: OH_ArkUI_PointerEvent_DestroyClonedEvent001 3255 * @tc.desc: Test OH_ArkUI_PointerEvent_DestroyClonedEvent 3256 * @tc.type: FUNC 3257 */ 3258 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_DestroyClonedEvent001, TestSize.Level1) 3259 { 3260 ArkUI_UIInputEvent* inputEvent = nullptr; 3261 ArkUI_UIInputEvent* clonedEvent; 3262 inputEvent = new ArkUI_UIInputEvent(); 3263 inputEvent->inputEvent = nullptr; 3264 ArkUITouchEvent* touchEvent = new ArkUITouchEvent(); 3265 inputEvent->inputEvent = touchEvent; 3266 inputEvent->isCloned = false; 3267 inputEvent->isCloned = true; 3268 ArkUI_NodeEvent nodeEvent; 3269 ArkUINodeEvent event; 3270 ArkUI_UIInputEvent uiInputEvent1; 3271 event.touchEvent.changedPointerId = 1; 3272 event.touchEvent.touchPointSize = 1; 3273 uiInputEvent1.inputEvent = &event.touchEvent; 3274 uiInputEvent1.eventTypeId = C_TOUCH_EVENT_ID; 3275 nodeEvent.origin = &uiInputEvent1; 3276 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3277 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3278 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3279 3280 touchEvent->target.id = touchEvenInput->target.id; 3281 touchEvent->target.type = touchEvenInput->target.type; 3282 touchEvent->target.area = touchEvenInput->target.area; 3283 touchEvent->target.origin = touchEvenInput->target.origin; 3284 touchEvent->action = touchEvenInput->action; 3285 touchEvent->changedPointerId = touchEvenInput->changedPointerId; 3286 touchEvent->actionTouchPoint = touchEvenInput->actionTouchPoint; 3287 touchEvent->timeStamp = touchEvenInput->timeStamp; 3288 touchEvent->sourceType = touchEvenInput->sourceType; 3289 touchEvent->targetDisplayId = touchEvenInput->targetDisplayId; 3290 touchEvent->deviceId = touchEvenInput->deviceId; 3291 3292 auto res = OH_ArkUI_PointerEvent_CreateClonedEvent(inputEvent, &clonedEvent); 3293 EXPECT_EQ(res, 401); 3294 3295 auto res1 = OH_ArkUI_PointerEvent_DestroyClonedEvent(clonedEvent); 3296 EXPECT_EQ(res1, 401); 3297 } 3298 3299 /** 3300 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPosition001 3301 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3302 * @tc.type: FUNC 3303 */ 3304 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPosition001, TestSize.Level1) 3305 { 3306 /** 3307 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3308 */ 3309 ArkUI_NodeEvent nodeEvent; 3310 ArkUINodeEvent event; 3311 ArkUI_UIInputEvent uiInputEvent; 3312 event.kind = TOUCH_EVENT; 3313 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3314 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3315 // deviceid 3316 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3317 // modifierkeystates 3318 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3319 uiInputEvent.inputEvent = &event.touchEvent; 3320 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3321 nodeEvent.origin = &uiInputEvent; 3322 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3323 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3324 3325 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3326 event.touchEvent.target.id = touchEvenInput->target.id; 3327 event.touchEvent.target.type = touchEvenInput->target.type; 3328 event.touchEvent.target.area = touchEvenInput->target.area; 3329 event.touchEvent.target.origin = touchEvenInput->target.origin; 3330 event.touchEvent.action = touchEvenInput->action; 3331 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3332 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3333 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3334 event.touchEvent.sourceType = touchEvenInput->sourceType; 3335 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3336 event.touchEvent.deviceId = touchEvenInput->deviceId; 3337 3338 auto nodeX = ARKUI_X - 1; 3339 auto nodeY = ARKUI_Y - 1; 3340 3341 auto res = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(inputEvent, nodeX, nodeY); 3342 EXPECT_EQ(res, 180003); 3343 auto x = OH_ArkUI_PointerEvent_GetX(inputEvent); 3344 auto y = OH_ArkUI_PointerEvent_GetY(inputEvent); 3345 EXPECT_EQ(x, ARKUI_X); 3346 EXPECT_EQ(y, ARKUI_Y); 3347 inputEvent->isCloned = true; 3348 res = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(inputEvent, nodeX, nodeY); 3349 EXPECT_EQ(res, 0); 3350 auto x1 = OH_ArkUI_PointerEvent_GetX(inputEvent); 3351 auto y1 = OH_ArkUI_PointerEvent_GetY(inputEvent); 3352 EXPECT_EQ(x1, ARKUI_X - 1); 3353 EXPECT_EQ(y1, ARKUI_Y - 1); 3354 } 3355 3356 /** 3357 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex001 3358 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3359 * @tc.type: FUNC 3360 */ 3361 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex001, TestSize.Level1) 3362 { 3363 /** 3364 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3365 */ 3366 ArkUI_NodeEvent nodeEvent; 3367 ArkUINodeEvent event; 3368 ArkUI_UIInputEvent uiInputEvent; 3369 event.kind = TOUCH_EVENT; 3370 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3371 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3372 // deviceid 3373 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3374 // modifierkeystates 3375 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3376 uiInputEvent.inputEvent = &event.touchEvent; 3377 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3378 nodeEvent.origin = &uiInputEvent; 3379 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3380 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3381 auto nodeX = ARKUI_X - 1; 3382 auto nodeY = ARKUI_Y - 1; 3383 3384 auto res = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(inputEvent, nodeX, nodeY, 0); 3385 EXPECT_EQ(res, 180003); 3386 auto x = OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0); 3387 auto y = OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0); 3388 EXPECT_EQ(x, 0); 3389 EXPECT_EQ(y, 0); 3390 inputEvent->isCloned = true; 3391 res = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(inputEvent, nodeX, nodeY, 0); 3392 EXPECT_EQ(res, 401); 3393 auto x1 = OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0); 3394 auto y1 = OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0); 3395 EXPECT_EQ(x1, 0); 3396 EXPECT_EQ(y1, 0); 3397 3398 ArkUITouchPoint points[2]; // 2 points 3399 points[0].nodeX = ARKUI_X; 3400 points[1].nodeY = ARKUI_Y; 3401 event.touchEvent.touchPointes = points; 3402 inputEvent->isCloned = false; 3403 uiInputEvent.inputEvent = &event.touchEvent; 3404 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3405 nodeEvent.origin = &uiInputEvent; 3406 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3407 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3408 3409 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3410 event.touchEvent.target.id = touchEvenInput->target.id; 3411 event.touchEvent.target.type = touchEvenInput->target.type; 3412 event.touchEvent.target.area = touchEvenInput->target.area; 3413 event.touchEvent.target.origin = touchEvenInput->target.origin; 3414 event.touchEvent.action = touchEvenInput->action; 3415 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3416 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3417 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3418 event.touchEvent.sourceType = touchEvenInput->sourceType; 3419 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3420 event.touchEvent.deviceId = touchEvenInput->deviceId; 3421 3422 res = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(inputEvent, nodeX, nodeY, 0); 3423 EXPECT_EQ(res, 180003); 3424 x = OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0); 3425 y = OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0); 3426 EXPECT_EQ(x, 0); 3427 EXPECT_EQ(y, 0); 3428 inputEvent->isCloned = true; 3429 res = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(inputEvent, nodeX, nodeY, 0); 3430 EXPECT_EQ(res, 401); 3431 x1 = OH_ArkUI_PointerEvent_GetXByIndex(inputEvent, 0); 3432 y1 = OH_ArkUI_PointerEvent_GetYByIndex(inputEvent, 0); 3433 EXPECT_EQ(x1, 0); 3434 EXPECT_EQ(y1, 0); 3435 } 3436 3437 /** 3438 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventActionType001 3439 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3440 * @tc.type: FUNC 3441 */ 3442 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventActionType001, TestSize.Level1) 3443 { 3444 /** 3445 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3446 */ 3447 ArkUI_NodeEvent nodeEvent; 3448 ArkUINodeEvent event; 3449 ArkUI_UIInputEvent uiInputEvent; 3450 event.kind = TOUCH_EVENT; 3451 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3452 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3453 // deviceid 3454 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3455 // modifierkeystates 3456 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3457 uiInputEvent.inputEvent = &event.touchEvent; 3458 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3459 nodeEvent.origin = &uiInputEvent; 3460 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3461 event.touchEvent.action = ARKUI_ACTIONTYPE; 3462 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3463 3464 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3465 event.touchEvent.target.id = touchEvenInput->target.id; 3466 event.touchEvent.target.type = touchEvenInput->target.type; 3467 event.touchEvent.target.area = touchEvenInput->target.area; 3468 event.touchEvent.target.origin = touchEvenInput->target.origin; 3469 event.touchEvent.action = touchEvenInput->action; 3470 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3471 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3472 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3473 event.touchEvent.sourceType = touchEvenInput->sourceType; 3474 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3475 event.touchEvent.deviceId = touchEvenInput->deviceId; 3476 3477 auto res = OH_ArkUI_PointerEvent_SetClonedEventActionType(inputEvent, ARKUI_ACTIONTYPE_SET); 3478 auto action = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 3479 EXPECT_EQ(res, 180003); 3480 EXPECT_EQ(action, 3); 3481 inputEvent->isCloned = true; 3482 res = OH_ArkUI_PointerEvent_SetClonedEventActionType(inputEvent, ARKUI_ACTIONTYPE_SET); 3483 action = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 3484 EXPECT_EQ(res, 0); 3485 EXPECT_EQ(action, 1); 3486 } 3487 3488 /** 3489 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId001 3490 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3491 * @tc.type: FUNC 3492 */ 3493 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId001, TestSize.Level1) 3494 { 3495 /** 3496 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3497 */ 3498 ArkUI_NodeEvent nodeEvent; 3499 ArkUINodeEvent event; 3500 ArkUI_UIInputEvent uiInputEvent; 3501 event.kind = TOUCH_EVENT; 3502 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3503 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3504 // deviceid 3505 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3506 // modifierkeystates 3507 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3508 uiInputEvent.inputEvent = &event.touchEvent; 3509 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3510 nodeEvent.origin = &uiInputEvent; 3511 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3512 event.touchEvent.action = ARKUI_FINGERID; 3513 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3514 3515 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3516 event.touchEvent.target.id = touchEvenInput->target.id; 3517 event.touchEvent.target.type = touchEvenInput->target.type; 3518 event.touchEvent.target.area = touchEvenInput->target.area; 3519 event.touchEvent.target.origin = touchEvenInput->target.origin; 3520 event.touchEvent.action = touchEvenInput->action; 3521 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3522 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3523 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3524 event.touchEvent.sourceType = touchEvenInput->sourceType; 3525 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3526 event.touchEvent.deviceId = touchEvenInput->deviceId; 3527 3528 auto res = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(inputEvent, ARKUI_FINGERID_SET); 3529 auto pointerId = OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0); 3530 EXPECT_EQ(res, 180003); 3531 EXPECT_EQ(pointerId, 0); 3532 inputEvent->isCloned = true; 3533 res = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(inputEvent, ARKUI_FINGERID_SET); 3534 pointerId = OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0); 3535 EXPECT_EQ(res, 0); 3536 EXPECT_EQ(pointerId, 0); 3537 } 3538 3539 /** 3540 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex001 3541 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3542 * @tc.type: FUNC 3543 */ 3544 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex001, TestSize.Level1) 3545 { 3546 /** 3547 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3548 */ 3549 ArkUI_NodeEvent nodeEvent; 3550 ArkUINodeEvent event; 3551 ArkUI_UIInputEvent uiInputEvent; 3552 event.kind = TOUCH_EVENT; 3553 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3554 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3555 // deviceid 3556 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3557 // modifierkeystates 3558 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3559 uiInputEvent.inputEvent = &event.touchEvent; 3560 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3561 nodeEvent.origin = &uiInputEvent; 3562 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3563 event.touchEvent.action = ARKUI_FINGERID; 3564 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3565 3566 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3567 event.touchEvent.target.id = touchEvenInput->target.id; 3568 event.touchEvent.target.type = touchEvenInput->target.type; 3569 event.touchEvent.target.area = touchEvenInput->target.area; 3570 event.touchEvent.target.origin = touchEvenInput->target.origin; 3571 event.touchEvent.action = touchEvenInput->action; 3572 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3573 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3574 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3575 event.touchEvent.sourceType = touchEvenInput->sourceType; 3576 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3577 event.touchEvent.deviceId = touchEvenInput->deviceId; 3578 3579 auto res = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(inputEvent, ARKUI_FINGERID_SET, 0); 3580 auto pointerId = OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0); 3581 EXPECT_EQ(res, 180003); 3582 EXPECT_EQ(pointerId, 0); 3583 inputEvent->isCloned = true; 3584 res = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(inputEvent, ARKUI_FINGERID_SET, 0); 3585 pointerId = OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0); 3586 EXPECT_EQ(res, 401); 3587 EXPECT_EQ(pointerId, 0); 3588 3589 ArkUITouchPoint points[2]; // 2 points 3590 points[0].id = ARKUI_FINGERID; 3591 points[1].id = ARKUI_FINGERID; 3592 event.touchEvent.touchPointes = points; 3593 inputEvent->isCloned = true; 3594 uiInputEvent.inputEvent = &event.touchEvent; 3595 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3596 nodeEvent.origin = &uiInputEvent; 3597 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3598 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3599 3600 res = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(inputEvent, ARKUI_FINGERID_SET, 0); 3601 pointerId = OH_ArkUI_PointerEvent_GetPointerId(inputEvent, 0); 3602 EXPECT_EQ(res, 401); 3603 EXPECT_EQ(pointerId, 0); 3604 } 3605 3606 /** 3607 * @tc.name: OH_ArkUI_PointerEvent_PostClonedEvent001 3608 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 3609 * @tc.type: FUNC 3610 */ 3611 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_PostClonedEvent001, TestSize.Level1) 3612 { 3613 /** 3614 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3615 */ 3616 ArkUI_NodeEvent nodeEvent; 3617 ArkUINodeEvent event; 3618 ArkUI_UIInputEvent uiInputEvent; 3619 event.kind = TOUCH_EVENT; 3620 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3621 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3622 // deviceid 3623 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3624 // modifierkeystates 3625 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3626 uiInputEvent.inputEvent = &event.touchEvent; 3627 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3628 nodeEvent.origin = &uiInputEvent; 3629 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3630 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3631 ArkUI_NodeHandle nodeHandle = nullptr; 3632 3633 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3634 event.touchEvent.target.id = touchEvenInput->target.id; 3635 event.touchEvent.target.type = touchEvenInput->target.type; 3636 event.touchEvent.target.area = touchEvenInput->target.area; 3637 event.touchEvent.target.origin = touchEvenInput->target.origin; 3638 event.touchEvent.action = touchEvenInput->action; 3639 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3640 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3641 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3642 event.touchEvent.sourceType = touchEvenInput->sourceType; 3643 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3644 event.touchEvent.deviceId = touchEvenInput->deviceId; 3645 inputEvent->isCloned = true; 3646 auto res = OH_ArkUI_PointerEvent_PostClonedEvent(nodeHandle, inputEvent); 3647 EXPECT_EQ(res, 180004); 3648 } 3649 3650 /** 3651 * @tc.name: OH_ArkUI_AxisEvent_SetPropagation001 3652 * @tc.desc: Test OH_ArkUI_AxisEvent_SetPropagation functions. 3653 * @tc.type: FUNC 3654 */ 3655 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_SetPropagation001, TestSize.Level1) 3656 { 3657 /** 3658 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3659 */ 3660 ArkUI_NodeEvent nodeEvent; 3661 ArkUINodeEvent event; 3662 ArkUI_UIInputEvent uiInputEvent; 3663 event.kind = TOUCH_EVENT; 3664 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3665 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3666 // deviceid 3667 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3668 // modifierkeystates 3669 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3670 uiInputEvent.inputEvent = &event.touchEvent; 3671 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3672 nodeEvent.origin = &uiInputEvent; 3673 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3674 event.touchEvent.action = ARKUI_FINGERID; 3675 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3676 3677 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3678 event.touchEvent.target.id = touchEvenInput->target.id; 3679 event.touchEvent.target.type = touchEvenInput->target.type; 3680 event.touchEvent.target.area = touchEvenInput->target.area; 3681 event.touchEvent.target.origin = touchEvenInput->target.origin; 3682 event.touchEvent.action = touchEvenInput->action; 3683 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3684 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3685 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3686 event.touchEvent.sourceType = touchEvenInput->sourceType; 3687 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3688 event.touchEvent.deviceId = touchEvenInput->deviceId; 3689 3690 ArkUI_UIInputEvent setEvent; 3691 ArkUIAxisEvent cAxisEvent; 3692 cAxisEvent.propagation = true; 3693 setEvent.inputEvent = &cAxisEvent; 3694 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3695 auto res = OH_ArkUI_AxisEvent_SetPropagation(nullptr, true); 3696 EXPECT_EQ(res, 401); 3697 res = OH_ArkUI_AxisEvent_SetPropagation(&setEvent, true); 3698 EXPECT_EQ(res, 0); 3699 cAxisEvent.propagation = false; 3700 setEvent.inputEvent = &cAxisEvent; 3701 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3702 res = OH_ArkUI_AxisEvent_SetPropagation(&setEvent, false); 3703 EXPECT_EQ(res, 0); 3704 cAxisEvent.propagation = true; 3705 setEvent.inputEvent = &cAxisEvent; 3706 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3707 res = OH_ArkUI_AxisEvent_SetPropagation(&setEvent, true); 3708 EXPECT_EQ(res, 401); 3709 cAxisEvent.propagation = false; 3710 setEvent.inputEvent = &cAxisEvent; 3711 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3712 res = OH_ArkUI_AxisEvent_SetPropagation(&setEvent, false); 3713 EXPECT_EQ(res, 401); 3714 } 3715 3716 /** 3717 * @tc.name: OH_ArkUI_HoverEvent_IsHovered001 3718 * @tc.desc: Test OH_ArkUI_HoverEvent_IsHovered functions. 3719 * @tc.type: FUNC 3720 */ 3721 HWTEST_F(UIInputEventTest, OH_ArkUI_HoverEvent_IsHovered001, TestSize.Level1) 3722 { 3723 /** 3724 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 3725 */ 3726 ArkUI_NodeEvent nodeEvent; 3727 ArkUINodeEvent event; 3728 ArkUI_UIInputEvent uiInputEvent; 3729 event.kind = TOUCH_EVENT; 3730 event.touchEvent.actionTouchPoint.nodeX = ARKUI_X; 3731 event.touchEvent.actionTouchPoint.nodeY = ARKUI_Y; 3732 // deviceid 3733 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 3734 // modifierkeystates 3735 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 3736 uiInputEvent.inputEvent = &event.touchEvent; 3737 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 3738 nodeEvent.origin = &uiInputEvent; 3739 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 3740 event.touchEvent.action = ARKUI_FINGERID; 3741 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 3742 3743 auto* touchEvenInput = reinterpret_cast<ArkUITouchEvent*>(inputEvent->inputEvent); 3744 event.touchEvent.target.id = touchEvenInput->target.id; 3745 event.touchEvent.target.type = touchEvenInput->target.type; 3746 event.touchEvent.target.area = touchEvenInput->target.area; 3747 event.touchEvent.target.origin = touchEvenInput->target.origin; 3748 event.touchEvent.action = touchEvenInput->action; 3749 event.touchEvent.changedPointerId = touchEvenInput->changedPointerId; 3750 event.touchEvent.actionTouchPoint = touchEvenInput->actionTouchPoint; 3751 event.touchEvent.timeStamp = touchEvenInput->timeStamp; 3752 event.touchEvent.sourceType = touchEvenInput->sourceType; 3753 event.touchEvent.targetDisplayId = touchEvenInput->targetDisplayId; 3754 event.touchEvent.deviceId = touchEvenInput->deviceId; 3755 3756 ArkUI_UIInputEvent setEvent; 3757 ArkUIHoverEvent hoverEvent; 3758 hoverEvent.isHover = true; 3759 setEvent.inputEvent = &hoverEvent; 3760 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3761 auto res = OH_ArkUI_HoverEvent_IsHovered(nullptr); 3762 EXPECT_EQ(res, false); 3763 res = OH_ArkUI_HoverEvent_IsHovered(&setEvent); 3764 EXPECT_EQ(res, false); 3765 hoverEvent.isHover = false; 3766 setEvent.inputEvent = &hoverEvent; 3767 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3768 res = OH_ArkUI_HoverEvent_IsHovered(&setEvent); 3769 EXPECT_EQ(res, false); 3770 hoverEvent.isHover = true; 3771 setEvent.inputEvent = &hoverEvent; 3772 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3773 res = OH_ArkUI_HoverEvent_IsHovered(&setEvent); 3774 EXPECT_EQ(res, true); 3775 hoverEvent.isHover = false; 3776 setEvent.inputEvent = &hoverEvent; 3777 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3778 res = OH_ArkUI_HoverEvent_IsHovered(&setEvent); 3779 EXPECT_EQ(res, 0); 3780 } 3781 3782 /** 3783 * @tc.name: OH_ArkUI_UIInputEvent_GetModifierKeyStates009 3784 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetModifierKeyStates functions. 3785 * @tc.type: FUNC 3786 */ 3787 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetModifierKeyStates009, TestSize.Level1) 3788 { 3789 ArkUI_UIInputEvent setEvent; 3790 ArkUITouchEvent touchEvent; 3791 setEvent.inputEvent = &touchEvent; 3792 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3793 uint64_t keys = C_TOUCH_EVENT_ID; 3794 auto res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(nullptr, &keys); 3795 EXPECT_EQ(res, 401); 3796 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3797 setEvent.eventTypeId = TOUCH_EVENT_ID; 3798 keys = TOUCH_EVENT_ID; 3799 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3800 ArkUIAxisEvent axisEvent; 3801 setEvent.inputEvent = &axisEvent; 3802 setEvent.eventTypeId = AXIS_EVENT_ID; 3803 keys = AXIS_EVENT_ID; 3804 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3805 EXPECT_EQ(res, 0); 3806 ArkUIMouseEvent mouseEvent; 3807 setEvent.inputEvent = &mouseEvent; 3808 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 3809 keys = C_MOUSE_EVENT_ID; 3810 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3811 EXPECT_EQ(res, 0); 3812 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3813 keys = C_AXIS_EVENT_ID; 3814 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3815 EXPECT_EQ(res, 0); 3816 ArkUIKeyEvent keyEvent; 3817 setEvent.inputEvent = &keyEvent; 3818 setEvent.eventTypeId = C_KEY_EVENT_ID; 3819 keys = C_KEY_EVENT_ID; 3820 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3821 EXPECT_EQ(res, 0); 3822 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3823 keys = C_AXIS_EVENT_ID; 3824 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3825 EXPECT_EQ(res, 0); 3826 ArkUIHoverEvent hoverEvent; 3827 setEvent.inputEvent = &hoverEvent; 3828 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3829 keys = C_HOVER_EVENT_ID; 3830 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3831 EXPECT_EQ(res, 0); 3832 ArkUIClickEvent clickEvent; 3833 setEvent.inputEvent = &clickEvent; 3834 setEvent.eventTypeId = C_CLICK_EVENT_ID; 3835 keys = C_CLICK_EVENT_ID; 3836 res = OH_ArkUI_UIInputEvent_GetModifierKeyStates(&setEvent, &keys); 3837 EXPECT_EQ(res, 0); 3838 } 3839 3840 /** 3841 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX001 3842 * @tc.desc: Test OH_ArkUI_PointerEvent_GetTiltX functions. 3843 * @tc.type: FUNC 3844 */ 3845 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX001, TestSize.Level1) 3846 { 3847 ArkUI_UIInputEvent setEvent; 3848 ArkUITouchEvent touchEvent; 3849 setEvent.inputEvent = &touchEvent; 3850 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3851 auto res = OH_ArkUI_PointerEvent_GetTiltX(nullptr, -1); 3852 EXPECT_EQ(res, 0); 3853 touchEvent.subKind = ON_HOVER_MOVE; 3854 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3855 EXPECT_EQ(res, 0); 3856 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, -1); 3857 setEvent.eventTypeId = TOUCH_EVENT_ID; 3858 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3859 EXPECT_EQ(res, 0); 3860 ArkUIAxisEvent axisEvent; 3861 setEvent.inputEvent = &axisEvent; 3862 setEvent.eventTypeId = AXIS_EVENT_ID; 3863 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3864 EXPECT_EQ(res, 0); 3865 ArkUIMouseEvent mouseEvent; 3866 setEvent.inputEvent = &mouseEvent; 3867 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 3868 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3869 EXPECT_EQ(res, 0); 3870 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3871 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3872 EXPECT_EQ(res, 0); 3873 ArkUIKeyEvent keyEvent; 3874 setEvent.inputEvent = &keyEvent; 3875 setEvent.eventTypeId = C_KEY_EVENT_ID; 3876 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3877 EXPECT_EQ(res, 0); 3878 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3879 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3880 EXPECT_EQ(res, 0); 3881 ArkUIHoverEvent hoverEvent; 3882 setEvent.inputEvent = &hoverEvent; 3883 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3884 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3885 EXPECT_EQ(res, 0); 3886 ArkUIClickEvent clickEvent; 3887 setEvent.inputEvent = &clickEvent; 3888 setEvent.eventTypeId = C_CLICK_EVENT_ID; 3889 res = OH_ArkUI_PointerEvent_GetTiltX(&setEvent, 0); 3890 EXPECT_EQ(res, 0); 3891 } 3892 3893 /** 3894 * @tc.name: OH_ArkUI_PointerEvent_GetTiltY001 3895 * @tc.desc: Test OH_ArkUI_PointerEvent_GetTiltY functions. 3896 * @tc.type: FUNC 3897 */ 3898 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltY001, TestSize.Level1) 3899 { 3900 ArkUI_UIInputEvent setEvent; 3901 ArkUITouchEvent touchEvent; 3902 setEvent.inputEvent = &touchEvent; 3903 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3904 auto res = OH_ArkUI_PointerEvent_GetTiltY(nullptr, -1); 3905 EXPECT_EQ(res, 0); 3906 touchEvent.subKind = ON_HOVER_MOVE; 3907 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3908 EXPECT_EQ(res, 0); 3909 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, -1); 3910 setEvent.eventTypeId = TOUCH_EVENT_ID; 3911 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3912 EXPECT_EQ(res, 0); 3913 ArkUIAxisEvent axisEvent; 3914 setEvent.inputEvent = &axisEvent; 3915 setEvent.eventTypeId = AXIS_EVENT_ID; 3916 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3917 EXPECT_EQ(res, 0); 3918 ArkUIMouseEvent mouseEvent; 3919 setEvent.inputEvent = &mouseEvent; 3920 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 3921 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3922 EXPECT_EQ(res, 0); 3923 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3924 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3925 EXPECT_EQ(res, 0); 3926 ArkUIKeyEvent keyEvent; 3927 setEvent.inputEvent = &keyEvent; 3928 setEvent.eventTypeId = C_KEY_EVENT_ID; 3929 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3930 EXPECT_EQ(res, 0); 3931 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3932 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3933 EXPECT_EQ(res, 0); 3934 ArkUIHoverEvent hoverEvent; 3935 setEvent.inputEvent = &hoverEvent; 3936 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3937 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3938 EXPECT_EQ(res, 0); 3939 ArkUIClickEvent clickEvent; 3940 setEvent.inputEvent = &clickEvent; 3941 setEvent.eventTypeId = C_CLICK_EVENT_ID; 3942 res = OH_ArkUI_PointerEvent_GetTiltY(&setEvent, 0); 3943 EXPECT_EQ(res, 0); 3944 } 3945 3946 /** 3947 * @tc.name: OH_ArkUI_PointerEvent_GetRollAngle001 3948 * @tc.desc: Test OH_ArkUI_PointerEvent_GetRollAngle functions. 3949 * @tc.type: FUNC 3950 */ 3951 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetRollAngle001, TestSize.Level1) 3952 { 3953 ArkUI_UIInputEvent setEvent; 3954 ArkUITouchEvent touchEvent; 3955 setEvent.inputEvent = &touchEvent; 3956 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 3957 double rollAngle = 0.0; 3958 touchEvent.subKind = ON_HOVER_MOVE; 3959 touchEvent.actionTouchPoint.rollAngle = 1.0; 3960 auto res = OH_ArkUI_PointerEvent_GetRollAngle(nullptr, &rollAngle); 3961 EXPECT_EQ(res, 401); 3962 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3963 setEvent.eventTypeId = TOUCH_EVENT_ID; 3964 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3965 EXPECT_EQ(res, 401); 3966 ArkUIAxisEvent axisEvent; 3967 setEvent.inputEvent = &axisEvent; 3968 setEvent.eventTypeId = AXIS_EVENT_ID; 3969 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3970 EXPECT_EQ(res, 401); 3971 ArkUIMouseEvent mouseEvent; 3972 setEvent.inputEvent = &mouseEvent; 3973 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 3974 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3975 EXPECT_EQ(res, 401); 3976 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3977 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3978 EXPECT_EQ(res, 401); 3979 ArkUIKeyEvent keyEvent; 3980 setEvent.inputEvent = &keyEvent; 3981 setEvent.eventTypeId = C_KEY_EVENT_ID; 3982 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3983 EXPECT_EQ(res, 401); 3984 setEvent.eventTypeId = C_AXIS_EVENT_ID; 3985 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3986 EXPECT_EQ(res, 401); 3987 ArkUIHoverEvent hoverEvent; 3988 setEvent.inputEvent = &hoverEvent; 3989 setEvent.eventTypeId = C_HOVER_EVENT_ID; 3990 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3991 EXPECT_EQ(res, 0); 3992 ArkUIClickEvent clickEvent; 3993 setEvent.inputEvent = &clickEvent; 3994 setEvent.eventTypeId = C_CLICK_EVENT_ID; 3995 res = OH_ArkUI_PointerEvent_GetRollAngle(&setEvent, &rollAngle); 3996 EXPECT_EQ(res, 0); 3997 } 3998 3999 /** 4000 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayYByIndex008 4001 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayYByIndex functions. 4002 * @tc.type: FUNC 4003 */ 4004 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayYByIndex008, TestSize.Level1) 4005 { 4006 ArkUI_UIInputEvent setEvent; 4007 ArkUITouchEvent touchEvent; 4008 setEvent.inputEvent = &touchEvent; 4009 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 4010 ArkUITouchPoint points[2]; // 2 points 4011 ArkUITouchEvent* touchEventPtr = new ArkUITouchEvent(); 4012 touchEventPtr->touchPointes = points; 4013 touchEventPtr->touchPointSize = 2; 4014 setEvent.inputEvent = touchEventPtr; 4015 auto res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(nullptr, 0); 4016 EXPECT_EQ(res, 0); 4017 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4018 setEvent.eventTypeId = TOUCH_EVENT_ID; 4019 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4020 EXPECT_EQ(res, 0); 4021 ArkUIAxisEvent axisEvent; 4022 setEvent.inputEvent = &axisEvent; 4023 setEvent.eventTypeId = AXIS_EVENT_ID; 4024 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4025 EXPECT_EQ(res, 0); 4026 ArkUIMouseEvent mouseEvent; 4027 setEvent.inputEvent = &mouseEvent; 4028 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 4029 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4030 EXPECT_EQ(res, 0); 4031 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4032 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4033 EXPECT_EQ(res, 0); 4034 ArkUIKeyEvent keyEvent; 4035 setEvent.inputEvent = &keyEvent; 4036 setEvent.eventTypeId = C_KEY_EVENT_ID; 4037 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4038 EXPECT_EQ(res, 0); 4039 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4040 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4041 EXPECT_EQ(res, 0); 4042 ArkUIHoverEvent hoverEvent; 4043 setEvent.inputEvent = &hoverEvent; 4044 setEvent.eventTypeId = C_HOVER_EVENT_ID; 4045 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4046 EXPECT_EQ(res, 0); 4047 ArkUIClickEvent clickEvent; 4048 setEvent.inputEvent = &clickEvent; 4049 setEvent.eventTypeId = C_CLICK_EVENT_ID; 4050 res = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&setEvent, 0); 4051 EXPECT_EQ(res, 0); 4052 } 4053 4054 /** 4055 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayXByIndex008 4056 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayXByIndex functions. 4057 * @tc.type: FUNC 4058 */ 4059 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayXByIndex008, TestSize.Level1) 4060 { 4061 ArkUI_UIInputEvent setEvent; 4062 ArkUITouchEvent touchEvent; 4063 setEvent.inputEvent = &touchEvent; 4064 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 4065 ArkUITouchPoint points[2]; // 2 points 4066 ArkUITouchEvent* touchEventPtr = new ArkUITouchEvent(); 4067 touchEventPtr->touchPointes = points; 4068 touchEventPtr->touchPointSize = 2; 4069 setEvent.inputEvent = touchEventPtr; 4070 auto res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(nullptr, 0); 4071 EXPECT_EQ(res, 0); 4072 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4073 setEvent.eventTypeId = TOUCH_EVENT_ID; 4074 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4075 EXPECT_EQ(res, 0); 4076 ArkUIAxisEvent axisEvent; 4077 setEvent.inputEvent = &axisEvent; 4078 setEvent.eventTypeId = AXIS_EVENT_ID; 4079 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4080 EXPECT_EQ(res, 0); 4081 ArkUIMouseEvent mouseEvent; 4082 setEvent.inputEvent = &mouseEvent; 4083 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 4084 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4085 EXPECT_EQ(res, 0); 4086 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4087 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4088 EXPECT_EQ(res, 0); 4089 ArkUIKeyEvent keyEvent; 4090 setEvent.inputEvent = &keyEvent; 4091 setEvent.eventTypeId = C_KEY_EVENT_ID; 4092 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4093 EXPECT_EQ(res, 0); 4094 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4095 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4096 EXPECT_EQ(res, 0); 4097 ArkUIHoverEvent hoverEvent; 4098 setEvent.inputEvent = &hoverEvent; 4099 setEvent.eventTypeId = C_HOVER_EVENT_ID; 4100 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4101 EXPECT_EQ(res, 0); 4102 ArkUIClickEvent clickEvent; 4103 setEvent.inputEvent = &clickEvent; 4104 setEvent.eventTypeId = C_CLICK_EVENT_ID; 4105 res = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&setEvent, 0); 4106 EXPECT_EQ(res, 0); 4107 } 4108 4109 /** 4110 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX008 4111 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayX functions. 4112 * @tc.type: FUNC 4113 */ 4114 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX008, TestSize.Level1) 4115 { 4116 ArkUI_UIInputEvent setEvent; 4117 ArkUITouchEvent touchEvent; 4118 setEvent.inputEvent = &touchEvent; 4119 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 4120 ArkUITouchPoint points[2]; // 2 points 4121 ArkUITouchEvent* touchEventPtr = new ArkUITouchEvent(); 4122 touchEventPtr->touchPointes = points; 4123 touchEventPtr->touchPointSize = 2; 4124 setEvent.inputEvent = touchEventPtr; 4125 auto res = OH_ArkUI_PointerEvent_GetDisplayX(nullptr); 4126 EXPECT_EQ(res, 0); 4127 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4128 setEvent.eventTypeId = TOUCH_EVENT_ID; 4129 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4130 EXPECT_EQ(res, 0); 4131 ArkUIAxisEvent axisEvent; 4132 setEvent.inputEvent = &axisEvent; 4133 setEvent.eventTypeId = AXIS_EVENT_ID; 4134 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4135 EXPECT_EQ(res, 0); 4136 ArkUIMouseEvent mouseEvent; 4137 setEvent.inputEvent = &mouseEvent; 4138 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 4139 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4140 EXPECT_EQ(res, 0); 4141 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4142 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4143 EXPECT_EQ(res, 0); 4144 ArkUIKeyEvent keyEvent; 4145 setEvent.inputEvent = &keyEvent; 4146 setEvent.eventTypeId = C_KEY_EVENT_ID; 4147 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4148 EXPECT_EQ(res, 0); 4149 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4150 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4151 EXPECT_EQ(res, 0); 4152 ArkUIHoverEvent hoverEvent; 4153 setEvent.inputEvent = &hoverEvent; 4154 setEvent.eventTypeId = C_HOVER_EVENT_ID; 4155 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4156 EXPECT_EQ(res, 0); 4157 ArkUIClickEvent clickEvent; 4158 setEvent.inputEvent = &clickEvent; 4159 setEvent.eventTypeId = C_CLICK_EVENT_ID; 4160 res = OH_ArkUI_PointerEvent_GetDisplayX(&setEvent); 4161 EXPECT_EQ(res, 0); 4162 } 4163 4164 /** 4165 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayY008 4166 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayY functions. 4167 * @tc.type: FUNC 4168 */ 4169 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayY008, TestSize.Level1) 4170 { 4171 ArkUI_UIInputEvent setEvent; 4172 ArkUITouchEvent touchEvent; 4173 setEvent.inputEvent = &touchEvent; 4174 setEvent.eventTypeId = C_TOUCH_EVENT_ID; 4175 ArkUITouchPoint points[2]; // 2 points 4176 points[0].screenY = 3.0; 4177 points[1].screenY = 4.0; 4178 ArkUITouchEvent* touchEventPtr = new ArkUITouchEvent(); 4179 touchEventPtr->touchPointes = points; 4180 touchEventPtr->touchPointSize = 2; 4181 setEvent.inputEvent = touchEventPtr; 4182 auto res = OH_ArkUI_PointerEvent_GetDisplayY(nullptr); 4183 EXPECT_EQ(res, 0); 4184 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4185 setEvent.eventTypeId = TOUCH_EVENT_ID; 4186 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4187 EXPECT_EQ(res, 0); 4188 ArkUIAxisEvent axisEvent; 4189 setEvent.inputEvent = &axisEvent; 4190 setEvent.eventTypeId = AXIS_EVENT_ID; 4191 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4192 EXPECT_EQ(res, 0); 4193 ArkUIMouseEvent mouseEvent; 4194 setEvent.inputEvent = &mouseEvent; 4195 setEvent.eventTypeId = C_MOUSE_EVENT_ID; 4196 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4197 EXPECT_EQ(res, 0); 4198 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4199 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4200 EXPECT_EQ(res, 0); 4201 ArkUIKeyEvent keyEvent; 4202 setEvent.inputEvent = &keyEvent; 4203 setEvent.eventTypeId = C_KEY_EVENT_ID; 4204 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4205 EXPECT_EQ(res, 0); 4206 setEvent.eventTypeId = C_AXIS_EVENT_ID; 4207 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4208 EXPECT_EQ(res, 0); 4209 ArkUIHoverEvent hoverEvent; 4210 setEvent.inputEvent = &hoverEvent; 4211 setEvent.eventTypeId = C_HOVER_EVENT_ID; 4212 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4213 EXPECT_EQ(res, 0); 4214 ArkUIClickEvent clickEvent; 4215 setEvent.inputEvent = &clickEvent; 4216 setEvent.eventTypeId = C_CLICK_EVENT_ID; 4217 res = OH_ArkUI_PointerEvent_GetDisplayY(&setEvent); 4218 EXPECT_EQ(res, 0); 4219 } 4220 } // namespace OHOS::Ace