1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17
18 #include "event_log_helper.h"
19 #include "input_handler_type.h"
20 #include "key_command_handler.h"
21 #include "input_event_handler.h"
22 #include "mmi_log.h"
23 #include "multimodal_event_handler.h"
24 #include "system_info.h"
25 #include "util.h"
26
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing::ext;
31 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "KeyCommandHandlerTest" };
32 constexpr int32_t NANOSECOND_TO_MILLISECOND = 1000000;
33 constexpr int32_t SEC_TO_NANOSEC = 1000000000;
34 constexpr int32_t COMMON_PARAMETER_ERROR = 401;
35 constexpr int32_t NONE_CLICK_STATE = 0;
36 constexpr int32_t CLICK_STATE = 1;
37 } // namespace
38 class KeyCommandHandlerTest : public testing::Test {
39 public:
SetUpTestCase(void)40 static void SetUpTestCase(void) {}
TearDownTestCase(void)41 static void TearDownTestCase(void) {}
42 std::shared_ptr<KeyEvent> SetupKeyEvent();
43 #ifdef OHOS_BUILD_ENABLE_TOUCH
44 std::shared_ptr<PointerEvent> SetupDoubleFingerDownEvent();
45 std::shared_ptr<PointerEvent> SetupSingleKnuckleDownEvent();
46 std::shared_ptr<PointerEvent> SetupDoubleKnuckleDownEvent();
47 #endif // OHOS_BUILD_ENABLE_TOUCH
48 };
49
GetNanoTime()50 int64_t GetNanoTime()
51 {
52 struct timespec time = { 0 };
53 clock_gettime(CLOCK_MONOTONIC, &time);
54 return static_cast<int64_t>(time.tv_sec) * SEC_TO_NANOSEC + time.tv_nsec;
55 }
56
SetupKeyEvent()57 std::shared_ptr<KeyEvent> KeyCommandHandlerTest::SetupKeyEvent()
58 {
59 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
60 CHKPP(keyEvent);
61 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
62 KeyEvent::KeyItem kitDown;
63 kitDown.SetKeyCode(KeyEvent::KEYCODE_HOME);
64 kitDown.SetPressed(true);
65 kitDown.SetDownTime(downTime);
66 keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
67 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
68 keyEvent->AddPressedKeyItems(kitDown);
69
70 return keyEvent;
71 }
72
73 #ifdef OHOS_BUILD_ENABLE_TOUCH
SetupDoubleFingerDownEvent()74 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleFingerDownEvent()
75 {
76 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
77 CHKPP(pointerEvent);
78 PointerEvent::PointerItem item;
79 PointerEvent::PointerItem item2;
80 item.SetPointerId(0);
81 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
82 int32_t downX = 100;
83 int32_t downY = 200;
84 item.SetDisplayX(downX);
85 item.SetDisplayY(downY);
86 item.SetPressed(true);
87 pointerEvent->SetPointerId(0);
88 pointerEvent->AddPointerItem(item);
89
90 item2.SetPointerId(1);
91 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
92 int32_t secondDownX = 120;
93 int32_t secondDownY = 220;
94 item2.SetDisplayX(secondDownX);
95 item2.SetDisplayY(secondDownY);
96 item2.SetPressed(true);
97 pointerEvent->SetPointerId(1);
98 pointerEvent->AddPointerItem(item2);
99 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
100 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
101 return pointerEvent;
102 }
103
SetupSingleKnuckleDownEvent()104 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupSingleKnuckleDownEvent()
105 {
106 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
107 CHKPP(pointerEvent);
108 PointerEvent::PointerItem item;
109 item.SetPointerId(0);
110 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
111 int32_t downX = 100;
112 int32_t downY = 200;
113 item.SetDisplayX(downX);
114 item.SetDisplayY(downY);
115 item.SetPressed(true);
116 pointerEvent->SetPointerId(0);
117 pointerEvent->AddPointerItem(item);
118 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
119 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
120 return pointerEvent;
121 }
122
SetupDoubleKnuckleDownEvent()123 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleKnuckleDownEvent()
124 {
125 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
126 CHKPP(pointerEvent);
127 PointerEvent::PointerItem item;
128 PointerEvent::PointerItem item2;
129 item.SetPointerId(0);
130 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
131 int32_t downX = 100;
132 int32_t downY = 200;
133 item.SetDisplayX(downX);
134 item.SetDisplayY(downY);
135 item.SetPressed(true);
136 pointerEvent->SetPointerId(0);
137 pointerEvent->AddPointerItem(item);
138
139 item2.SetPointerId(1);
140 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
141 int32_t secondDownX = 120;
142 int32_t secondDownY = 220;
143 item2.SetDisplayX(secondDownX);
144 item2.SetDisplayY(secondDownY);
145 item2.SetPressed(true);
146 pointerEvent->SetPointerId(1);
147 pointerEvent->AddPointerItem(item2);
148 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
149 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
150 return pointerEvent;
151 }
152 #endif // OHOS_BUILD_ENABLE_TOUCH
153
154 /**
155 * @tc.name: KeyCommandHandlerTest_001
156 * @tc.desc: Test update key down duration 0, 100, 4000
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_001, TestSize.Level1)
161 {
162 KeyCommandHandler eventKeyCommandHandler;
163 std::string businessId = "aaa";
164 int32_t delay = 0;
165 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
166 delay = 100;
167 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
168 delay = 4000;
169 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
170 }
171
172 /**
173 * @tc.name: KeyCommandHandlerTest_002
174 * @tc.desc: Test update key down duration -1 and 4001
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_002, TestSize.Level1)
179 {
180 KeyCommandHandler eventKeyCommandHandler;
181 std::string businessId = "com.ohos.camera";
182 int32_t delay = -1;
183 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
184 delay = 4001;
185 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
186 }
187
188 /**
189 * @tc.name: KeyCommandHandlerTest_003
190 * @tc.desc: Test businessId is ""
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_003, TestSize.Level1)
195 {
196 KeyCommandHandler eventKeyCommandHandler;
197 std::string businessId = "";
198 int32_t delay = 100;
199 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
200 }
201
202 /**
203 * @tc.name: KeyCommandHandlerTest_004
204 * @tc.desc: Test key event
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_004, TestSize.Level1)
209 {
210 CALL_TEST_DEBUG;
211 auto keyEvent = SetupKeyEvent();
212 ASSERT_TRUE(keyEvent != nullptr);
213 KeyCommandHandler eventKeyCommandHandler;
214 ASSERT_FALSE(eventKeyCommandHandler.OnHandleEvent(keyEvent));
215 }
216 #ifdef OHOS_BUILD_ENABLE_TOUCH
217 /**
218 * @tc.name: KeyCommandHandlerTest_TouchTest_001
219 * @tc.desc: Test key event
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_TouchTest_001, TestSize.Level1)
224 {
225 CALL_DEBUG_ENTER;
226 auto pointerEvent = SetupDoubleFingerDownEvent();
227 ASSERT_TRUE(pointerEvent != nullptr);
228 KeyCommandHandler keyCommandHandler;
229 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
230 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
231 keyCommandHandler.HandlePointerActionMoveEvent(pointerEvent);
232 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
233 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
234 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
235 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
236 }
237
238 /**
239 * @tc.name: KeyCommandHandlerTest_KnuckleTest_001
240 * @tc.desc: Test key event
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_001, TestSize.Level1)
245 {
246 CALL_DEBUG_ENTER;
247 auto pointerEvent = SetupSingleKnuckleDownEvent();
248 ASSERT_TRUE(pointerEvent != nullptr);
249 KeyCommandHandler keyCommandHandler;
250 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
251 ASSERT_EQ(CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
252 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
253 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
254 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
255 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
256 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
257 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
258 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
259 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
260 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
261 }
262
263 /**
264 * @tc.name: KeyCommandHandlerTest_KnuckleTest_002
265 * @tc.desc: Test key event
266 * @tc.type: FUNC
267 * @tc.require:
268 */
269 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_002, TestSize.Level1)
270 {
271 CALL_DEBUG_ENTER;
272 auto pointerEvent = SetupDoubleKnuckleDownEvent();
273 ASSERT_TRUE(pointerEvent != nullptr);
274 KeyCommandHandler keyCommandHandler;
275 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
276 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
277 ASSERT_EQ(CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
278 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
279 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
280 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
281 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
282 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
283 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
284 }
285
286 /**
287 * @tc.name: KeyCommandHandlerTest_KnuckleTest_003
288 * @tc.desc: Test key event
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_003, TestSize.Level1)
293 {
294 CALL_DEBUG_ENTER;
295 auto singlePointerEvent = SetupSingleKnuckleDownEvent();
296 ASSERT_TRUE(singlePointerEvent != nullptr);
297 auto pointerEvent = SetupDoubleKnuckleDownEvent();
298 ASSERT_TRUE(pointerEvent != nullptr);
299 KeyCommandHandler keyCommandHandler;
300 keyCommandHandler.HandlePointerActionDownEvent(singlePointerEvent);
301 ASSERT_EQ(CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
302 singlePointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
303 keyCommandHandler.HandlePointerActionUpEvent(singlePointerEvent);
304 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
305 ASSERT_EQ(NONE_CLICK_STATE, keyCommandHandler.GetSingleKnuckleGesture().state);
306 ASSERT_EQ(CLICK_STATE, keyCommandHandler.GetDoubleKnuckleGesture().state);
307 }
308 #endif // OHOS_BUILD_ENABLE_TOUCH
309 } // namespace MMI
310 } // namespace OHOS