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 /** 118 * @tc.name: NativeKeyEventTest004 119 * @tc.desc: Test the KeyEvent property functions. 120 * @tc.type: FUNC 121 */ 122 HWTEST_F(NativeKeyEventTest, NativeKeyEventTest004, TestSize.Level1) 123 { 124 /** 125 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 126 */ 127 ArkUI_NodeEvent nodeEvent; 128 ArkUINodeEvent event; 129 ArkUI_UIInputEvent uiInputEvent; 130 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 131 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 132 event.keyEvent.type = static_cast<ArkUI_Int32>(OHOS::Ace::KeyAction::UP); 133 event.keyEvent.keyCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyCode::KEY_VOLUME_UP); 134 event.keyEvent.keySource = static_cast<ArkUI_Int32>(OHOS::Ace::SourceType::MOUSE); 135 event.keyEvent.intentionCode = static_cast<ArkUI_Int32>(OHOS::Ace::KeyIntention::INTENTION_UP); 136 event.keyEvent.unicode = ARKUI_UNICODE; 137 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 138 event.keyEvent.timestamp = ARKUI_TIME; 139 event.keyEvent.keyText = ARKUI_KEY_TEXT; 140 uiInputEvent.inputEvent = &event.keyEvent; 141 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 142 nodeEvent.origin = &uiInputEvent; 143 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 144 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 145 146 /** 147 * @tc.steps: step2. call functions. 148 */ 149 auto type = OH_ArkUI_KeyEvent_GetType(inputEvent); 150 auto code = OH_ArkUI_KeyEvent_GetKeyCode(inputEvent); 151 auto keySource = OH_ArkUI_KeyEvent_GetKeySource(inputEvent); 152 auto intensionCode = OH_ArkUI_KeyEvent_GetKeyIntensionCode(inputEvent); 153 auto unicode = OH_ArkUI_KeyEvent_GetUnicode(inputEvent); 154 auto diviceId = OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent); 155 auto time = OH_ArkUI_UIInputEvent_GetEventTime(inputEvent); 156 auto keyText = OH_ArkUI_KeyEvent_GetKeyText(inputEvent); 157 158 /** 159 * @tc.expected: Return expected results. 160 */ 161 EXPECT_EQ(type, ArkUI_KeyEventType::ARKUI_KEY_EVENT_UP); 162 EXPECT_EQ(code, ArkUI_KeyCode::ARKUI_KEYCODE_VOLUME_UP); 163 EXPECT_EQ(keySource, ArkUI_KeySourceType::ARKUI_KEY_SOURCE_TYPE_MOUSE); 164 EXPECT_EQ(intensionCode, ArkUI_KeyIntension::ARKUI_KEY_INTENSION_UP); 165 EXPECT_EQ(unicode, ARKUI_UNICODE); 166 EXPECT_EQ(diviceId, ARKUI_DEVICE_ID); 167 EXPECT_EQ(time, ARKUI_TIME); 168 EXPECT_NE(keyText, nullptr); 169 } 170 } // namespace OHOS::Ace