1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "../ui_input_event_test.h" 17 #include "interfaces/native/native_key_event.h" 18 #include "core/common/ace_application_info.h" 19 20 using namespace testing; 21 using namespace testing::ext; 22 23 // defined in ace_engine/interfaces/native/node/event_converter.cpp 24 namespace { 25 constexpr int32_t ORIGIN_TOUCH_ACTION_DOWN = 0; 26 constexpr int32_t ORIGIN_TOUCH_ACTION_UP = 1; 27 constexpr int32_t ORIGIN_TOUCH_ACTION_MOVE = 2; 28 constexpr int32_t ORIGIN_TOUCH_ACTION_CANCEL = 3; 29 constexpr int32_t ORIGIN_TOUCH_ACTION_LESS_THAN_LIMIT = ORIGIN_TOUCH_ACTION_DOWN - 1; 30 constexpr int32_t ORIGIN_TOUCH_ACTION_MORE_THAN_LIMIT = ORIGIN_TOUCH_ACTION_CANCEL + 1; 31 32 constexpr int32_t ORIGIN_MOUSE_ACTION_PRESS = 1; 33 constexpr int32_t ORIGIN_MOUSE_ACTION_RELEASE = 2; 34 constexpr int32_t ORIGIN_MOUSE_ACTION_MOVE = 3; 35 constexpr int32_t ORIGIN_MOUSE_ACTION_CANCEL = 13; 36 constexpr int32_t ORIGIN_MOUSE_ACTION_LESS_THAN_LIMIT = ORIGIN_MOUSE_ACTION_PRESS - 1; 37 constexpr int32_t ORIGIN_MOUSE_ACTION_MORE_THAN_LIMIT = ORIGIN_MOUSE_ACTION_CANCEL + 1; 38 39 constexpr int32_t ORIGIN_AXIS_ACTION_NONE = 0; 40 constexpr int32_t ORIGIN_AXIS_ACTION_BEGIN = 1; 41 constexpr int32_t ORIGIN_AXIS_ACTION_UPDATE = 2; 42 constexpr int32_t ORIGIN_AXIS_ACTION_END = 3; 43 constexpr int32_t ORIGIN_AXIS_ACTION_CANCEL = 4; 44 constexpr int32_t ORIGIN_AXIS_ACTION_LESS_THAN_LIMIT = ORIGIN_AXIS_ACTION_NONE - 1; 45 constexpr int32_t ORIGIN_AXIS_ACTION_MORE_THAN_LIMIT = ORIGIN_AXIS_ACTION_CANCEL + 1; 46 47 constexpr int32_t ARKUI_EVENT_ACTION_NULL = -1; 48 } // namespace 49 50 namespace OHOS::Ace { 51 /** 52 * @tc.name: OH_ArkUI_UIInputEvent_GetAction001 53 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 54 * @tc.type: FUNC 55 */ 56 57 58 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction001, TestSize.Level0) 59 { 60 /** 61 * @tc.steps: step1.call functions and return expected results. 62 */ 63 auto result = OH_ArkUI_UIInputEvent_GetAction(nullptr); 64 EXPECT_EQ(result, -1); 65 } 66 67 /** 68 * @tc.name: OH_ArkUI_UIInputEvent_GetAction101 69 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 70 * @tc.type: FUNC 71 */ 72 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction101, TestSize.Level0) 73 { 74 /** 75 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 76 */ 77 // 1 ArkUITouchEvent ConvertToCTouchActionType 78 ArkUITouchEvent inputEvent; 79 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 80 { ORIGIN_TOUCH_ACTION_DOWN, UI_TOUCH_EVENT_ACTION_DOWN }, 81 { ORIGIN_TOUCH_ACTION_UP, UI_TOUCH_EVENT_ACTION_UP }, 82 { ORIGIN_TOUCH_ACTION_MOVE, UI_TOUCH_EVENT_ACTION_MOVE }, 83 { ORIGIN_TOUCH_ACTION_CANCEL, UI_TOUCH_EVENT_ACTION_CANCEL }, 84 { ORIGIN_TOUCH_ACTION_LESS_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL }, 85 { ORIGIN_TOUCH_ACTION_MORE_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL } 86 }; 87 88 /** 89 * @tc.steps: step2. Init testCases and call functions. 90 * @tc.expected: Return expected results. 91 */ 92 auto count = 0; 93 for (auto testCase : testCases) { 94 inputEvent.action = testCase.first; 95 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_TOUCH_EVENT_ID, &inputEvent }; 96 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 97 EXPECT_EQ(result, testCase.second) 98 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 99 count++; 100 } 101 102 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_TOUCH_EVENT_ID, nullptr }; 103 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 104 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 105 } 106 107 /** 108 * @tc.name: OH_ArkUI_UIInputEvent_GetAction102 109 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 110 * @tc.type: FUNC 111 */ 112 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction102, TestSize.Level0) 113 { 114 /** 115 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 116 */ 117 // 2 ArkUIMouseEvent ConvertToCMouseActionType 118 ArkUIMouseEvent inputEvent; 119 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 120 { ORIGIN_MOUSE_ACTION_PRESS, UI_MOUSE_EVENT_ACTION_PRESS }, 121 { ORIGIN_MOUSE_ACTION_RELEASE, UI_MOUSE_EVENT_ACTION_RELEASE }, 122 { ORIGIN_MOUSE_ACTION_MOVE, UI_MOUSE_EVENT_ACTION_MOVE }, 123 { ORIGIN_MOUSE_ACTION_CANCEL, UI_MOUSE_EVENT_ACTION_CANCEL }, 124 { ORIGIN_MOUSE_ACTION_LESS_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN }, 125 { ORIGIN_MOUSE_ACTION_MORE_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN } 126 }; 127 128 /** 129 * @tc.steps: step2. Init testCases and call functions. 130 * @tc.expected: Return expected results. 131 */ 132 auto count = 0; 133 for (auto testCase : testCases) { 134 inputEvent.action = testCase.first; 135 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_MOUSE_EVENT_ID, &inputEvent }; 136 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 137 EXPECT_EQ(result, testCase.second) 138 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 139 count++; 140 } 141 142 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_MOUSE_EVENT_ID, nullptr }; 143 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 144 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 145 } 146 147 /** 148 * @tc.name: OH_ArkUI_UIInputEvent_GetAction103 149 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 150 * @tc.type: FUNC 151 */ 152 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction103, TestSize.Level0) 153 { 154 /** 155 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 156 */ 157 // 3 Other ArkUIEventTypeId 158 std::vector<ArkUIEventTypeId> typeIds = { 159 AXIS_EVENT_ID, 160 TOUCH_EVENT_ID, 161 C_AXIS_EVENT_ID, 162 C_KEY_EVENT_ID, 163 C_FOCUS_AXIS_EVENT_ID, 164 C_CLICK_EVENT_ID, 165 C_HOVER_EVENT_ID 166 }; 167 168 /** 169 * @tc.steps: step2. Init testCases and call functions. 170 * @tc.expected: Return expected results. 171 */ 172 auto count = 0; 173 for (auto typeId : typeIds) { 174 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, typeId, nullptr }; 175 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 176 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "other index = " << count; 177 count++; 178 } 179 } 180 181 /** 182 * @tc.name: OH_ArkUI_UIInputEvent_GetAction201 183 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 184 * @tc.type: FUNC 185 */ 186 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction201, TestSize.Level0) 187 { 188 /** 189 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 190 */ 191 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 192 // 1 ArkUITouchEvent ConvertToCTouchActionType 193 ArkUITouchEvent inputEvent; 194 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 195 { ORIGIN_TOUCH_ACTION_DOWN, UI_TOUCH_EVENT_ACTION_DOWN }, 196 { ORIGIN_TOUCH_ACTION_UP, UI_TOUCH_EVENT_ACTION_UP }, 197 { ORIGIN_TOUCH_ACTION_MOVE, UI_TOUCH_EVENT_ACTION_MOVE }, 198 { ORIGIN_TOUCH_ACTION_CANCEL, UI_TOUCH_EVENT_ACTION_CANCEL }, 199 { ORIGIN_TOUCH_ACTION_LESS_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL }, 200 { ORIGIN_TOUCH_ACTION_MORE_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL } 201 }; 202 203 /** 204 * @tc.steps: step2. Init testCases and call functions. 205 * @tc.expected: Return expected results. 206 */ 207 auto count = 0; 208 for (auto testCase : testCases) { 209 inputEvent.action = testCase.first; 210 auto uiInputEvent = 211 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_TOUCH_EVENT_ID, &inputEvent, false, apiVersion }; 212 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 213 EXPECT_EQ(result, testCase.second) 214 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 215 count++; 216 } 217 218 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_TOUCH_EVENT_ID, nullptr }; 219 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 220 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 221 } 222 223 /** 224 * @tc.name: OH_ArkUI_UIInputEvent_GetAction202 225 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 226 * @tc.type: FUNC 227 */ 228 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction202, TestSize.Level0) 229 { 230 /** 231 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 232 */ 233 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 234 // 2 ArkUIMouseEvent ConvertToCMouseActionType 235 ArkUIMouseEvent inputEvent; 236 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 237 { ORIGIN_MOUSE_ACTION_PRESS, UI_MOUSE_EVENT_ACTION_PRESS }, 238 { ORIGIN_MOUSE_ACTION_RELEASE, UI_MOUSE_EVENT_ACTION_RELEASE }, 239 { ORIGIN_MOUSE_ACTION_MOVE, UI_MOUSE_EVENT_ACTION_MOVE }, 240 { ORIGIN_MOUSE_ACTION_CANCEL, UI_MOUSE_EVENT_ACTION_CANCEL }, 241 { ORIGIN_MOUSE_ACTION_LESS_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN }, 242 { ORIGIN_MOUSE_ACTION_MORE_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN } 243 }; 244 245 /** 246 * @tc.steps: step2. Init testCases and call functions. 247 * @tc.expected: Return expected results. 248 */ 249 auto count = 0; 250 for (auto testCase : testCases) { 251 inputEvent.action = testCase.first; 252 auto uiInputEvent = 253 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_MOUSE_EVENT_ID, &inputEvent, false, apiVersion }; 254 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 255 EXPECT_EQ(result, testCase.second) 256 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 257 count++; 258 } 259 260 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_MOUSE_EVENT_ID, nullptr }; 261 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 262 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 263 } 264 265 /** 266 * @tc.name: OH_ArkUI_UIInputEvent_GetAction203 267 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 268 * @tc.type: FUNC 269 */ 270 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction203, TestSize.Level0) 271 { 272 /** 273 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 274 */ 275 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 276 // 3 ArkUIAxisEvent ConvertToCAxisActionType 277 ArkUIAxisEvent inputEvent; 278 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 279 { ORIGIN_AXIS_ACTION_NONE, UI_AXIS_EVENT_ACTION_NONE }, 280 { ORIGIN_AXIS_ACTION_BEGIN, UI_AXIS_EVENT_ACTION_BEGIN }, 281 { ORIGIN_AXIS_ACTION_UPDATE, UI_AXIS_EVENT_ACTION_UPDATE }, 282 { ORIGIN_AXIS_ACTION_END, UI_AXIS_EVENT_ACTION_END }, 283 { ORIGIN_AXIS_ACTION_CANCEL, UI_AXIS_EVENT_ACTION_CANCEL }, 284 { ORIGIN_AXIS_ACTION_LESS_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN }, 285 { ORIGIN_AXIS_ACTION_MORE_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN } 286 }; 287 288 /** 289 * @tc.steps: step2. Init testCases and call functions. 290 * @tc.expected: Return expected results. 291 */ 292 auto count = 0; 293 for (auto testCase : testCases) { 294 inputEvent.action = testCase.first; 295 auto uiInputEvent = 296 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_AXIS_EVENT_ID, &inputEvent, false, apiVersion }; 297 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 298 EXPECT_EQ(result, testCase.second) 299 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 300 count++; 301 } 302 303 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_AXIS_EVENT_ID, nullptr }; 304 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 305 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 306 } 307 308 /** 309 * @tc.name: OH_ArkUI_UIInputEvent_GetAction204 310 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 311 * @tc.type: FUNC 312 */ 313 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction204, TestSize.Level0) 314 { 315 /** 316 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 317 */ 318 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 319 // 4 ArkUIKeyEvent ConvertToCKeyActionType 320 ArkUIKeyEvent inputEvent; 321 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 322 { ORIGIN_TOUCH_ACTION_DOWN, ARKUI_KEY_EVENT_DOWN }, 323 { ORIGIN_TOUCH_ACTION_UP, ARKUI_KEY_EVENT_UP }, 324 { ORIGIN_TOUCH_ACTION_MOVE, ARKUI_KEY_EVENT_UNKNOWN }, 325 { ORIGIN_TOUCH_ACTION_CANCEL, ARKUI_KEY_EVENT_UNKNOWN }, 326 { ORIGIN_TOUCH_ACTION_LESS_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL }, 327 { ORIGIN_TOUCH_ACTION_MORE_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL } 328 }; 329 330 /** 331 * @tc.steps: step2. Init testCases and call functions. 332 * @tc.expected: Return expected results. 333 */ 334 auto count = 0; 335 for (auto testCase : testCases) { 336 inputEvent.type = testCase.first; 337 auto uiInputEvent = 338 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_CLICK_EVENT_ID, &inputEvent, false, apiVersion }; 339 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 340 EXPECT_EQ(result, testCase.second) 341 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 342 count++; 343 } 344 345 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, C_CLICK_EVENT_ID, nullptr }; 346 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 347 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 348 } 349 350 /** 351 * @tc.name: OH_ArkUI_UIInputEvent_GetAction205 352 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 353 * @tc.type: FUNC 354 */ 355 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction205, TestSize.Level0) 356 { 357 /** 358 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 359 */ 360 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 361 // 5 OHOS::Ace::TouchEvent ConvertToCTouchActionType 362 OHOS::Ace::TouchEvent inputEvent; 363 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 364 { ORIGIN_TOUCH_ACTION_DOWN, UI_TOUCH_EVENT_ACTION_DOWN }, 365 { ORIGIN_TOUCH_ACTION_UP, UI_TOUCH_EVENT_ACTION_UP }, 366 { ORIGIN_TOUCH_ACTION_MOVE, UI_TOUCH_EVENT_ACTION_MOVE }, 367 { ORIGIN_TOUCH_ACTION_CANCEL, UI_TOUCH_EVENT_ACTION_CANCEL }, 368 { ORIGIN_TOUCH_ACTION_LESS_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL }, 369 { ORIGIN_TOUCH_ACTION_MORE_THAN_LIMIT, ARKUI_EVENT_ACTION_NULL } 370 }; 371 372 /** 373 * @tc.steps: step2. Init testCases and call functions. 374 * @tc.expected: Return expected results. 375 */ 376 auto count = 0; 377 for (auto testCase : testCases) { 378 inputEvent.type = static_cast<TouchType>(testCase.first); 379 auto uiInputEvent = 380 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, TOUCH_EVENT_ID, &inputEvent, false, apiVersion }; 381 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 382 EXPECT_EQ(result, testCase.second) 383 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 384 count++; 385 } 386 387 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, TOUCH_EVENT_ID, nullptr }; 388 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 389 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 390 } 391 392 /** 393 * @tc.name: OH_ArkUI_UIInputEvent_GetAction206 394 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction206, TestSize.Level0) 398 { 399 /** 400 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 401 */ 402 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 403 // 6 OHOS::Ace::AxisEvent ConvertToCAxisActionType 404 OHOS::Ace::AxisEvent inputEvent; 405 std::vector<std::pair<ArkUI_Int32, int32_t>> testCases = { 406 { ORIGIN_AXIS_ACTION_NONE, UI_AXIS_EVENT_ACTION_NONE }, 407 { ORIGIN_AXIS_ACTION_BEGIN, UI_AXIS_EVENT_ACTION_BEGIN }, 408 { ORIGIN_AXIS_ACTION_UPDATE, UI_AXIS_EVENT_ACTION_UPDATE }, 409 { ORIGIN_AXIS_ACTION_END, UI_AXIS_EVENT_ACTION_END }, 410 { ORIGIN_AXIS_ACTION_CANCEL, UI_AXIS_EVENT_ACTION_CANCEL }, 411 { ORIGIN_AXIS_ACTION_LESS_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN }, 412 { ORIGIN_AXIS_ACTION_MORE_THAN_LIMIT, UI_MOUSE_EVENT_ACTION_UNKNOWN } 413 }; 414 415 /** 416 * @tc.steps: step2. Init testCases and call functions. 417 * @tc.expected: Return expected results. 418 */ 419 auto count = 0; 420 for (auto testCase : testCases) { 421 inputEvent.action = static_cast<AxisAction>(testCase.first); 422 auto uiInputEvent = 423 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, AXIS_EVENT_ID, &inputEvent, false, apiVersion }; 424 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 425 EXPECT_EQ(result, testCase.second) 426 << "index = " << count << " : originAction = " << testCase.first << " , result = " << result; 427 count++; 428 } 429 430 431 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, AXIS_EVENT_ID, nullptr }; 432 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 433 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "index = " << count; 434 } 435 436 /** 437 * @tc.name: OH_ArkUI_UIInputEvent_GetAction207 438 * @tc.desc: Test the OH_ArkUI_UIInputEvent_GetAction function. 439 * @tc.type: FUNC 440 */ 441 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction207, TestSize.Level0) 442 { 443 /** 444 * @tc.steps: step1.create and init ArkUI_UIInputEvent. 445 */ 446 const int32_t apiVersion = static_cast<int32_t>(OHOS::Ace::PlatformVersion::VERSION_TWENTY); 447 // 6 Other ArkUIEventTypeId 448 std::vector<ArkUIEventTypeId> typeIds = { 449 C_KEY_EVENT_ID, 450 C_FOCUS_AXIS_EVENT_ID, 451 C_HOVER_EVENT_ID 452 }; 453 454 /** 455 * @tc.steps: step2. Init testCases and call functions. 456 * @tc.expected: Return expected results. 457 */ 458 auto count = 0; 459 for (auto typeId : typeIds) { 460 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, typeId, nullptr, false, apiVersion }; 461 auto result = OH_ArkUI_UIInputEvent_GetAction(&uiInputEvent); 462 EXPECT_EQ(result, ARKUI_EVENT_ACTION_NULL) << "other index = " << count; 463 count++; 464 } 465 } 466 467 } // namespace OHOS::Ace