1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #include <cstdint> 16 #include <iostream> 17 18 #include "gtest/gtest.h" 19 #include "securec.h" 20 #define private public 21 #define protected public 22 #include "native_key_event.h" 23 #include "event_converter.h" 24 #include "native_interface.h" 25 #include "native_node.h" 26 #include "native_type.h" 27 #include "node_model.h" 28 #include "ui_input_event.h" 29 #include "event/ui_input_event_impl.h" 30 #include "test/mock/base/mock_task_executor.h" 31 #include "test/mock/core/common/mock_container.h" 32 #include "test/mock/core/common/mock_theme_manager.h" 33 #include "test/mock/core/pipeline/mock_pipeline_context.h" 34 35 using namespace testing; 36 using namespace testing::ext; 37 namespace OHOS::Ace { 38 namespace { 39 constexpr uint32_t ARKUI_UNICODE = 98; 40 constexpr int32_t ARKUI_DEVICE_ID = 1; 41 constexpr uint64_t ARKUI_TIME = 20; 42 const char* ARKUI_KEY_TEXT = "k"; 43 } // namespace 44 class NativeKeyEventTest : public testing::Test { 45 public: SetUpTestSuite()46 static void SetUpTestSuite() 47 { 48 NG::MockPipelineContext::SetUp(); 49 MockContainer::SetUp(); 50 MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent(); 51 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>(); 52 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_; 53 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 54 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 55 } TearDownTestSuite()56 static void TearDownTestSuite() 57 { 58 NG::MockPipelineContext::TearDown(); 59 MockContainer::TearDown(); 60 } SetUp()61 void SetUp() {} TearDown()62 void TearDown() {} 63 }; 64 65 /** 66 * @tc.name: NativeKeyEventTest001 67 * @tc.desc: test NODE_ON_KEY_EVENT; 68 * @tc.type: FUNC 69 */ 70 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest001, TestSize.Level1) 71 { 72 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 73 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 74 ASSERT_NE(nodeAPI, nullptr); 75 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 76 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 77 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 78 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 79 nodeAPI->unregisterNodeEvent(nullptr, NODE_ON_KEY_EVENT); 80 nodeAPI->unregisterNodeEvent(node, NODE_ON_KEY_EVENT); 81 nodeAPI->disposeNode(node); 82 } 83 84 /** 85 * @tc.name: NativeKeyEventTest002 86 * @tc.desc: test NODE_ON_KEY_PRE_IME; 87 * @tc.type: FUNC 88 */ 89 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest002, TestSize.Level1) 90 { 91 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 92 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 93 ASSERT_NE(nodeAPI, nullptr); 94 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 95 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 96 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 97 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 98 nodeAPI->unregisterNodeEvent(nullptr, NODE_ON_KEY_PRE_IME); 99 nodeAPI->unregisterNodeEvent(node, NODE_ON_KEY_PRE_IME); 100 nodeAPI->disposeNode(node); 101 } 102 103 /** 104 * @tc.name: NativeKeyEventTest003 105 * @tc.desc: Test OH_ArkUI_KeyEvent_GetType function. 106 * @tc.type: FUNC 107 */ 108 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest003, TestSize.Level1) 109 { 110 /** 111 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 112 */ 113 ArkUI_NodeEvent event = { 1, 0 }; 114 event.origin = nullptr; 115 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 116 auto type = OH_ArkUI_KeyEvent_GetType(uiInputEvent); 117 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UNKNOWN); 118 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 119 120 /** 121 * @tc.steps: step2.create null KeyEvent, related function is called. 122 */ 123 ArkUI_NodeEvent nodeEvent; 124 ArkUI_UIInputEvent nullUiInputEvent; 125 nullUiInputEvent.inputEvent = nullptr; 126 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 127 nodeEvent.origin = &nullUiInputEvent; 128 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 129 type = OH_ArkUI_KeyEvent_GetType(uiInputEvent); 130 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UNKNOWN); 131 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 132 } 133 134 /** 135 * @tc.name: NativeKeyEventTest004 136 * @tc.desc: Test the KeyEvent property functions. 137 * @tc.type: FUNC 138 */ 139 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest004, TestSize.Level1) 140 { 141 /** 142 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 143 */ 144 ArkUI_NodeEvent nodeEvent; 145 ArkUINodeEvent event; 146 ArkUI_UIInputEvent uiInputEvent; 147 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 148 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 149 event.keyEvent.type = static_cast<ArkUI_Int32>(OHOS::Ace::KeyAction::UP); 150 event.keyEvent.keyCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyCode::KEY_VOLUME_UP); 151 event.keyEvent.keySource = static_cast<ArkUI_Int32>(OHOS::Ace::SourceType::MOUSE); 152 event.keyEvent.intentionCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyIntention::INTENTION_UP); 153 event.keyEvent.unicode = ARKUI_UNICODE; 154 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 155 event.keyEvent.timestamp = ARKUI_TIME; 156 std::size_t n = std::min(std::strlen(ARKUI_KEY_TEXT), sizeof(event.keyEvent.keyText) - 1); 157 errno_t ret = strncpy_s(event.keyEvent.keyText, sizeof(event.keyEvent.keyText), ARKUI_KEY_TEXT, n); 158 ASSERT_EQ(ret, 0); 159 event.keyEvent.keyText[n] = '\0'; 160 uiInputEvent.inputEvent = &event.keyEvent; 161 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 162 nodeEvent.origin = &uiInputEvent; 163 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 164 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 165 166 /** 167 * @tc.steps: step2. call functions. 168 */ 169 auto type = OH_ArkUI_KeyEvent_GetType(inputEvent); 170 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 171 auto code = OH_ArkUI_KeyEvent_GetKeyCode(inputEvent); 172 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 173 auto keySource = OH_ArkUI_KeyEvent_GetKeySource(inputEvent); 174 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 175 auto intensionCode = OH_ArkUI_KeyEvent_GetKeyIntensionCode(inputEvent); 176 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 177 auto unicode = OH_ArkUI_KeyEvent_GetUnicode(inputEvent); 178 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 179 auto diviceId = OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent); 180 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 181 auto time = OH_ArkUI_UIInputEvent_GetEventTime(inputEvent); 182 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 183 auto keyText = OH_ArkUI_KeyEvent_GetKeyText(inputEvent); 184 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 185 186 /** 187 * @tc.expected: Return expected results. 188 */ 189 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UP); 190 EXPECT_EQ(code, ArkUI_KeyCode::ARKUI_KEYCODE_VOLUME_UP); 191 EXPECT_EQ(keySource, ArkUI_KeySourceType::ARKUI_KEY_SOURCE_TYPE_MOUSE); 192 EXPECT_EQ(intensionCode, ArkUI_KeyIntension::ARKUI_KEY_INTENSION_UP); 193 EXPECT_EQ(unicode, ARKUI_UNICODE); 194 EXPECT_EQ(diviceId, ARKUI_DEVICE_ID); 195 EXPECT_EQ(time, ARKUI_TIME); 196 EXPECT_NE(keyText, nullptr); 197 } 198 199 /** 200 * @tc.name: NativeKeyEventTest005 201 * @tc.desc: test NODE_DISPATCH_KEY_EVENT; 202 * @tc.type: FUNC 203 */ 204 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest005, TestSize.Level1) 205 { 206 /** 207 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 208 */ 209 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 210 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 211 ASSERT_NE(nodeAPI, nullptr); 212 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 213 214 /** 215 * @tc.steps: step2. call functions. 216 */ 217 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 218 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 219 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 220 nodeAPI->unregisterNodeEvent(nullptr, NODE_DISPATCH_KEY_EVENT); 221 nodeAPI->unregisterNodeEvent(node, NODE_DISPATCH_KEY_EVENT); 222 nodeAPI->disposeNode(node); 223 } 224 225 /** 226 * @tc.name: NativeKeyEventTest007 227 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyCode function. 228 * @tc.type: FUNC 229 */ 230 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest007, TestSize.Level1) 231 { 232 /** 233 * @tc.steps: step1.create null UIInputEvent, function will return -1. 234 */ 235 ArkUI_NodeEvent event = { 1, 0 }; 236 event.origin = nullptr; 237 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 238 auto type = OH_ArkUI_KeyEvent_GetKeyCode(uiInputEvent); 239 EXPECT_EQ(type, -1); 240 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 241 242 /** 243 * @tc.steps: step2.create null KeyEvent, function will return -1. 244 */ 245 ArkUI_NodeEvent nodeEvent; 246 ArkUI_UIInputEvent nullUiInputEvent; 247 nullUiInputEvent.inputEvent = nullptr; 248 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 249 nodeEvent.origin = &nullUiInputEvent; 250 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 251 type = OH_ArkUI_KeyEvent_GetKeyCode(uiInputEvent); 252 EXPECT_EQ(type, -1); 253 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 254 } 255 256 /** 257 * @tc.name: NativeKeyEventTest008 258 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyText function. 259 * @tc.type: FUNC 260 */ 261 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest008, TestSize.Level1) 262 { 263 /** 264 * @tc.steps: step1.create null UIInputEvent, function will return null. 265 */ 266 ArkUI_NodeEvent event = { 1, 0 }; 267 event.origin = nullptr; 268 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 269 auto type = OH_ArkUI_KeyEvent_GetKeyText(uiInputEvent); 270 EXPECT_EQ(type, nullptr); 271 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 272 273 /** 274 * @tc.steps: step2.create null KeyEvent, function will return null. 275 */ 276 ArkUI_NodeEvent nodeEvent; 277 ArkUI_UIInputEvent nullUiInputEvent; 278 nullUiInputEvent.inputEvent = nullptr; 279 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 280 nodeEvent.origin = &nullUiInputEvent; 281 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 282 type = OH_ArkUI_KeyEvent_GetKeyText(uiInputEvent); 283 EXPECT_EQ(type, nullptr); 284 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 285 } 286 287 /** 288 * @tc.name: NativeKeyEventTest009 289 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeySource function. 290 * @tc.type: FUNC 291 */ 292 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest009, TestSize.Level1) 293 { 294 /** 295 * @tc.steps: step1.create null UIInputEvent, function will return -1. 296 */ 297 ArkUI_NodeEvent event = { 1, 0 }; 298 event.origin = nullptr; 299 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 300 auto type = OH_ArkUI_KeyEvent_GetKeySource(uiInputEvent); 301 EXPECT_EQ(type, -1); 302 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 303 304 /** 305 * @tc.steps: step2.create null KeyEvent, function will return -1. 306 */ 307 ArkUI_NodeEvent nodeEvent; 308 ArkUI_UIInputEvent nullUiInputEvent; 309 nullUiInputEvent.inputEvent = nullptr; 310 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 311 nodeEvent.origin = &nullUiInputEvent; 312 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 313 type = OH_ArkUI_KeyEvent_GetKeySource(uiInputEvent); 314 EXPECT_EQ(type, -1); 315 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 316 } 317 318 /** 319 * @tc.name: NativeKeyEventTest0010 320 * @tc.desc: Test OH_ArkUI_KeyEvent_StopPropagation function. 321 * @tc.type: FUNC 322 */ 323 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0010, TestSize.Level1) 324 { 325 /** 326 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called and stopPropagation is true. 327 */ 328 ArkUI_NodeEvent nodeEvent; 329 ArkUINodeEvent event; 330 ArkUI_UIInputEvent uiInputEvent; 331 event.keyEvent.stopPropagation = false; 332 uiInputEvent.inputEvent = &event.keyEvent; 333 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 334 nodeEvent.origin = &uiInputEvent; 335 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 336 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, true); 337 EXPECT_EQ(event.keyEvent.stopPropagation, true); 338 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 339 340 /** 341 * @tc.steps: step2.create null UIInputEvent, related function is called and stopPropagation is true. 342 */ 343 nodeEvent.origin = nullptr; 344 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 345 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, false); 346 EXPECT_EQ(event.keyEvent.stopPropagation, true); 347 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 348 349 /** 350 * @tc.steps: step2.create null KeyEvent, related function is called and stopPropagation is true. 351 */ 352 uiInputEvent.inputEvent = nullptr; 353 nodeEvent.origin = &uiInputEvent; 354 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 355 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, false); 356 EXPECT_EQ(event.keyEvent.stopPropagation, true); 357 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 358 } 359 360 /** 361 * @tc.name: NativeKeyEventTest0011 362 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyIntensionCode function. 363 * @tc.type: FUNC 364 */ 365 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0011, TestSize.Level1) 366 { 367 /** 368 * @tc.steps: step1.create null UIInputEvent, function will return -1. 369 */ 370 ArkUI_NodeEvent event = { 1, 0 }; 371 event.origin = nullptr; 372 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 373 auto type = OH_ArkUI_KeyEvent_GetKeyIntensionCode(uiInputEvent); 374 EXPECT_EQ(type, -1); 375 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 376 377 /** 378 * @tc.steps: step2.create null KeyEvent, function will return -1. 379 */ 380 ArkUI_NodeEvent nodeEvent; 381 ArkUI_UIInputEvent nullUiInputEvent; 382 nullUiInputEvent.inputEvent = nullptr; 383 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 384 nodeEvent.origin = &nullUiInputEvent; 385 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 386 type = OH_ArkUI_KeyEvent_GetKeyIntensionCode(uiInputEvent); 387 EXPECT_EQ(type, -1); 388 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 389 } 390 391 /** 392 * @tc.name: NativeKeyEventTest0012 393 * @tc.desc: Test OH_ArkUI_KeyEvent_GetUnicode function. 394 * @tc.type: FUNC 395 */ 396 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0012, TestSize.Level1) 397 { 398 /** 399 * @tc.steps: step1.create null UIInputEvent, function will return 0. 400 */ 401 ArkUI_NodeEvent event = { 1, 0 }; 402 event.origin = nullptr; 403 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 404 auto type = OH_ArkUI_KeyEvent_GetUnicode(uiInputEvent); 405 EXPECT_EQ(type, 0); 406 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 407 408 /** 409 * @tc.steps: step2.create null KeyEvent, function will return 0. 410 */ 411 ArkUI_NodeEvent nodeEvent; 412 ArkUI_UIInputEvent nullUiInputEvent; 413 nullUiInputEvent.inputEvent = nullptr; 414 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 415 nodeEvent.origin = &nullUiInputEvent; 416 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 417 type = OH_ArkUI_KeyEvent_GetUnicode(uiInputEvent); 418 EXPECT_EQ(type, 0); 419 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 420 } 421 422 /** 423 * @tc.name: NativeKeyEventTest0013 424 * @tc.desc: Test OH_ArkUI_KeyEvent_SetConsumed function. 425 * @tc.type: FUNC 426 */ 427 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0013, TestSize.Level1) 428 { 429 /** 430 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called and stopPropagation is true. 431 */ 432 ArkUI_NodeEvent nodeEvent; 433 ArkUINodeEvent event; 434 ArkUI_UIInputEvent uiInputEvent; 435 event.keyEvent.stopPropagation = false; 436 uiInputEvent.inputEvent = &event.keyEvent; 437 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 438 nodeEvent.origin = &uiInputEvent; 439 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 440 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, true); 441 EXPECT_EQ(event.keyEvent.isConsumed, true); 442 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 443 444 /** 445 * @tc.steps: step2.create null UIInputEvent, related function is called and stopPropagation is true. 446 */ 447 nodeEvent.origin = nullptr; 448 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 449 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, false); 450 EXPECT_EQ(event.keyEvent.isConsumed, true); 451 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 452 453 /** 454 * @tc.steps: step2.create null KeyEvent, related function is called and stopPropagation is true. 455 */ 456 uiInputEvent.inputEvent = nullptr; 457 nodeEvent.origin = &uiInputEvent; 458 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 459 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, false); 460 EXPECT_EQ(event.keyEvent.isConsumed, true); 461 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 462 } 463 464 /** 465 * @tc.name: NativeKeyEventTest0014 466 * @tc.desc: Test OH_ArkUI_KeyEvent_Dispatch function. 467 * @tc.type: FUNC 468 */ 469 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0014, TestSize.Level1) 470 { 471 /** 472 * @tc.steps: step1. create node. 473 */ 474 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 475 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 476 ASSERT_NE(nodeAPI, nullptr); 477 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 478 479 /** 480 * @tc.steps: step2.create null UIInputEvent, flag is false. 481 */ 482 ArkUI_NodeEvent nodeEvent; 483 ArkUINodeEvent event; 484 ArkUI_UIInputEvent uiInputEvent; 485 event.keyEvent.stopPropagation = true; 486 uiInputEvent.inputEvent = &event.keyEvent; 487 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 488 nodeEvent.origin = nullptr; 489 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 490 491 bool flag = false; 492 nodeAPI->registerNodeEvent(node, NODE_DISPATCH_KEY_EVENT, 0, &flag); __anon95a9941a0202(ArkUI_NodeEvent* event) 493 NodeModel::AddNodeEventReceiver(node, [](ArkUI_NodeEvent* event) { 494 auto userData = reinterpret_cast<bool*>(event->userData); 495 *userData = true; 496 }); 497 auto* frameNode = reinterpret_cast<NG::FrameNode*>(node->uiNodeHandle); 498 frameNode->GetOrCreateFocusHub()->currentFocus_ = true; 499 OH_ArkUI_KeyEvent_Dispatch(node, inputEvent); 500 EXPECT_EQ(flag, false); 501 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 502 503 /** 504 * @tc.steps: step2.create null KeyEvent, flag is false. 505 */ 506 uiInputEvent.inputEvent = nullptr; 507 nodeEvent.origin = &uiInputEvent; 508 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 509 OH_ArkUI_KeyEvent_Dispatch(node, inputEvent); 510 nodeAPI->unregisterNodeEvent(node, NODE_DISPATCH_KEY_EVENT); 511 NodeModel::DisposeNode(node); 512 EXPECT_EQ(flag, false); 513 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 514 } 515 516 /** 517 * @tc.name: NativeKeyEventTest0015 518 * @tc.desc: Test OH_ArkUI_KeyEvent_IsNumLockOn function. 519 * @tc.type: FUNC 520 */ 521 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0015, TestSize.Level1) 522 { 523 /** 524 * @tc.steps: step1. create node. 525 */ 526 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 527 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 528 ASSERT_NE(nodeAPI, nullptr); 529 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 530 nodeAPI->registerNodeEvent(node, NODE_ON_KEY_EVENT, 0, nullptr); 531 532 /** 533 * @tc.steps: step2.create null UIInputEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 534 */ 535 ArkUI_NodeEvent nodeEvent; 536 ArkUINodeEvent event; 537 ArkUI_UIInputEvent uiInputEvent; 538 event.keyEvent.isNumLockOn = true; 539 uiInputEvent.inputEvent = &event.keyEvent; 540 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 541 nodeEvent.origin = nullptr; 542 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 543 544 bool isNumLockOnState = false; 545 auto returnValue = OH_ArkUI_KeyEvent_IsNumLockOn(inputEvent, &isNumLockOnState); 546 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 547 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 548 549 /** 550 * @tc.steps: step2.create null KeyEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 551 */ 552 uiInputEvent.inputEvent = nullptr; 553 nodeEvent.origin = &uiInputEvent; 554 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 555 returnValue = OH_ArkUI_KeyEvent_IsNumLockOn(inputEvent, &isNumLockOnState); 556 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 557 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 558 559 /** 560 * @tc.steps: step3.create inputEvent and KeyEvent, returnValue is ARKUI_ERROR_CODE_NO_ERROR. 561 */ 562 uiInputEvent.inputEvent = &event.keyEvent; 563 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 564 nodeEvent.origin = &uiInputEvent; 565 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 566 returnValue = OH_ArkUI_KeyEvent_IsNumLockOn(inputEvent, &isNumLockOnState); 567 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_NO_ERROR); 568 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 569 } 570 571 /** 572 * @tc.name: NativeKeyEventTest0016 573 * @tc.desc: Test OH_ArkUI_KeyEvent_IsCapsLockOn function. 574 * @tc.type: FUNC 575 */ 576 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0016, TestSize.Level1) 577 { 578 /** 579 * @tc.steps: step1. create node. 580 */ 581 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 582 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 583 ASSERT_NE(nodeAPI, nullptr); 584 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 585 nodeAPI->registerNodeEvent(node, NODE_ON_KEY_EVENT, 0, nullptr); 586 587 /** 588 * @tc.steps: step2.create null UIInputEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 589 */ 590 ArkUI_NodeEvent nodeEvent; 591 ArkUINodeEvent event; 592 ArkUI_UIInputEvent uiInputEvent; 593 event.keyEvent.isNumLockOn = true; 594 uiInputEvent.inputEvent = &event.keyEvent; 595 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 596 nodeEvent.origin = nullptr; 597 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 598 599 bool isNumLockOnState = false; 600 auto returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 601 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 602 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 603 604 /** 605 * @tc.steps: step2.create null KeyEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 606 */ 607 uiInputEvent.inputEvent = nullptr; 608 nodeEvent.origin = &uiInputEvent; 609 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 610 returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 611 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 612 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 613 614 /** 615 * @tc.steps: step3.create inputEvent and KeyEvent, returnValue is ARKUI_ERROR_CODE_NO_ERROR. 616 */ 617 uiInputEvent.inputEvent = &event.keyEvent; 618 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 619 nodeEvent.origin = &uiInputEvent; 620 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 621 returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 622 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_NO_ERROR); 623 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 624 } 625 626 /** 627 * @tc.name: NativeKeyEventTest0017 628 * @tc.desc: Test OH_ArkUI_KeyEvent_IsCapsLockOn function. 629 * @tc.type: FUNC 630 */ 631 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0017, TestSize.Level1) 632 { 633 /** 634 * @tc.steps: step1. create node. 635 */ 636 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 637 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 638 ASSERT_NE(nodeAPI, nullptr); 639 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 640 nodeAPI->registerNodeEvent(node, NODE_ON_KEY_EVENT, 0, nullptr); 641 642 /** 643 * @tc.steps: step2.create null UIInputEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 644 */ 645 ArkUI_NodeEvent nodeEvent; 646 ArkUINodeEvent event; 647 ArkUI_UIInputEvent uiInputEvent; 648 event.keyEvent.isNumLockOn = true; 649 uiInputEvent.inputEvent = &event.keyEvent; 650 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 651 nodeEvent.origin = nullptr; 652 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 653 654 bool isNumLockOnState = false; 655 auto returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 656 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 657 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 658 659 /** 660 * @tc.steps: step2.create null KeyEvent, returnValue is ARKUI_ERROR_CODE_PARAM_INVALID. 661 */ 662 uiInputEvent.inputEvent = nullptr; 663 nodeEvent.origin = &uiInputEvent; 664 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 665 returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 666 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_PARAM_INVALID); 667 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_PARAM_INVALID); 668 669 /** 670 * @tc.steps: step3.create inputEvent and KeyEvent, returnValue is ARKUI_ERROR_CODE_NO_ERROR. 671 */ 672 uiInputEvent.inputEvent = &event.keyEvent; 673 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 674 nodeEvent.origin = &uiInputEvent; 675 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 676 returnValue = OH_ArkUI_KeyEvent_IsCapsLockOn(inputEvent, &isNumLockOnState); 677 EXPECT_EQ(returnValue, ARKUI_ERROR_CODE_NO_ERROR); 678 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetLatestStatus(), ARKUI_ERROR_CODE_NO_ERROR); 679 } 680 681 /** 682 * @tc.name: NativeKeyEventTest0018 683 * @tc.desc: Test OH_ArkUI_KeyEvent_IsScrollLockOn function. 684 * @tc.type: FUNC 685 */ 686 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0018, TestSize.Level1) 687 { 688 /** 689 * @tc.steps: step1. create node. 690 */ 691 ArkUI_NodeEvent nodeEvent; 692 ArkUINodeEvent event; 693 ArkUI_UIInputEvent uiInputEvent; 694 event.keyEvent.stopPropagation = true; 695 uiInputEvent.inputEvent = &event.keyEvent; 696 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 697 nodeEvent.origin = nullptr; 698 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 699 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 700 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 701 ASSERT_NE(nodeAPI, nullptr); 702 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 703 704 /** 705 * @tc.steps: step2.related function is called, flag is false. 706 */ 707 bool flag = false; 708 nodeAPI->registerNodeEvent(node, NODE_DISPATCH_KEY_EVENT, 0, &flag); __anon95a9941a0302(ArkUI_NodeEvent* event) 709 NodeModel::AddNodeEventReceiver(node, [](ArkUI_NodeEvent* event) { 710 auto userData = reinterpret_cast<bool*>(event->userData); 711 *userData = true; 712 }); 713 ArkUI_ErrorCode ret = OH_ArkUI_KeyEvent_IsScrollLockOn(inputEvent, &flag); 714 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 715 716 /** 717 * @tc.steps: step3.related function is called, flag is true. 718 */ 719 flag = true; 720 uiInputEvent.inputEvent = nullptr; 721 nodeEvent.origin = &uiInputEvent; 722 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 723 ret = OH_ArkUI_KeyEvent_IsScrollLockOn(inputEvent, &flag); 724 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 725 } 726 } // namespace OHOS::Ace