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 INTERVAL_TIME = 100;
36 constexpr int64_t DOUBLE_CLICK_INTERVAL_TIME_DEFAULT = 250000;
37 constexpr float DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG = 64.0;
38 } // namespace
39 class KeyCommandHandlerTest : public testing::Test {
40 public:
SetUpTestCase(void)41 static void SetUpTestCase(void) {}
TearDownTestCase(void)42 static void TearDownTestCase(void) {}
43 std::shared_ptr<KeyEvent> SetupKeyEvent();
44 std::shared_ptr<PointerEvent> SetupThreeFingerTapEvent();
45 std::shared_ptr<PointerEvent> SetupFourFingerTapEvent();
46 #ifdef OHOS_BUILD_ENABLE_TOUCH
47 std::shared_ptr<PointerEvent> SetupDoubleFingerDownEvent();
48 std::shared_ptr<PointerEvent> SetupSingleKnuckleDownEvent();
49 std::shared_ptr<PointerEvent> SetupDoubleKnuckleDownEvent();
50 #endif // OHOS_BUILD_ENABLE_TOUCH
51 };
52
GetNanoTime()53 int64_t GetNanoTime()
54 {
55 struct timespec time = { 0 };
56 clock_gettime(CLOCK_MONOTONIC, &time);
57 return static_cast<int64_t>(time.tv_sec) * SEC_TO_NANOSEC + time.tv_nsec;
58 }
59
SetupKeyEvent()60 std::shared_ptr<KeyEvent> KeyCommandHandlerTest::SetupKeyEvent()
61 {
62 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
63 CHKPP(keyEvent);
64 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
65 KeyEvent::KeyItem kitDown;
66 kitDown.SetKeyCode(KeyEvent::KEYCODE_HOME);
67 kitDown.SetPressed(true);
68 kitDown.SetDownTime(downTime);
69 keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
70 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
71 keyEvent->AddPressedKeyItems(kitDown);
72
73 return keyEvent;
74 }
75
76 #ifdef OHOS_BUILD_ENABLE_TOUCH
SetupDoubleFingerDownEvent()77 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleFingerDownEvent()
78 {
79 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
80 CHKPP(pointerEvent);
81 PointerEvent::PointerItem item;
82 PointerEvent::PointerItem item2;
83 item.SetPointerId(0);
84 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
85 int32_t downX = 100;
86 int32_t downY = 200;
87 item.SetDisplayX(downX);
88 item.SetDisplayY(downY);
89 item.SetPressed(true);
90 pointerEvent->SetPointerId(0);
91 pointerEvent->AddPointerItem(item);
92
93 item2.SetPointerId(1);
94 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
95 int32_t secondDownX = 120;
96 int32_t secondDownY = 220;
97 item2.SetDisplayX(secondDownX);
98 item2.SetDisplayY(secondDownY);
99 item2.SetPressed(true);
100 pointerEvent->SetPointerId(1);
101 pointerEvent->AddPointerItem(item2);
102 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
103 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
104 return pointerEvent;
105 }
106
SetupSingleKnuckleDownEvent()107 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupSingleKnuckleDownEvent()
108 {
109 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
110 CHKPP(pointerEvent);
111 PointerEvent::PointerItem item;
112 item.SetPointerId(0);
113 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
114 int32_t downX = 100;
115 int32_t downY = 200;
116 item.SetDisplayX(downX);
117 item.SetDisplayY(downY);
118 item.SetPressed(true);
119 pointerEvent->SetPointerId(0);
120 pointerEvent->AddPointerItem(item);
121 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
122 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
123 return pointerEvent;
124 }
125
SetupDoubleKnuckleDownEvent()126 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleKnuckleDownEvent()
127 {
128 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
129 CHKPP(pointerEvent);
130 PointerEvent::PointerItem item;
131 PointerEvent::PointerItem item2;
132 item.SetPointerId(0);
133 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
134 int32_t downX = 100;
135 int32_t downY = 200;
136 item.SetDisplayX(downX);
137 item.SetDisplayY(downY);
138 item.SetPressed(true);
139 pointerEvent->SetPointerId(0);
140 pointerEvent->AddPointerItem(item);
141
142 item2.SetPointerId(1);
143 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
144 int32_t secondDownX = 120;
145 int32_t secondDownY = 220;
146 item2.SetDisplayX(secondDownX);
147 item2.SetDisplayY(secondDownY);
148 item2.SetPressed(true);
149 pointerEvent->SetPointerId(1);
150 pointerEvent->AddPointerItem(item2);
151 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
152 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
153 return pointerEvent;
154 }
155 #endif // OHOS_BUILD_ENABLE_TOUCH
156
SetupThreeFingerTapEvent()157 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupThreeFingerTapEvent()
158 {
159 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
160 CHKPP(pointerEvent);
161 PointerEvent::PointerItem item1;
162 PointerEvent::PointerItem item2;
163 PointerEvent::PointerItem item3;
164
165 int32_t id0 = 0;
166 item1.SetPointerId(id0);
167 int32_t downX1 = 100;
168 int32_t downY1 = 200;
169 int64_t actionTime1 = 1000000;
170 item1.SetDisplayX(downX1);
171 item1.SetDisplayY(downY1);
172 item1.SetDownTime(actionTime1);
173 pointerEvent->SetPointerId(id0);
174 pointerEvent->AddPointerItem(item1);
175
176 int32_t id1 = 1;
177 item2.SetPointerId(id1);
178 int32_t downX2 = 200;
179 int32_t downY2 = 300;
180 int64_t actionTime2 = 1000100;
181 item2.SetDisplayX(downX2);
182 item2.SetDisplayY(downY2);
183 item2.SetDownTime(actionTime2);
184 pointerEvent->SetPointerId(id1);
185 pointerEvent->AddPointerItem(item2);
186
187 int32_t id2 = 2;
188 item3.SetPointerId(id2);
189 int32_t downX3 = 100;
190 int32_t downY3 = 200;
191 int64_t actionTime3 = 1000200;
192 item3.SetDisplayX(downX3);
193 item3.SetDisplayY(downY3);
194 item3.SetDownTime(actionTime3);
195 pointerEvent->SetPointerId(id2);
196 pointerEvent->AddPointerItem(item3);
197
198 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP);
199 return pointerEvent;
200 }
201
SetupFourFingerTapEvent()202 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupFourFingerTapEvent()
203 {
204 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
205 CHKPP(pointerEvent);
206 PointerEvent::PointerItem item1;
207 PointerEvent::PointerItem item2;
208 PointerEvent::PointerItem item3;
209 PointerEvent::PointerItem item4;
210
211 int32_t id0 = 0;
212 item1.SetPointerId(id0);
213 int32_t downX1 = 100;
214 int32_t downY1 = 200;
215 int64_t actionTime1 = 1000000;
216 item1.SetDisplayX(downX1);
217 item1.SetDisplayY(downY1);
218 item1.SetDownTime(actionTime1);
219 pointerEvent->SetPointerId(id0);
220 pointerEvent->AddPointerItem(item1);
221
222 int32_t id1 = 1;
223 item2.SetPointerId(id1);
224 int32_t downX2 = 200;
225 int32_t downY2 = 300;
226 int64_t actionTime2 = 1000100;
227 item2.SetDisplayX(downX2);
228 item2.SetDisplayY(downY2);
229 item2.SetDownTime(actionTime2);
230 pointerEvent->SetPointerId(id1);
231 pointerEvent->AddPointerItem(item2);
232
233 int32_t id2 = 2;
234 item3.SetPointerId(id2);
235 int32_t downX3 = 100;
236 int32_t downY3 = 200;
237 int64_t actionTime3 = 1000200;
238 item3.SetDisplayX(downX3);
239 item3.SetDisplayY(downY3);
240 item3.SetDownTime(actionTime3);
241 pointerEvent->SetPointerId(id2);
242 pointerEvent->AddPointerItem(item3);
243
244 int32_t id3 = 3;
245 item4.SetPointerId(id3);
246 int32_t downX4 = 400;
247 int32_t downY4 = 280;
248 int64_t actionTime4 = 1000300;
249 item4.SetDisplayX(downX4);
250 item4.SetDisplayY(downY4);
251 item4.SetDownTime(actionTime4);
252 pointerEvent->SetPointerId(id3);
253 pointerEvent->AddPointerItem(item4);
254
255 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_QUADTAP);
256 return pointerEvent;
257 }
258
259 /**
260 * @tc.name: KeyCommandHandlerTest_HandleMultiTapTest__001
261 * @tc.desc: Test three fingers tap event launch ability
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMultiTapTest__001, TestSize.Level1)
266 {
267 CALL_DEBUG_ENTER;
268 auto threeFingerTap = SetupThreeFingerTapEvent();
269 ASSERT_TRUE(threeFingerTap != nullptr);
270 KeyCommandHandler keyCommandHandler;
271 ASSERT_TRUE(keyCommandHandler.OnHandleEvent(threeFingerTap));
272 }
273
274 /**
275 * @tc.name: KeyCommandHandlerTest_HandleMultiTapTest__002
276 * @tc.desc: Test four fingers tap event launch ability
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMultiTapTest__002, TestSize.Level1)
281 {
282 CALL_DEBUG_ENTER;
283 auto fourFingerTap = SetupFourFingerTapEvent();
284 ASSERT_TRUE(fourFingerTap != nullptr);
285 KeyCommandHandler keyCommandHandler;
286 ASSERT_FALSE(keyCommandHandler.OnHandleEvent(fourFingerTap));
287 }
288
289 /**
290 * @tc.name: KeyCommandHandlerTest_001
291 * @tc.desc: Test update key down duration 0, 100, 4000
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_001, TestSize.Level1)
296 {
297 KeyCommandHandler eventKeyCommandHandler;
298 std::string businessId = "aaa";
299 int32_t delay = 0;
300 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
301 delay = 100;
302 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
303 delay = 4000;
304 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
305 }
306
307 /**
308 * @tc.name: KeyCommandHandlerTest_EnableCombineKey_001
309 * @tc.desc: Test enable combineKey
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_EnableCombineKey_001, TestSize.Level1)
314 {
315 KeyCommandHandler eventKeyCommandHandler;
316 ASSERT_EQ(eventKeyCommandHandler.EnableCombineKey(true), RET_OK);
317 }
318
319 /**
320 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_001
321 * @tc.desc: Test IsEnableCombineKey
322 * @tc.type: FUNC
323 * @tc.require:
324 */
325 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_001, TestSize.Level1)
326 {
327 KeyCommandHandler eventKeyCommandHandler;
328 eventKeyCommandHandler.EnableCombineKey(false);
329 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
330 CHKPV(keyEvent);
331 KeyEvent::KeyItem item;
332 item.SetKeyCode(KeyEvent::KEYCODE_POWER);
333 keyEvent->AddKeyItem(item);
334 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER);
335 ASSERT_EQ(eventKeyCommandHandler.OnHandleEvent(keyEvent), false);
336 eventKeyCommandHandler.EnableCombineKey(true);
337 }
338
339 /**
340 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_002
341 * @tc.desc: Test IsEnableCombineKey
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_002, TestSize.Level1)
346 {
347 KeyCommandHandler eventKeyCommandHandler;
348 eventKeyCommandHandler.EnableCombineKey(false);
349 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
350 CHKPV(keyEvent);
351 KeyEvent::KeyItem item1;
352 item1.SetKeyCode(KeyEvent::KEYCODE_META_LEFT);
353 keyEvent->AddKeyItem(item1);
354 KeyEvent::KeyItem item2;
355 item2.SetKeyCode(KeyEvent::KEYCODE_L);
356 keyEvent->AddKeyItem(item2);
357 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L);
358 ASSERT_EQ(eventKeyCommandHandler.OnHandleEvent(keyEvent), false);
359 eventKeyCommandHandler.EnableCombineKey(true);
360 }
361
362 /**
363 * @tc.name: KeyCommandHandlerTest_002
364 * @tc.desc: Test update key down duration -1 and 4001
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_002, TestSize.Level1)
369 {
370 KeyCommandHandler eventKeyCommandHandler;
371 std::string businessId = "com.ohos.camera";
372 int32_t delay = -1;
373 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
374 delay = 4001;
375 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
376 }
377
378 /**
379 * @tc.name: KeyCommandHandlerTest_003
380 * @tc.desc: Test businessId is ""
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_003, TestSize.Level1)
385 {
386 KeyCommandHandler eventKeyCommandHandler;
387 std::string businessId = "";
388 int32_t delay = 100;
389 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
390 }
391
392 /**
393 * @tc.name: KeyCommandHandlerTest_004
394 * @tc.desc: Test key event
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_004, TestSize.Level1)
399 {
400 CALL_TEST_DEBUG;
401 auto keyEvent = SetupKeyEvent();
402 ASSERT_TRUE(keyEvent != nullptr);
403 KeyCommandHandler eventKeyCommandHandler;
404 ASSERT_FALSE(eventKeyCommandHandler.OnHandleEvent(keyEvent));
405 }
406 #ifdef OHOS_BUILD_ENABLE_TOUCH
407 /**
408 * @tc.name: KeyCommandHandlerTest_TouchTest_001
409 * @tc.desc: Test double finger down event
410 * @tc.type: FUNC
411 * @tc.require:
412 */
413 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_TouchTest_001, TestSize.Level1)
414 {
415 CALL_DEBUG_ENTER;
416 auto pointerEvent = SetupDoubleFingerDownEvent();
417 ASSERT_TRUE(pointerEvent != nullptr);
418 KeyCommandHandler keyCommandHandler;
419 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
420 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
421 keyCommandHandler.HandlePointerActionMoveEvent(pointerEvent);
422 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
423 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
424 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
425 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
426 }
427
428 /**
429 * @tc.name: KeyCommandHandlerTest_KnuckleTest_001
430 * @tc.desc: Test single knuckle double click
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_001, TestSize.Level1)
435 {
436 CALL_DEBUG_ENTER;
437 auto pointerEvent = SetupSingleKnuckleDownEvent();
438 ASSERT_TRUE(pointerEvent != nullptr);
439 KeyCommandHandler keyCommandHandler;
440 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
441 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
442 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
443 pointerEvent->SetActionTime(actionTime);
444 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
445 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
446 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
447 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
448 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
449 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
450 actionTime = actionTime + INTERVAL_TIME;
451 pointerEvent->SetActionTime(actionTime);
452 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
453 ASSERT_TRUE(keyCommandHandler.GetSingleKnuckleGesture().state);
454 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
455 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
456 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
457 }
458
459 /**
460 * @tc.name: KeyCommandHandlerTest_KnuckleTest_002
461 * @tc.desc: Test double knuckle double click
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_002, TestSize.Level1)
466 {
467 CALL_DEBUG_ENTER;
468 auto pointerEvent = SetupDoubleKnuckleDownEvent();
469 ASSERT_TRUE(pointerEvent != nullptr);
470 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
471 pointerEvent->SetActionTime(actionTime);
472 KeyCommandHandler keyCommandHandler;
473 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
474 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
475 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
476 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
477 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
478 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
479 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
480 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
481 actionTime = actionTime + INTERVAL_TIME;
482 pointerEvent->SetActionTime(actionTime);
483 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
484 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
485 ASSERT_TRUE(keyCommandHandler.GetDoubleKnuckleGesture().state);
486 }
487
488 /**
489 * @tc.name: KeyCommandHandlerTest_KnuckleTest_003
490 * @tc.desc: Test single knuckle event to double knuckle event
491 * @tc.type: FUNC
492 * @tc.require:
493 */
494 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_003, TestSize.Level1)
495 {
496 CALL_DEBUG_ENTER;
497 auto singlePointerEvent = SetupSingleKnuckleDownEvent();
498 ASSERT_TRUE(singlePointerEvent != nullptr);
499 auto pointerEvent = SetupDoubleKnuckleDownEvent();
500 ASSERT_TRUE(pointerEvent != nullptr);
501 KeyCommandHandler keyCommandHandler;
502 keyCommandHandler.HandlePointerActionDownEvent(singlePointerEvent);
503 singlePointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
504 keyCommandHandler.HandlePointerActionUpEvent(singlePointerEvent);
505 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
506 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
507 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
508 }
509 #endif // OHOS_BUILD_ENABLE_TOUCH
510 } // namespace MMI
511 } // namespace OHOS