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 #define private public 20 #define protected public 21 #include "native_key_event.h" 22 #include "event_converter.h" 23 #include "native_interface.h" 24 #include "native_node.h" 25 #include "native_type.h" 26 #include "node_model.h" 27 #include "ui_input_event.h" 28 #include "event/ui_input_event_impl.h" 29 #include "test/mock/base/mock_task_executor.h" 30 #include "test/mock/core/common/mock_container.h" 31 #include "test/mock/core/common/mock_theme_manager.h" 32 #include "test/mock/core/pipeline/mock_pipeline_context.h" 33 34 using namespace testing; 35 using namespace testing::ext; 36 namespace OHOS::Ace { 37 namespace { 38 constexpr uint32_t ARKUI_UNICODE = 98; 39 constexpr int32_t ARKUI_DEVICE_ID = 1; 40 constexpr uint64_t ARKUI_TIME = 20; 41 const char* ARKUI_KEY_TEXT = "k"; 42 } // namespace 43 class NativeKeyEventTest : public testing::Test { 44 public: SetUpTestSuite()45 static void SetUpTestSuite() 46 { 47 NG::MockPipelineContext::SetUp(); 48 MockContainer::SetUp(); 49 MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent(); 50 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>(); 51 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_; 52 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 53 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 54 } TearDownTestSuite()55 static void TearDownTestSuite() 56 { 57 NG::MockPipelineContext::TearDown(); 58 MockContainer::TearDown(); 59 } SetUp()60 void SetUp() {} TearDown()61 void TearDown() {} 62 }; 63 64 /** 65 * @tc.name: NativeKeyEventTest001 66 * @tc.desc: test NODE_ON_KEY_EVENT; 67 * @tc.type: FUNC 68 */ 69 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest001, TestSize.Level1) 70 { 71 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 72 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 73 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 74 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 75 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 76 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 77 nodeAPI->unregisterNodeEvent(nullptr, NODE_ON_KEY_EVENT); 78 nodeAPI->unregisterNodeEvent(node, NODE_ON_KEY_EVENT); 79 nodeAPI->disposeNode(node); 80 } 81 82 /** 83 * @tc.name: NativeKeyEventTest002 84 * @tc.desc: test NODE_ON_KEY_PRE_IME; 85 * @tc.type: FUNC 86 */ 87 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest002, TestSize.Level1) 88 { 89 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 90 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 91 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 92 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 93 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 94 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 95 nodeAPI->unregisterNodeEvent(nullptr, NODE_ON_KEY_PRE_IME); 96 nodeAPI->unregisterNodeEvent(node, NODE_ON_KEY_PRE_IME); 97 nodeAPI->disposeNode(node); 98 } 99 100 /** 101 * @tc.name: NativeKeyEventTest003 102 * @tc.desc: Test OH_ArkUI_KeyEvent_GetType function. 103 * @tc.type: FUNC 104 */ 105 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest003, TestSize.Level1) 106 { 107 /** 108 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 109 */ 110 ArkUI_NodeEvent event = { 1, 0 }; 111 event.origin = nullptr; 112 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 113 auto type = OH_ArkUI_KeyEvent_GetType(uiInputEvent); 114 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UNKNOWN); 115 116 /** 117 * @tc.steps: step2.create null KeyEvent, related function is called. 118 */ 119 ArkUI_NodeEvent nodeEvent; 120 ArkUI_UIInputEvent nullUiInputEvent; 121 nullUiInputEvent.inputEvent = nullptr; 122 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 123 nodeEvent.origin = &nullUiInputEvent; 124 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 125 type = OH_ArkUI_KeyEvent_GetType(uiInputEvent); 126 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UNKNOWN); 127 } 128 129 /** 130 * @tc.name: NativeKeyEventTest004 131 * @tc.desc: Test the KeyEvent property functions. 132 * @tc.type: FUNC 133 */ 134 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest004, TestSize.Level1) 135 { 136 /** 137 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 138 */ 139 ArkUI_NodeEvent nodeEvent; 140 ArkUINodeEvent event; 141 ArkUI_UIInputEvent uiInputEvent; 142 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 143 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 144 event.keyEvent.type = static_cast<ArkUI_Int32>(OHOS::Ace::KeyAction::UP); 145 event.keyEvent.keyCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyCode::KEY_VOLUME_UP); 146 event.keyEvent.keySource = static_cast<ArkUI_Int32>(OHOS::Ace::SourceType::MOUSE); 147 event.keyEvent.intentionCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyIntention::INTENTION_UP); 148 event.keyEvent.unicode = ARKUI_UNICODE; 149 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 150 event.keyEvent.timestamp = ARKUI_TIME; 151 event.keyEvent.keyText = ARKUI_KEY_TEXT; 152 uiInputEvent.inputEvent = &event.keyEvent; 153 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 154 nodeEvent.origin = &uiInputEvent; 155 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 156 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 157 158 /** 159 * @tc.steps: step2. call functions. 160 */ 161 auto type = OH_ArkUI_KeyEvent_GetType(inputEvent); 162 auto code = OH_ArkUI_KeyEvent_GetKeyCode(inputEvent); 163 auto keySource = OH_ArkUI_KeyEvent_GetKeySource(inputEvent); 164 auto intensionCode = OH_ArkUI_KeyEvent_GetKeyIntensionCode(inputEvent); 165 auto unicode = OH_ArkUI_KeyEvent_GetUnicode(inputEvent); 166 auto diviceId = OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent); 167 auto time = OH_ArkUI_UIInputEvent_GetEventTime(inputEvent); 168 auto keyText = OH_ArkUI_KeyEvent_GetKeyText(inputEvent); 169 170 /** 171 * @tc.expected: Return expected results. 172 */ 173 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UP); 174 EXPECT_EQ(code, ArkUI_KeyCode::ARKUI_KEYCODE_VOLUME_UP); 175 EXPECT_EQ(keySource, ArkUI_KeySourceType::ARKUI_KEY_SOURCE_TYPE_MOUSE); 176 EXPECT_EQ(intensionCode, ArkUI_KeyIntension::ARKUI_KEY_INTENSION_UP); 177 EXPECT_EQ(unicode, ARKUI_UNICODE); 178 EXPECT_EQ(diviceId, ARKUI_DEVICE_ID); 179 EXPECT_EQ(time, ARKUI_TIME); 180 EXPECT_NE(keyText, nullptr); 181 } 182 183 /** 184 * @tc.name: NativeKeyEventTest005 185 * @tc.desc: test NODE_DISPATCH_KEY_EVENT; 186 * @tc.type: FUNC 187 */ 188 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest005, TestSize.Level1) 189 { 190 /** 191 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 192 */ 193 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 194 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 195 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 196 197 /** 198 * @tc.steps: step2. call functions. 199 */ 200 EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_ON_KEY_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID); 201 EXPECT_EQ(nodeAPI->registerNodeEvent(node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), 202 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED); 203 nodeAPI->unregisterNodeEvent(nullptr, NODE_DISPATCH_KEY_EVENT); 204 nodeAPI->unregisterNodeEvent(node, NODE_DISPATCH_KEY_EVENT); 205 nodeAPI->disposeNode(node); 206 } 207 208 /** 209 * @tc.name: NativeKeyEventTest006 210 * @tc.desc: Test OH_ArkUI_KeyEvent_Dispatch function. 211 * @tc.type: FUNC 212 */ 213 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest006, TestSize.Level1) 214 { 215 /** 216 * @tc.steps: step1. create node. 217 */ 218 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 219 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 220 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 221 222 /** 223 * @tc.steps: step2. create ArkUI_NodeEvent, related function is called. 224 */ 225 ArkUI_NodeEvent nodeEvent; 226 ArkUINodeEvent event; 227 ArkUI_UIInputEvent uiInputEvent; 228 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 229 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 230 event.keyEvent.type = static_cast<ArkUI_Int32>(OHOS::Ace::KeyAction::UP); 231 event.keyEvent.keyCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyCode::KEY_SPACE); 232 event.keyEvent.keySource = static_cast<ArkUI_Int32>(OHOS::Ace::SourceType::KEYBOARD); 233 event.keyEvent.intentionCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyIntention::INTENTION_UP); 234 event.keyEvent.unicode = ARKUI_UNICODE; 235 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 236 event.keyEvent.timestamp = ARKUI_TIME; 237 event.keyEvent.keyText = ARKUI_KEY_TEXT; 238 uiInputEvent.inputEvent = &event.keyEvent; 239 nodeEvent.origin = &uiInputEvent; 240 nodeEvent.node = node; 241 242 /** 243 * @tc.steps: step3. call functions. 244 */ 245 bool flag = false; 246 nodeAPI->registerNodeEvent(node, NODE_DISPATCH_KEY_EVENT, 0, &flag); __anon4d65bfb80202(ArkUI_NodeEvent* event) 247 NodeModel::AddNodeEventReceiver(node, [](ArkUI_NodeEvent* event) { 248 auto userData = reinterpret_cast<bool*>(event->userData); 249 *userData = true; 250 }); 251 auto* frameNode = reinterpret_cast<NG::FrameNode*>(node->uiNodeHandle); 252 frameNode->GetOrCreateFocusHub()->currentFocus_ = true; 253 OH_ArkUI_KeyEvent_Dispatch(node, &uiInputEvent); 254 nodeAPI->unregisterNodeEvent(node, NODE_DISPATCH_KEY_EVENT); 255 NodeModel::DisposeNode(node); 256 257 /** 258 * @tc.expected: Return expected results. 259 */ 260 EXPECT_EQ(flag, true); 261 } 262 263 /** 264 * @tc.name: NativeKeyEventTest007 265 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyCode function. 266 * @tc.type: FUNC 267 */ 268 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest007, TestSize.Level1) 269 { 270 /** 271 * @tc.steps: step1.create null UIInputEvent, function will return -1. 272 */ 273 ArkUI_NodeEvent event = { 1, 0 }; 274 event.origin = nullptr; 275 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 276 auto type = OH_ArkUI_KeyEvent_GetKeyCode(uiInputEvent); 277 EXPECT_EQ(type, -1); 278 279 /** 280 * @tc.steps: step2.create null KeyEvent, function will return -1. 281 */ 282 ArkUI_NodeEvent nodeEvent; 283 ArkUI_UIInputEvent nullUiInputEvent; 284 nullUiInputEvent.inputEvent = nullptr; 285 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 286 nodeEvent.origin = &nullUiInputEvent; 287 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 288 type = OH_ArkUI_KeyEvent_GetKeyCode(uiInputEvent); 289 EXPECT_EQ(type, -1); 290 } 291 292 /** 293 * @tc.name: NativeKeyEventTest008 294 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyText function. 295 * @tc.type: FUNC 296 */ 297 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest008, TestSize.Level1) 298 { 299 /** 300 * @tc.steps: step1.create null UIInputEvent, function will return null. 301 */ 302 ArkUI_NodeEvent event = { 1, 0 }; 303 event.origin = nullptr; 304 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 305 auto type = OH_ArkUI_KeyEvent_GetKeyText(uiInputEvent); 306 EXPECT_EQ(type, nullptr); 307 308 /** 309 * @tc.steps: step2.create null KeyEvent, function will return null. 310 */ 311 ArkUI_NodeEvent nodeEvent; 312 ArkUI_UIInputEvent nullUiInputEvent; 313 nullUiInputEvent.inputEvent = nullptr; 314 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 315 nodeEvent.origin = &nullUiInputEvent; 316 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 317 type = OH_ArkUI_KeyEvent_GetKeyText(uiInputEvent); 318 EXPECT_EQ(type, nullptr); 319 } 320 321 /** 322 * @tc.name: NativeKeyEventTest009 323 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeySource function. 324 * @tc.type: FUNC 325 */ 326 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest009, TestSize.Level1) 327 { 328 /** 329 * @tc.steps: step1.create null UIInputEvent, function will return -1. 330 */ 331 ArkUI_NodeEvent event = { 1, 0 }; 332 event.origin = nullptr; 333 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 334 auto type = OH_ArkUI_KeyEvent_GetKeySource(uiInputEvent); 335 EXPECT_EQ(type, -1); 336 337 /** 338 * @tc.steps: step2.create null KeyEvent, function will return -1. 339 */ 340 ArkUI_NodeEvent nodeEvent; 341 ArkUI_UIInputEvent nullUiInputEvent; 342 nullUiInputEvent.inputEvent = nullptr; 343 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 344 nodeEvent.origin = &nullUiInputEvent; 345 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 346 type = OH_ArkUI_KeyEvent_GetKeySource(uiInputEvent); 347 EXPECT_EQ(type, -1); 348 } 349 350 /** 351 * @tc.name: NativeKeyEventTest0010 352 * @tc.desc: Test OH_ArkUI_KeyEvent_StopPropagation function. 353 * @tc.type: FUNC 354 */ 355 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0010, TestSize.Level1) 356 { 357 /** 358 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called and stopPropagation is true. 359 */ 360 ArkUI_NodeEvent nodeEvent; 361 ArkUINodeEvent event; 362 ArkUI_UIInputEvent uiInputEvent; 363 event.keyEvent.stopPropagation = false; 364 uiInputEvent.inputEvent = &event.keyEvent; 365 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 366 nodeEvent.origin = &uiInputEvent; 367 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 368 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, true); 369 EXPECT_EQ(event.keyEvent.stopPropagation, true); 370 371 /** 372 * @tc.steps: step2.create null UIInputEvent, related function is called and stopPropagation is true. 373 */ 374 nodeEvent.origin = nullptr; 375 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 376 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, false); 377 EXPECT_EQ(event.keyEvent.stopPropagation, true); 378 379 /** 380 * @tc.steps: step2.create null KeyEvent, related function is called and stopPropagation is true. 381 */ 382 uiInputEvent.inputEvent = nullptr; 383 nodeEvent.origin = &uiInputEvent; 384 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 385 OH_ArkUI_KeyEvent_StopPropagation(inputEvent, false); 386 EXPECT_EQ(event.keyEvent.stopPropagation, true); 387 } 388 389 /** 390 * @tc.name: NativeKeyEventTest0011 391 * @tc.desc: Test OH_ArkUI_KeyEvent_GetKeyIntensionCode function. 392 * @tc.type: FUNC 393 */ 394 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0011, TestSize.Level1) 395 { 396 /** 397 * @tc.steps: step1.create null UIInputEvent, function will return -1. 398 */ 399 ArkUI_NodeEvent event = { 1, 0 }; 400 event.origin = nullptr; 401 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 402 auto type = OH_ArkUI_KeyEvent_GetKeyIntensionCode(uiInputEvent); 403 EXPECT_EQ(type, -1); 404 405 /** 406 * @tc.steps: step2.create null KeyEvent, function will return -1. 407 */ 408 ArkUI_NodeEvent nodeEvent; 409 ArkUI_UIInputEvent nullUiInputEvent; 410 nullUiInputEvent.inputEvent = nullptr; 411 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 412 nodeEvent.origin = &nullUiInputEvent; 413 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 414 type = OH_ArkUI_KeyEvent_GetKeyIntensionCode(uiInputEvent); 415 EXPECT_EQ(type, -1); 416 } 417 418 /** 419 * @tc.name: NativeKeyEventTest0012 420 * @tc.desc: Test OH_ArkUI_KeyEvent_GetUnicode function. 421 * @tc.type: FUNC 422 */ 423 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0012, TestSize.Level1) 424 { 425 /** 426 * @tc.steps: step1.create null UIInputEvent, function will return 0. 427 */ 428 ArkUI_NodeEvent event = { 1, 0 }; 429 event.origin = nullptr; 430 auto uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&event); 431 auto type = OH_ArkUI_KeyEvent_GetUnicode(uiInputEvent); 432 EXPECT_EQ(type, 0); 433 434 /** 435 * @tc.steps: step2.create null KeyEvent, function will return 0. 436 */ 437 ArkUI_NodeEvent nodeEvent; 438 ArkUI_UIInputEvent nullUiInputEvent; 439 nullUiInputEvent.inputEvent = nullptr; 440 nullUiInputEvent.eventTypeId = C_KEY_EVENT_ID; 441 nodeEvent.origin = &nullUiInputEvent; 442 uiInputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 443 type = OH_ArkUI_KeyEvent_GetUnicode(uiInputEvent); 444 EXPECT_EQ(type, 0); 445 } 446 447 /** 448 * @tc.name: NativeKeyEventTest0013 449 * @tc.desc: Test OH_ArkUI_KeyEvent_SetConsumed function. 450 * @tc.type: FUNC 451 */ 452 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0013, TestSize.Level1) 453 { 454 /** 455 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called and stopPropagation is true. 456 */ 457 ArkUI_NodeEvent nodeEvent; 458 ArkUINodeEvent event; 459 ArkUI_UIInputEvent uiInputEvent; 460 event.keyEvent.stopPropagation = false; 461 uiInputEvent.inputEvent = &event.keyEvent; 462 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 463 nodeEvent.origin = &uiInputEvent; 464 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 465 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, true); 466 EXPECT_EQ(event.keyEvent.isConsumed, true); 467 468 /** 469 * @tc.steps: step2.create null UIInputEvent, related function is called and stopPropagation is true. 470 */ 471 nodeEvent.origin = nullptr; 472 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 473 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, false); 474 EXPECT_EQ(event.keyEvent.isConsumed, true); 475 476 /** 477 * @tc.steps: step2.create null KeyEvent, related function is called and stopPropagation is true. 478 */ 479 uiInputEvent.inputEvent = nullptr; 480 nodeEvent.origin = &uiInputEvent; 481 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 482 OH_ArkUI_KeyEvent_SetConsumed(inputEvent, false); 483 EXPECT_EQ(event.keyEvent.isConsumed, true); 484 } 485 486 /** 487 * @tc.name: NativeKeyEventTest0014 488 * @tc.desc: Test OH_ArkUI_KeyEvent_Dispatch function. 489 * @tc.type: FUNC 490 */ 491 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest0014, TestSize.Level1) 492 { 493 /** 494 * @tc.steps: step1. create node. 495 */ 496 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 497 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 498 auto node = nodeAPI->createNode(ARKUI_NODE_STACK); 499 500 /** 501 * @tc.steps: step2.create null UIInputEvent, flag is false. 502 */ 503 ArkUI_NodeEvent nodeEvent; 504 ArkUINodeEvent event; 505 ArkUI_UIInputEvent uiInputEvent; 506 event.keyEvent.stopPropagation = true; 507 uiInputEvent.inputEvent = &event.keyEvent; 508 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 509 nodeEvent.origin = nullptr; 510 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 511 512 bool flag = false; 513 nodeAPI->registerNodeEvent(node, NODE_DISPATCH_KEY_EVENT, 0, &flag); __anon4d65bfb80302(ArkUI_NodeEvent* event) 514 NodeModel::AddNodeEventReceiver(node, [](ArkUI_NodeEvent* event) { 515 auto userData = reinterpret_cast<bool*>(event->userData); 516 *userData = true; 517 }); 518 auto* frameNode = reinterpret_cast<NG::FrameNode*>(node->uiNodeHandle); 519 frameNode->GetOrCreateFocusHub()->currentFocus_ = true; 520 OH_ArkUI_KeyEvent_Dispatch(node, inputEvent); 521 EXPECT_EQ(flag, false); 522 523 /** 524 * @tc.steps: step2.create null KeyEvent, flag is false. 525 */ 526 uiInputEvent.inputEvent = nullptr; 527 nodeEvent.origin = &uiInputEvent; 528 inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 529 OH_ArkUI_KeyEvent_Dispatch(node, inputEvent); 530 nodeAPI->unregisterNodeEvent(node, NODE_DISPATCH_KEY_EVENT); 531 NodeModel::DisposeNode(node); 532 EXPECT_EQ(flag, false); 533 } 534 } // namespace OHOS::Ace