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 "cJSON.h"
19 #include "util.h"
20
21 #include "ability_manager_client.h"
22 #include "display_event_monitor.h"
23 #include "event_log_helper.h"
24 #include "gesturesense_wrapper.h"
25 #include "input_event_handler.h"
26 #include "input_handler_type.h"
27 #include "input_windows_manager.h"
28 #include "key_command_handler.h"
29 #include "mmi_log.h"
30 #include "multimodal_event_handler.h"
31 #include "multimodal_input_preferences_manager.h"
32 #include "stylus_key_handler.h"
33 #include "system_info.h"
34
35 #undef MMI_LOG_TAG
36 #define MMI_LOG_TAG "KeyCommandHandlerTest"
37
38 namespace OHOS {
39 namespace MMI {
40 namespace {
41 using namespace testing::ext;
42 constexpr int32_t NANOSECOND_TO_MILLISECOND = 1000000;
43 constexpr int32_t SEC_TO_NANOSEC = 1000000000;
44 constexpr int32_t COMMON_PARAMETER_ERROR = 401;
45 constexpr int32_t INTERVAL_TIME = 100;
46 constexpr int32_t INTERVAL_TIME_OUT = 500000;
47 constexpr int32_t ERROR_DELAY_VALUE = -1000;
48 constexpr int64_t DOUBLE_CLICK_INTERVAL_TIME_DEFAULT = 250000;
49 constexpr int32_t TWO_FINGERS_TIME_LIMIT = 150000;
50 constexpr int64_t DOUBLE_CLICK_INTERVAL_TIME_SLOW = 450000;
51 constexpr float DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG = 64.0;
52 constexpr int32_t WINDOW_INPUT_METHOD_TYPE = 2105;
53 const std::string EXTENSION_ABILITY = "extensionAbility";
54 const std::string EXTENSION_ABILITY_ABNORMAL = "extensionAbilityAbnormal";
55 const vector<float> CIRCLE_COORDINATES = {
56 328.0f, 596.0f, 328.0f, 597.0f, 322.0f, 606.0f,
57 306.0f, 635.0f, 291.0f, 665.0f, 283.0f, 691.0f,
58 291.0f, 739.0f, 300.0f, 751.0f, 312.0f, 759.0f,
59 327.0f, 765.0f, 343.0f, 768.0f, 361.0f, 769.0f,
60 379.0f, 767.0f, 395.0f, 761.0f, 411.0f, 751.0f,
61 425.0f, 737.0f, 439.0f, 718.0f, 449.0f, 709.0f,
62 456.0f, 683.0f, 459.0f, 654.0f, 451.0f, 569.0f,
63 437.0f, 552.0f, 418.0f, 542.0f, 392.0f, 540.0f,
64 363.0f, 545.0f };
65 const vector<int64_t> CIRCLE_TIMESTAMPS = {
66 71304451, 71377126, 71387783, 71398239, 71409629,
67 71419392, 71461386, 71472044, 71483797, 71493077,
68 71503426, 71514339, 71524715, 71535126, 71545652,
69 71556329, 71566506, 71577283, 71587745, 71598921,
70 71630319, 71642155, 71651090, 71662474, 71671657 };
71 const vector<float> CURVE_COORDINATES = {
72 374.0f, 489.0f, 373.0f, 489.0f, 365.0f, 491.0f,
73 341.0f, 503.0f, 316.0f, 519.0f, 300.0f, 541.0f,
74 293.0f, 561.0f, 289.0f, 582.0f, 292.0f, 643.0f,
75 301.0f, 657.0f, 317.0f, 668.0f, 336.0f, 681.0f,
76 358.0f, 695.0f, 381.0f, 706.0f, 403.0f, 717.0f,
77 423.0f, 715.0f, 441.0f, 727.0f, 458.0f, 739.0f,
78 468.0f, 751.0f, 474.0f, 764.0f, 467.0f, 812.0f,
79 455.0f, 828.0f, 435.0f, 844.0f, 412.0f, 860.0f,
80 387.0f, 876.0f, 362.0f, 894.0f, 338.0f, 906.0f,
81 317.0f, 913.0f, 296.0f, 918.0f };
82 const vector<int64_t> CURVE_TIMESTAMPS = {
83 134900436, 134951403, 134962832, 134973234,
84 134983492, 134995390, 135003876, 135014389,
85 135045917, 135057774, 135067076, 135077688,
86 135088139, 135098494, 135109130, 135119679,
87 135130101, 135140670, 135151182, 135161672,
88 135193739, 135203790, 135214272, 135224868,
89 135236197, 135245828, 135256481, 135267186,
90 135276939 };
91 const vector<float> LINE_COORDINATES = {
92 390.0f, 340.0f, 390.0f, 348.0f, 390.0f, 367.0f,
93 387.0f, 417.0f, 385.0f, 455.0f, 384.0f, 491.0f,
94 382.0f, 516.0f, 381.0f, 539.0f, 380.0f, 564.0f,
95 378.0f, 589.0f, 377.0f, 616.0f, 376.0f, 643.0f,
96 375.0f, 669.0f, 375.0f, 694.0f, 374.0f, 718.0f,
97 374.0f, 727.0f, 374.0f, 750.0f, 374.0f, 771.0f,
98 374.0f, 791.0f, 374.0f, 811.0f, 375.0f, 831.0f,
99 375.0f, 851.0f, 376.0f, 870.0f, 377.0f, 886.0f,
100 377.0f, 902.0f, 379.0f, 918.0f, 379.0f, 934.0f,
101 380.0f, 950.0f, 381.0f, 963.0f, 383.0f, 977.0f,
102 385.0f, 992.0f, 387.0f, 1002.0f, 389.0f, 1016.0f,
103 390.0f, 1030.0f, 390.0f, 1042.0f, 390.0f, 1052.0f,
104 390.0f, 1061.0f, 391.0f, 1069.0f, 391.0f, 1075.0f,
105 391.0f, 1080.0f, 391.0f, 1085.0f, 391.0f, 1089.0f,
106 392.0f, 1095.0f, 393.0f, 1099.0f, 394.0f, 1103.0f,
107 395.0f, 1111.0f, 395.0f, 1117.0f, 396.0f, 1124.0f,
108 397.0f, 1130.0f, 397.0f, 1134.0f, 397.0f, 1138.0f };
109 const vector<int64_t> LINE_TIMESTAMPS = {
110 70809086, 70912930, 70923294, 70933960,
111 70944571, 70955130, 70965726, 70976076,
112 70986620, 70997190, 71007517, 71017998,
113 71028551, 71039171, 71049654, 71060120,
114 71070809, 71082130, 71091709, 71102285,
115 71112746, 71123402, 71133898, 71144469,
116 71154894, 71165617, 71175944, 71186477,
117 71197199, 71207737, 71218030, 71228652,
118 71239243, 71249733, 71260291, 71270821,
119 71281313, 71291919, 71302477, 71313573,
120 71323426, 71333880, 71355034, 71376110,
121 71418297, 71439219, 71449749, 71460268,
122 71470874, 71481275, 71744747 };
123 } // namespace
124 class KeyCommandHandlerTest : public testing::Test {
125 public:
SetUpTestCase(void)126 static void SetUpTestCase(void) {}
TearDownTestCase(void)127 static void TearDownTestCase(void) {}
128 std::shared_ptr<KeyEvent> SetupKeyEvent();
129 std::shared_ptr<PointerEvent> SetupThreeFingerTapEvent();
130 std::shared_ptr<PointerEvent> SetupFourFingerTapEvent();
131 #ifdef OHOS_BUILD_ENABLE_TOUCH
132 std::shared_ptr<PointerEvent> SetupDoubleFingerDownEvent();
133 std::shared_ptr<PointerEvent> SetupSingleKnuckleDownEvent();
134 std::shared_ptr<PointerEvent> SetupDoubleKnuckleDownEvent();
135 #endif // OHOS_BUILD_ENABLE_TOUCH
136 };
137
GetNanoTime()138 int64_t GetNanoTime()
139 {
140 struct timespec time = { 0 };
141 clock_gettime(CLOCK_MONOTONIC, &time);
142 return static_cast<int64_t>(time.tv_sec) * SEC_TO_NANOSEC + time.tv_nsec;
143 }
144
SetupKeyEvent()145 std::shared_ptr<KeyEvent> KeyCommandHandlerTest::SetupKeyEvent()
146 {
147 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
148 CHKPP(keyEvent);
149 int64_t downTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
150 KeyEvent::KeyItem kitDown;
151 kitDown.SetKeyCode(KeyEvent::KEYCODE_HOME);
152 kitDown.SetPressed(true);
153 kitDown.SetDownTime(downTime);
154 keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
155 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
156 keyEvent->AddPressedKeyItems(kitDown);
157
158 return keyEvent;
159 }
160
161 #ifdef OHOS_BUILD_ENABLE_TOUCH
SetupDoubleFingerDownEvent()162 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleFingerDownEvent()
163 {
164 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
165 CHKPP(pointerEvent);
166 PointerEvent::PointerItem item;
167 PointerEvent::PointerItem item2;
168 item.SetPointerId(0);
169 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
170 int32_t downX = 100;
171 int32_t downY = 200;
172 item.SetDisplayX(downX);
173 item.SetDisplayY(downY);
174 item.SetPressed(true);
175 pointerEvent->SetPointerId(0);
176 pointerEvent->AddPointerItem(item);
177
178 item2.SetPointerId(1);
179 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
180 int32_t secondDownX = 120;
181 int32_t secondDownY = 220;
182 item2.SetDisplayX(secondDownX);
183 item2.SetDisplayY(secondDownY);
184 item2.SetPressed(true);
185 pointerEvent->SetPointerId(1);
186 pointerEvent->AddPointerItem(item2);
187 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
188 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
189 return pointerEvent;
190 }
191
SetupSingleKnuckleDownEvent()192 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupSingleKnuckleDownEvent()
193 {
194 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
195 CHKPP(pointerEvent);
196 PointerEvent::PointerItem item;
197 item.SetPointerId(0);
198 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
199 int32_t downX = 100;
200 int32_t downY = 200;
201 item.SetDisplayX(downX);
202 item.SetDisplayY(downY);
203 item.SetPressed(true);
204 pointerEvent->SetPointerId(0);
205 pointerEvent->AddPointerItem(item);
206 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
207 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
208 return pointerEvent;
209 }
210
SetupDoubleKnuckleDownEvent()211 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupDoubleKnuckleDownEvent()
212 {
213 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
214 CHKPP(pointerEvent);
215 PointerEvent::PointerItem item;
216 PointerEvent::PointerItem item2;
217 item.SetPointerId(0);
218 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
219 int32_t downX = 100;
220 int32_t downY = 200;
221 item.SetDisplayX(downX);
222 item.SetDisplayY(downY);
223 item.SetPressed(true);
224 pointerEvent->SetPointerId(0);
225 pointerEvent->AddPointerItem(item);
226
227 item2.SetPointerId(1);
228 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
229 int32_t secondDownX = 120;
230 int32_t secondDownY = 220;
231 item2.SetDisplayX(secondDownX);
232 item2.SetDisplayY(secondDownY);
233 item2.SetPressed(true);
234 pointerEvent->SetPointerId(1);
235 pointerEvent->AddPointerItem(item2);
236 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
237 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
238 return pointerEvent;
239 }
240 #endif // OHOS_BUILD_ENABLE_TOUCH
241
SetupThreeFingerTapEvent()242 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupThreeFingerTapEvent()
243 {
244 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
245 CHKPP(pointerEvent);
246 PointerEvent::PointerItem item1;
247 PointerEvent::PointerItem item2;
248 PointerEvent::PointerItem item3;
249
250 int32_t id0 = 0;
251 item1.SetPointerId(id0);
252 int32_t downX1 = 100;
253 int32_t downY1 = 200;
254 int64_t actionTime1 = 1000000;
255 item1.SetDisplayX(downX1);
256 item1.SetDisplayY(downY1);
257 item1.SetDownTime(actionTime1);
258 pointerEvent->SetPointerId(id0);
259 pointerEvent->AddPointerItem(item1);
260
261 int32_t id1 = 1;
262 item2.SetPointerId(id1);
263 int32_t downX2 = 200;
264 int32_t downY2 = 300;
265 int64_t actionTime2 = 1000100;
266 item2.SetDisplayX(downX2);
267 item2.SetDisplayY(downY2);
268 item2.SetDownTime(actionTime2);
269 pointerEvent->SetPointerId(id1);
270 pointerEvent->AddPointerItem(item2);
271
272 int32_t id2 = 2;
273 item3.SetPointerId(id2);
274 int32_t downX3 = 100;
275 int32_t downY3 = 200;
276 int64_t actionTime3 = 1000200;
277 item3.SetDisplayX(downX3);
278 item3.SetDisplayY(downY3);
279 item3.SetDownTime(actionTime3);
280 pointerEvent->SetPointerId(id2);
281 pointerEvent->AddPointerItem(item3);
282
283 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP);
284 return pointerEvent;
285 }
286
SetupFourFingerTapEvent()287 std::shared_ptr<PointerEvent> KeyCommandHandlerTest::SetupFourFingerTapEvent()
288 {
289 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
290 CHKPP(pointerEvent);
291 PointerEvent::PointerItem item1;
292 PointerEvent::PointerItem item2;
293 PointerEvent::PointerItem item3;
294 PointerEvent::PointerItem item4;
295
296 int32_t id0 = 0;
297 item1.SetPointerId(id0);
298 int32_t downX1 = 100;
299 int32_t downY1 = 200;
300 int64_t actionTime1 = 1000000;
301 item1.SetDisplayX(downX1);
302 item1.SetDisplayY(downY1);
303 item1.SetDownTime(actionTime1);
304 pointerEvent->SetPointerId(id0);
305 pointerEvent->AddPointerItem(item1);
306
307 int32_t id1 = 1;
308 item2.SetPointerId(id1);
309 int32_t downX2 = 200;
310 int32_t downY2 = 300;
311 int64_t actionTime2 = 1000100;
312 item2.SetDisplayX(downX2);
313 item2.SetDisplayY(downY2);
314 item2.SetDownTime(actionTime2);
315 pointerEvent->SetPointerId(id1);
316 pointerEvent->AddPointerItem(item2);
317
318 int32_t id2 = 2;
319 item3.SetPointerId(id2);
320 int32_t downX3 = 100;
321 int32_t downY3 = 200;
322 int64_t actionTime3 = 1000200;
323 item3.SetDisplayX(downX3);
324 item3.SetDisplayY(downY3);
325 item3.SetDownTime(actionTime3);
326 pointerEvent->SetPointerId(id2);
327 pointerEvent->AddPointerItem(item3);
328
329 int32_t id3 = 3;
330 item4.SetPointerId(id3);
331 int32_t downX4 = 400;
332 int32_t downY4 = 280;
333 int64_t actionTime4 = 1000300;
334 item4.SetDisplayX(downX4);
335 item4.SetDisplayY(downY4);
336 item4.SetDownTime(actionTime4);
337 pointerEvent->SetPointerId(id3);
338 pointerEvent->AddPointerItem(item4);
339
340 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_QUADTAP);
341 return pointerEvent;
342 }
343
344 /**
345 * @tc.name: KeyCommandHandlerTest_OnHandleEvent_002
346 * @tc.desc: Test the funcation OnHandleEvent
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_OnHandleEvent_002, TestSize.Level1)
351 {
352 CALL_TEST_DEBUG;
353 KeyCommandHandler handler;
354 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
355 ASSERT_NE(key, nullptr);
356 key->SetKeyCode(18);
357 handler.specialKeys_.insert(std::make_pair(18, 18));
358 bool ret = handler.OnHandleEvent(key);
359 EXPECT_TRUE(ret);
360 key->SetKeyCode(KeyEvent::KEYCODE_POWER);
361 handler.specialTimers_.insert(std::make_pair(KeyEvent::KEYCODE_POWER, 10));
362 ret = handler.OnHandleEvent(key);
363 EXPECT_TRUE(ret);
364 key->SetKeyCode(5);
365 ret = handler.OnHandleEvent(key);
366 EXPECT_FALSE(ret);
367 }
368
369 /**
370 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_006
371 * @tc.desc: Test the funcation HandleShortKeys
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_006, TestSize.Level1)
376 {
377 KeyCommandHandler handler;
378 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
379 ASSERT_NE(keyEvent, nullptr);
380 ShortcutKey key;
381 key.preKeys = {2, 3, 4};
382 key.businessId = "business";
383 key.statusConfig = "config";
384 key.statusConfigValue = true;
385 key.finalKey = 6;
386 key.keyDownDuration = 7;
387 key.triggerType = KeyEvent::KEY_ACTION_DOWN;
388 key.timerId = 10;
389 handler.shortcutKeys_.insert(std::make_pair("key1", key));
390 bool ret = handler.HandleShortKeys(keyEvent);
391 ASSERT_FALSE(ret);
392 handler.currentLaunchAbilityKey_.businessId = "business1";
393 handler.currentLaunchAbilityKey_.statusConfig = "config1";
394 handler.currentLaunchAbilityKey_.timerId = 6;
395 handler.currentLaunchAbilityKey_.statusConfigValue = true;
396 handler.currentLaunchAbilityKey_.finalKey = 4;
397 handler.currentLaunchAbilityKey_.keyDownDuration = 5;
398 handler.currentLaunchAbilityKey_.triggerType = KeyEvent::KEY_ACTION_DOWN;
399 keyEvent->SetKeyCode(KeyEvent::INTENTION_RIGHT);
400 keyEvent->SetKeyAction(KeyEvent::INTENTION_UP);
401 SequenceKey sequenceKey;
402 sequenceKey.keyCode = 2017;
403 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
404 handler.keys_.push_back(sequenceKey);
405 sequenceKey.keyCode = 2022;
406 sequenceKey.keyAction = KeyEvent::INTENTION_UP;
407 handler.keys_.push_back(sequenceKey);
408 EventLogHelper eventLogHelper;
409 eventLogHelper.userType_ = "beta";
410 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
411 EXPECT_NE(inputEvent, nullptr);
412 inputEvent->bitwise_ = 0x00000040;
413 ret = handler.HandleShortKeys(keyEvent);
414 ASSERT_FALSE(ret);
415 eventLogHelper.userType_ = "abcde";
416 ret = handler.HandleShortKeys(keyEvent);
417 ASSERT_FALSE(ret);
418 inputEvent->bitwise_ = 0x00000000;
419 ret = handler.HandleShortKeys(keyEvent);
420 ASSERT_FALSE(ret);
421 handler.lastMatchedKey_.timerId = -5;
422 ret = handler.HandleShortKeys(keyEvent);
423 ASSERT_FALSE(ret);
424 }
425
426 /**
427 * @tc.name: KeyCommandHandlerTest_HandlePointerEvent_002
428 * @tc.desc: Test the funcation HandlePointerEvent
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandlePointerEvent_002, TestSize.Level1)
433 {
434 CALL_TEST_DEBUG;
435 KeyCommandHandler handler;
436 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
437 ASSERT_TRUE(pointerEvent != nullptr);
438 handler.isParseConfig_ = true;
439 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_QUADTAP);
440 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
441
442 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP);
443 EventLogHelper eventLogHelper;
444 eventLogHelper.userType_ = "beta";
445 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
446 EXPECT_NE(inputEvent, nullptr);
447 inputEvent->bitwise_ = 0;
448 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
449 eventLogHelper.userType_ = "default";
450 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
451 inputEvent->bitwise_ = InputEvent::EVENT_FLAG_PRIVACY_MODE;
452 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
453 }
454
455 /**
456 * @tc.name: KeyCommandHandlerTest_StartTwoFingerGesture_003
457 * @tc.desc: Test the funcation StartTwoFingerGesture
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_StartTwoFingerGesture_003, TestSize.Level1)
462 {
463 CALL_TEST_DEBUG;
464 KeyCommandHandler handler;
465 handler.twoFingerGesture_.active = true;
466 handler.twoFingerGesture_.touches[0].downTime = 150000;
467 handler.twoFingerGesture_.touches[0].id = 10;
468 handler.twoFingerGesture_.touches[0].x = 100;
469 handler.twoFingerGesture_.touches[0].y = 200;
470 handler.twoFingerGesture_.touches[1].downTime = 100000;
471 handler.twoFingerGesture_.touches[0].id = 5;
472 handler.twoFingerGesture_.touches[0].x = 50;
473 handler.twoFingerGesture_.touches[0].y = 100;
474 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
475 handler.twoFingerGesture_.touches[0].downTime = 350000;
476 handler.twoFingerGesture_.touches[1].downTime = 100000;
477 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
478 handler.twoFingerGesture_.active = false;
479 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
480 }
481
482 /**
483 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_006
484 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_006, TestSize.Level1)
489 {
490 CALL_TEST_DEBUG;
491 KeyCommandHandler handler;
492 handler.twoFingerGesture_.active = true;
493 handler.twoFingerGesture_.touches[0].id = 1;
494 handler.twoFingerGesture_.touches[0].x = 30;
495 handler.twoFingerGesture_.touches[0].y = 20;
496 handler.twoFingerGesture_.touches[0].downTime = 150000;
497 handler.twoFingerGesture_.touches[1].id = 2;
498 handler.twoFingerGesture_.touches[1].x = 20;
499 handler.twoFingerGesture_.touches[1].y = 10;
500 handler.twoFingerGesture_.touches[1].downTime = 100000;
501 InputWindowsManager inputWindowsManager;
502 DisplayInfo displayInfo;
503 displayInfo.dpi = 320;
504 displayInfo.width = 150;
505 displayInfo.height = 300;
506 displayInfo.uniq = "default0";
507 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
508 bool ret = handler.CheckTwoFingerGestureAction();
509 EXPECT_FALSE(ret);
510 handler.twoFingerGesture_.touches[0].x = 30;
511 handler.twoFingerGesture_.touches[0].y = 200;
512 handler.twoFingerGesture_.touches[1].x = 60;
513 handler.twoFingerGesture_.touches[1].y = 170;
514 ret = handler.CheckTwoFingerGestureAction();
515 EXPECT_FALSE(ret);
516 handler.twoFingerGesture_.touches[0].x = 120;
517 ret = handler.CheckTwoFingerGestureAction();
518 EXPECT_FALSE(ret);
519 handler.twoFingerGesture_.touches[0].x = 90;
520 handler.twoFingerGesture_.touches[0].y = 120;
521 ret = handler.CheckTwoFingerGestureAction();
522 EXPECT_FALSE(ret);
523 handler.twoFingerGesture_.touches[0].y = 250;
524 ret = handler.CheckTwoFingerGestureAction();
525 EXPECT_FALSE(ret);
526 }
527
528 /**
529 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_007
530 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
531 * @tc.type: FUNC
532 * @tc.require:
533 */
534 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_007, TestSize.Level1)
535 {
536 CALL_TEST_DEBUG;
537 KeyCommandHandler handler;
538 handler.twoFingerGesture_.active = true;
539 handler.twoFingerGesture_.touches[0].x = 90;
540 handler.twoFingerGesture_.touches[0].y = 200;
541 handler.twoFingerGesture_.touches[0].downTime = 150000;
542 handler.twoFingerGesture_.touches[1].x = 30;
543 handler.twoFingerGesture_.touches[1].y = 170;
544 handler.twoFingerGesture_.touches[1].downTime = 100000;
545 InputWindowsManager inputWindowsManager;
546 DisplayInfo displayInfo;
547 displayInfo.dpi = 320;
548 displayInfo.width = 150;
549 displayInfo.height = 300;
550 displayInfo.uniq = "default0";
551 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
552 handler.twoFingerGesture_.touches[0].y = 200;
553 handler.twoFingerGesture_.touches[1].x = 30;
554 bool ret = handler.CheckTwoFingerGestureAction();
555 EXPECT_FALSE(ret);
556 handler.twoFingerGesture_.touches[1].x = 130;
557 ret = handler.CheckTwoFingerGestureAction();
558 EXPECT_FALSE(ret);
559 handler.twoFingerGesture_.touches[1].x = 60;
560 handler.twoFingerGesture_.touches[1].y = 100;
561 ret = handler.CheckTwoFingerGestureAction();
562 EXPECT_FALSE(ret);
563 handler.twoFingerGesture_.touches[1].y = 250;
564 ret = handler.CheckTwoFingerGestureAction();
565 EXPECT_FALSE(ret);
566 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
567 handler.twoFingerGesture_.touches[1].y = 170;
568 ret = handler.CheckTwoFingerGestureAction();
569 EXPECT_FALSE(ret);
570 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
571 }
572
573 /**
574 * @tc.name: KeyCommandHandlerTest_ConvertVPToPX_004
575 * @tc.desc: Test the funcation ConvertVPToPX
576 * @tc.type: FUNC
577 * @tc.require:
578 */
579 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ConvertVPToPX_004, TestSize.Level1)
580 {
581 CALL_TEST_DEBUG;
582 KeyCommandHandler handler;
583 int32_t vp = 10;
584 InputWindowsManager inputWindowsManager;
585 DisplayInfo displayInfo;
586 displayInfo.dpi = -10;
587 displayInfo.uniq = "default0";
588 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
589 int32_t ret = handler.ConvertVPToPX(vp);
590 ASSERT_EQ(ret, 0);
591 displayInfo.dpi = 160;
592 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
593 ret = handler.ConvertVPToPX(vp);
594 ASSERT_EQ(ret, 0);
595 }
596
597 /**
598 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureEvent_004
599 * @tc.desc: Test the funcation HandleKnuckleGestureEvent
600 * @tc.type: FUNC
601 * @tc.require:
602 */
603 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureEvent_004, TestSize.Level1)
604 {
605 CALL_TEST_DEBUG;
606 KeyCommandHandler handler;
607 PointerEvent::PointerItem item;
608 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
609 ASSERT_NE(touchEvent, nullptr);
610 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
611 handler.singleKnuckleGesture_.state = false;
612 handler.knuckleSwitch_.statusConfigValue = false;
613 touchEvent->AddPointerItem(item);
614 touchEvent->SetPointerId(1);
615 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
616 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
617 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
618 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
619 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
620 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
621 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
622 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
623 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN);
624 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
625 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
626 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
627 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
628 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
629 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
630 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
631 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
632 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
633 }
634
635 /**
636 * @tc.name: KeyCommandHandlerTest_OnHandleTouchEvent
637 * @tc.desc: Test OnHandleTouchEvent
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_OnHandleTouchEvent, TestSize.Level1)
642 {
643 CALL_TEST_DEBUG;
644 KeyCommandHandler handler;
645 PointerEvent::PointerItem item;
646 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
647 ASSERT_NE(touchEvent, nullptr);
648 handler.isParseConfig_ = false;
649 handler.isTimeConfig_ = false;
650 handler.isDistanceConfig_ = false;
651 handler.isKnuckleSwitchConfig_ = true;
652 item.SetPointerId(1);
653 item.SetToolType(PointerEvent::TOOL_TYPE_PENCIL);
654 touchEvent->AddPointerItem(item);
655 touchEvent->SetPointerId(1);
656 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
657 ASSERT_NO_FATAL_FAILURE(handler.OnHandleTouchEvent(touchEvent));
658
659 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
660 ASSERT_NO_FATAL_FAILURE(handler.OnHandleTouchEvent(touchEvent));
661
662 touchEvent->RemovePointerItem(1);
663 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
664 ASSERT_NO_FATAL_FAILURE(handler.OnHandleTouchEvent(touchEvent));
665
666 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN);
667 ASSERT_NO_FATAL_FAILURE(handler.OnHandleTouchEvent(touchEvent));
668 }
669
670 /**
671 * @tc.name: KeyCommandHandlerTest_HandlePointerActionMoveEvent
672 * @tc.desc: Test HandlePointerActionMoveEvent
673 * @tc.type: FUNC
674 * @tc.require:
675 */
676 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandlePointerActionMoveEvent, TestSize.Level1)
677 {
678 CALL_TEST_DEBUG;
679 KeyCommandHandler handler;
680 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
681 ASSERT_NE(touchEvent, nullptr);
682 handler.twoFingerGesture_.active = true;
683 handler.twoFingerGesture_.timerId = -1;
684 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerActionMoveEvent(touchEvent));
685
686 touchEvent->SetPointerId(2);
687 handler.twoFingerGesture_.timerId = 1;
688 handler.twoFingerGesture_.touches->id = 1;
689 handler.twoFingerGesture_.touches->x = 25;
690 handler.twoFingerGesture_.touches->y = 25;
691 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerActionMoveEvent(touchEvent));
692
693 touchEvent->SetPointerId(1);
694 PointerEvent::PointerItem item;
695 item.SetDisplayX(5);
696 item.SetDisplayY(5);
697 touchEvent->AddPointerItem(item);
698 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerActionMoveEvent(touchEvent));
699 }
700
701 /**
702 * @tc.name: KeyCommandHandlerTest_HandleFingerGestureDownEvent
703 * @tc.desc: Test HandleFingerGestureDownEvent
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleFingerGestureDownEvent, TestSize.Level1)
708 {
709 CALL_TEST_DEBUG;
710 KeyCommandHandler handler;
711 PointerEvent::PointerItem item;
712 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
713 ASSERT_NE(touchEvent, nullptr);
714 handler.twoFingerGesture_.active = true;
715 item.SetPointerId(1);
716 item.SetDisplayX(10);
717 item.SetDisplayY(10);
718 touchEvent->AddPointerItem(item);
719 touchEvent->SetPointerId(1);
720 ASSERT_NO_FATAL_FAILURE(handler.HandleFingerGestureDownEvent(touchEvent));
721
722 item.SetPointerId(2);
723 item.SetDisplayX(15);
724 item.SetDisplayY(15);
725 touchEvent->AddPointerItem(item);
726 ASSERT_NO_FATAL_FAILURE(handler.HandleFingerGestureDownEvent(touchEvent));
727
728 handler.twoFingerGesture_.active = true;
729 handler.twoFingerGesture_.timerId = 150;
730 ASSERT_NO_FATAL_FAILURE(handler.HandleFingerGestureUpEvent(touchEvent));
731 }
732
733 /**
734 * @tc.name: KeyCommandHandlerTest_HandleFingerGestureDownEvent_001
735 * @tc.desc: Test HandleFingerGestureDownEvent
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleFingerGestureDownEvent_001, TestSize.Level1)
740 {
741 CALL_TEST_DEBUG;
742 KeyCommandHandler handler;
743 PointerEvent::PointerItem item;
744 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
745 ASSERT_NE(touchEvent, nullptr);
746 handler.twoFingerGesture_.active = true;
747 ASSERT_NO_FATAL_FAILURE(handler.HandleFingerGestureDownEvent(touchEvent));
748
749 item.SetPointerId(1);
750 touchEvent->AddPointerItem(item);
751 item.SetPointerId(2);
752 touchEvent->AddPointerItem(item);
753 item.SetPointerId(3);
754 touchEvent->AddPointerItem(item);
755 ASSERT_NO_FATAL_FAILURE(handler.HandleFingerGestureDownEvent(touchEvent));
756 }
757
758 /**
759 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_001
760 * @tc.desc: Test HandleKnuckleGestureDownEvent_001
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_001, TestSize.Level1)
765 {
766 CALL_TEST_DEBUG;
767 KeyCommandHandler handler;
768 PointerEvent::PointerItem item;
769 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
770 ASSERT_NE(touchEvent, nullptr);
771 handler.twoFingerGesture_.active = true;
772 item.SetPointerId(1);
773 item.SetToolType(PointerEvent::TOOL_TYPE_PALM);
774 touchEvent->AddPointerItem(item);
775 touchEvent->SetPointerId(1);
776 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureDownEvent(touchEvent));
777
778 item.SetPointerId(2);
779 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
780 touchEvent->AddPointerItem(item);
781 item.SetPointerId(3);
782 touchEvent->AddPointerItem(item);
783 touchEvent->SetPointerId(2);
784 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureDownEvent(touchEvent));
785
786 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureUpEvent(touchEvent));
787 }
788
789 /**
790 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_002
791 * @tc.desc: Test HandleKnuckleGestureDownEvent_002
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_002, TestSize.Level1)
796 {
797 CALL_TEST_DEBUG;
798 KeyCommandHandler handler;
799 PointerEvent::PointerItem item;
800 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
801 ASSERT_NE(touchEvent, nullptr);
802 handler.twoFingerGesture_.active = true;
803 handler.knuckleSwitch_.statusConfigValue = true;
804
805 item.SetPointerId(2);
806 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
807 touchEvent->AddPointerItem(item);
808 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureDownEvent(touchEvent));
809 }
810
811 /**
812 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_003
813 * @tc.desc: Test HandleKnuckleGestureDownEvent_003
814 * @tc.type: FUNC
815 * @tc.require:
816 */
817 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureDownEvent_003, TestSize.Level1)
818 {
819 CALL_TEST_DEBUG;
820 KeyCommandHandler handler;
821 PointerEvent::PointerItem item;
822 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
823 ASSERT_NE(touchEvent, nullptr);
824 handler.twoFingerGesture_.active = true;
825 handler.knuckleSwitch_.statusConfigValue = false;
826
827 item.SetPointerId(2);
828 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
829 touchEvent->AddPointerItem(item);
830 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureDownEvent(touchEvent));
831 }
832
833 /**
834 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureUpEvent
835 * @tc.desc: Test HandleKnuckleGestureUpEvent
836 * @tc.type: FUNC
837 * @tc.require:
838 */
839 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureUpEvent, TestSize.Level1)
840 {
841 CALL_TEST_DEBUG;
842 KeyCommandHandler handler;
843 PointerEvent::PointerItem item;
844 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
845 ASSERT_NE(touchEvent, nullptr);
846 item.SetPointerId(1);
847 touchEvent->AddPointerItem(item);
848 handler.isDoubleClick_ = true;
849 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureUpEvent(touchEvent));
850 }
851
852 /**
853 * @tc.name: KeyCommandHandlerTest_KnuckleGestureProcessor
854 * @tc.desc: Test KnuckleGestureProcessor
855 * @tc.type: FUNC
856 * @tc.require:
857 */
858 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleGestureProcessor, TestSize.Level1)
859 {
860 CALL_TEST_DEBUG;
861 KeyCommandHandler handler;
862 KnuckleGesture knuckleGesture;
863 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
864 ASSERT_NE(touchEvent, nullptr);
865 knuckleGesture.lastPointerDownEvent = touchEvent;
866 knuckleGesture.lastPointerUpTime = 10;
867 touchEvent->SetActionTime(5);
868 handler.knuckleCount_ = 2;
869 ASSERT_NO_FATAL_FAILURE(handler.KnuckleGestureProcessor(touchEvent,
870 knuckleGesture, KnuckleType::KNUCKLE_TYPE_SINGLE));
871 }
872
873 /**
874 * @tc.name: KeyCommandHandlerTest_HandleMultiTapTest__001
875 * @tc.desc: Test three fingers tap event launch ability
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMultiTapTest__001, TestSize.Level1)
880 {
881 CALL_TEST_DEBUG;
882 auto threeFingerTap = SetupThreeFingerTapEvent();
883 ASSERT_TRUE(threeFingerTap != nullptr);
884 KeyCommandHandler keyCommandHandler;
885 ASSERT_TRUE(keyCommandHandler.OnHandleEvent(threeFingerTap));
886 }
887
888 /**
889 * @tc.name: KeyCommandHandlerTest_HandleMultiTapTest__002
890 * @tc.desc: Test four fingers tap event launch ability
891 * @tc.type: FUNC
892 * @tc.require:
893 */
894 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMultiTapTest__002, TestSize.Level1)
895 {
896 CALL_TEST_DEBUG;
897 auto fourFingerTap = SetupFourFingerTapEvent();
898 ASSERT_TRUE(fourFingerTap != nullptr);
899 KeyCommandHandler keyCommandHandler;
900 ASSERT_FALSE(keyCommandHandler.OnHandleEvent(fourFingerTap));
901 }
902
903 /**
904 * @tc.name: KeyCommandHandlerTest_001
905 * @tc.desc: Test update key down duration 0, 100, 4000
906 * @tc.type: FUNC
907 * @tc.require:
908 */
909 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_001, TestSize.Level1)
910 {
911 KeyCommandHandler eventKeyCommandHandler;
912 std::string businessId = "aaa";
913 int32_t delay = 0;
914 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
915 delay = 100;
916 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
917 delay = 4000;
918 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
919 }
920
921 /**
922 * @tc.name: KeyCommandHandlerTest_EnableCombineKey_001
923 * @tc.desc: Test enable combineKey
924 * @tc.type: FUNC
925 * @tc.require:
926 */
927 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_EnableCombineKey_001, TestSize.Level1)
928 {
929 KeyCommandHandler eventKeyCommandHandler;
930 ASSERT_EQ(eventKeyCommandHandler.EnableCombineKey(true), RET_OK);
931 }
932
933 /**
934 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_001
935 * @tc.desc: Test IsEnableCombineKey
936 * @tc.type: FUNC
937 * @tc.require:
938 */
939 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_001, TestSize.Level1)
940 {
941 KeyCommandHandler eventKeyCommandHandler;
942 eventKeyCommandHandler.EnableCombineKey(false);
943 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
944 CHKPV(keyEvent);
945 KeyEvent::KeyItem item;
946 item.SetKeyCode(KeyEvent::KEYCODE_POWER);
947 keyEvent->AddKeyItem(item);
948 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER);
949 ASSERT_EQ(eventKeyCommandHandler.OnHandleEvent(keyEvent), false);
950 eventKeyCommandHandler.EnableCombineKey(true);
951 }
952
953 /**
954 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_002
955 * @tc.desc: Test IsEnableCombineKey
956 * @tc.type: FUNC
957 * @tc.require:
958 */
959 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_002, TestSize.Level1)
960 {
961 KeyCommandHandler eventKeyCommandHandler;
962 eventKeyCommandHandler.EnableCombineKey(false);
963 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
964 CHKPV(keyEvent);
965 KeyEvent::KeyItem item1;
966 item1.SetKeyCode(KeyEvent::KEYCODE_META_LEFT);
967 keyEvent->AddKeyItem(item1);
968 KeyEvent::KeyItem item2;
969 item2.SetKeyCode(KeyEvent::KEYCODE_L);
970 keyEvent->AddKeyItem(item2);
971 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L);
972 ASSERT_EQ(eventKeyCommandHandler.OnHandleEvent(keyEvent), false);
973 eventKeyCommandHandler.EnableCombineKey(true);
974 }
975
976 /**
977 * @tc.name: KeyCommandHandlerTest_002
978 * @tc.desc: Test update key down duration -1 and 4001
979 * @tc.type: FUNC
980 * @tc.require:
981 */
982 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_002, TestSize.Level1)
983 {
984 KeyCommandHandler eventKeyCommandHandler;
985 std::string businessId = "com.ohos.camera";
986 int32_t delay = -1;
987 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
988 delay = 4001;
989 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
990 }
991
992 /**
993 * @tc.name: KeyCommandHandlerTest_003
994 * @tc.desc: Test businessId is ""
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_003, TestSize.Level1)
999 {
1000 KeyCommandHandler eventKeyCommandHandler;
1001 std::string businessId = "";
1002 int32_t delay = 100;
1003 ASSERT_EQ(COMMON_PARAMETER_ERROR, eventKeyCommandHandler.UpdateSettingsXml(businessId, delay));
1004 }
1005
1006 /**
1007 * @tc.name: KeyCommandHandlerTest_004
1008 * @tc.desc: Test key event
1009 * @tc.type: FUNC
1010 * @tc.require:
1011 */
1012 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_004, TestSize.Level1)
1013 {
1014 CALL_TEST_DEBUG;
1015 auto keyEvent = SetupKeyEvent();
1016 ASSERT_TRUE(keyEvent != nullptr);
1017 KeyCommandHandler eventKeyCommandHandler;
1018 ASSERT_FALSE(eventKeyCommandHandler.OnHandleEvent(keyEvent));
1019 }
1020
1021 /**
1022 * @tc.name: KeyCommandHandlerTest_HandleEvent_01
1023 * @tc.desc: Test HandleEvent
1024 * @tc.type: FUNC
1025 * @tc.require:
1026 */
1027 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_01, TestSize.Level1)
1028 {
1029 CALL_TEST_DEBUG;
1030 auto keyEvent = SetupKeyEvent();
1031 ASSERT_TRUE(keyEvent != nullptr);
1032 KeyCommandHandler eventKeyCommandHandler;
1033
1034 bool preHandleEvent = eventKeyCommandHandler.PreHandleEvent(keyEvent);
1035 EXPECT_TRUE(preHandleEvent);
1036 bool ret = eventKeyCommandHandler.HandleEvent(keyEvent);
1037 EXPECT_FALSE(ret);
1038 }
1039
1040 /**
1041 * @tc.name: KeyCommandHandlerTest_HandleEvent_02
1042 * @tc.desc: Test HandleEvent
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_02, TestSize.Level1)
1047 {
1048 CALL_TEST_DEBUG;
1049 auto keyEvent = SetupKeyEvent();
1050 ASSERT_TRUE(keyEvent != nullptr);
1051 KeyCommandHandler eventKeyCommandHandler;
1052
1053 bool stylusKey = STYLUS_HANDLER->HandleStylusKey(keyEvent);
1054 EXPECT_FALSE(stylusKey);
1055 bool ret = eventKeyCommandHandler.HandleEvent(keyEvent);
1056 EXPECT_FALSE(ret);
1057 }
1058
1059 /**
1060 * @tc.name: KeyCommandHandlerTest_HandleEvent_03
1061 * @tc.desc: Test HandleEvent
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_03, TestSize.Level1)
1066 {
1067 CALL_TEST_DEBUG;
1068 auto keyEvent = SetupKeyEvent();
1069 ASSERT_TRUE(keyEvent != nullptr);
1070 KeyCommandHandler eventKeyCommandHandler;
1071
1072 bool isHandled = eventKeyCommandHandler.HandleShortKeys(keyEvent);
1073 EXPECT_FALSE(isHandled);
1074 bool ret = eventKeyCommandHandler.HandleEvent(keyEvent);
1075 EXPECT_FALSE(ret);
1076 }
1077
1078 /**
1079 * @tc.name: KeyCommandHandlerTest_HandleEvent_04
1080 * @tc.desc: Test HandleEvent
1081 * @tc.type: FUNC
1082 * @tc.require:
1083 */
1084 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_04, TestSize.Level1)
1085 {
1086 CALL_TEST_DEBUG;
1087 auto keyEvent = SetupKeyEvent();
1088 ASSERT_TRUE(keyEvent != nullptr);
1089 KeyCommandHandler eventKeyCommandHandler;
1090
1091 eventKeyCommandHandler.isDownStart_ = true;
1092 bool isRepeatKeyHandle = eventKeyCommandHandler.HandleRepeatKeys(keyEvent);
1093 EXPECT_FALSE(isRepeatKeyHandle);
1094 bool ret = eventKeyCommandHandler.HandleEvent(keyEvent);
1095 EXPECT_FALSE(ret);
1096 }
1097
1098 /**
1099 * @tc.name: KeyCommandHandlerTest_ParseJson_01
1100 * @tc.desc: Test ParseJson
1101 * @tc.type: FUNC
1102 * @tc.require:
1103 */
1104 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ParseJson_01, TestSize.Level1)
1105 {
1106 CALL_TEST_DEBUG;
1107 std::string configFile = "abc";
1108 std::string jsonStr = ReadJsonFile(configFile);
1109 KeyCommandHandler eventKeyCommandHandler;
1110
1111 jsonStr = "";
1112 bool ret = eventKeyCommandHandler.ParseJson(configFile);
1113 EXPECT_TRUE(jsonStr.empty());
1114 EXPECT_FALSE(ret);
1115 }
1116
1117 /**
1118 * @tc.name: KeyCommandHandlerTest_ParseJson_02
1119 * @tc.desc: Test ParseJson
1120 * @tc.type: FUNC
1121 * @tc.require:
1122 */
1123 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ParseJson_02, TestSize.Level1)
1124 {
1125 CALL_TEST_DEBUG;
1126 std::string configFile = "config";
1127 std::string jsonStr = ReadJsonFile(configFile);
1128 KeyCommandHandler eventKeyCommandHandler;
1129
1130 jsonStr = "abc";
1131 bool ret = eventKeyCommandHandler.ParseJson(configFile);
1132 EXPECT_FALSE(jsonStr.empty());
1133 EXPECT_FALSE(ret);
1134 }
1135
1136 /**
1137 * @tc.name: KeyCommandHandlerTest_ProcessKnuckleGestureTouchUp_01
1138 * @tc.desc: Test ProcessKnuckleGestureTouchUp
1139 * @tc.type: FUNC
1140 * @tc.require:
1141 */
1142 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ProcessKnuckleGestureTouchUp_01, TestSize.Level1)
1143 {
1144 CALL_TEST_DEBUG;
1145 NotifyType type;
1146 KeyCommandHandler eventKeyCommandHandler;
1147 type = NotifyType::REGIONGESTURE;
1148 ASSERT_NO_FATAL_FAILURE(eventKeyCommandHandler.ProcessKnuckleGestureTouchUp(type));
1149 }
1150
1151 /**
1152 * @tc.name: KeyCommandHandlerTest_ProcessKnuckleGestureTouchUp_02
1153 * @tc.desc: Test ProcessKnuckleGestureTouchUp
1154 * @tc.type: FUNC
1155 * @tc.require:
1156 */
1157 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ProcessKnuckleGestureTouchUp_02, TestSize.Level1)
1158 {
1159 CALL_TEST_DEBUG;
1160 NotifyType type;
1161 KeyCommandHandler eventKeyCommandHandler;
1162 type = NotifyType::LETTERGESTURE;
1163 ASSERT_NO_FATAL_FAILURE(eventKeyCommandHandler.ProcessKnuckleGestureTouchUp(type));
1164 }
1165
1166 /**
1167 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_01
1168 * @tc.desc: Test CheckTwoFingerGestureAction
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_01, TestSize.Level1)
1173 {
1174 CALL_TEST_DEBUG;
1175 KeyCommandHandler eventKeyCommandHandler;
1176 bool isActive = eventKeyCommandHandler.twoFingerGesture_.active;
1177 EXPECT_FALSE(isActive);
1178 bool ret = eventKeyCommandHandler.CheckTwoFingerGestureAction();
1179 EXPECT_FALSE(ret);
1180 }
1181
1182 /**
1183 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_02
1184 * @tc.desc: Test CheckTwoFingerGestureAction
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 */
1188 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_02, TestSize.Level1)
1189 {
1190 CALL_TEST_DEBUG;
1191 KeyCommandHandler eventKeyCommandHandler;
1192 auto pressTimeInterval = fabs(200000 - 40000);
1193 EXPECT_TRUE(pressTimeInterval > TWO_FINGERS_TIME_LIMIT);
1194 bool ret = eventKeyCommandHandler.CheckTwoFingerGestureAction();
1195 EXPECT_FALSE(ret);
1196 }
1197
1198 /**
1199 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_03
1200 * @tc.desc: Test CheckTwoFingerGestureAction
1201 * @tc.type: FUNC
1202 * @tc.require:
1203 */
1204 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_03, TestSize.Level1)
1205 {
1206 CALL_TEST_DEBUG;
1207 KeyCommandHandler eventKeyCommandHandler;
1208 auto pressTimeInterval = fabs(200000 - 60000);
1209 EXPECT_FALSE(pressTimeInterval > TWO_FINGERS_TIME_LIMIT);
1210 bool ret = eventKeyCommandHandler.CheckTwoFingerGestureAction();
1211 EXPECT_FALSE(ret);
1212 }
1213
1214 #ifdef OHOS_BUILD_ENABLE_TOUCH
1215 /**
1216 * @tc.name: KeyCommandHandlerTest_TouchTest_001
1217 * @tc.desc: Test double finger down event
1218 * @tc.type: FUNC
1219 * @tc.require:
1220 */
1221 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_TouchTest_001, TestSize.Level1)
1222 {
1223 CALL_TEST_DEBUG;
1224 auto pointerEvent = SetupDoubleFingerDownEvent();
1225 ASSERT_TRUE(pointerEvent != nullptr);
1226 KeyCommandHandler keyCommandHandler;
1227 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1228 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1229 keyCommandHandler.HandlePointerActionMoveEvent(pointerEvent);
1230 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1231 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1232 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1233 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1234 }
1235
1236 /**
1237 * @tc.name: KeyCommandHandlerTest_KnuckleTest_001
1238 * @tc.desc: Test single knuckle double click
1239 * @tc.type: FUNC
1240 * @tc.require:
1241 */
1242 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_001, TestSize.Level1)
1243 {
1244 CALL_TEST_DEBUG;
1245 auto pointerEvent = SetupSingleKnuckleDownEvent();
1246 ASSERT_TRUE(pointerEvent != nullptr);
1247 KeyCommandHandler keyCommandHandler;
1248 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1249 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
1250 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1251 pointerEvent->SetActionTime(actionTime);
1252 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1253 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1254 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1255 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1256 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1257 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1258 actionTime = actionTime + INTERVAL_TIME;
1259 pointerEvent->SetActionTime(actionTime);
1260 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1261 ASSERT_TRUE(keyCommandHandler.GetSingleKnuckleGesture().state);
1262 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1263 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1264 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1265 }
1266
1267 /**
1268 * @tc.name: KeyCommandHandlerTest_KnuckleTest_002
1269 * @tc.desc: Test double knuckle double click
1270 * @tc.type: FUNC
1271 * @tc.require:
1272 */
1273 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_002, TestSize.Level1)
1274 {
1275 CALL_TEST_DEBUG;
1276 auto pointerEvent = SetupDoubleKnuckleDownEvent();
1277 ASSERT_TRUE(pointerEvent != nullptr);
1278 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1279 pointerEvent->SetActionTime(actionTime);
1280 KeyCommandHandler keyCommandHandler;
1281 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1282 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
1283 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1284 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1285 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1286 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1287 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1288 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1289 actionTime = actionTime + INTERVAL_TIME;
1290 pointerEvent->SetActionTime(actionTime);
1291 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1292 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1293 ASSERT_TRUE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1294 }
1295
1296 /**
1297 * @tc.name: KeyCommandHandlerTest_KnuckleTest_003
1298 * @tc.desc: Test single knuckle event to double knuckle event
1299 * @tc.type: FUNC
1300 * @tc.require:
1301 */
1302 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_003, TestSize.Level1)
1303 {
1304 CALL_TEST_DEBUG;
1305 auto singlePointerEvent = SetupSingleKnuckleDownEvent();
1306 ASSERT_TRUE(singlePointerEvent != nullptr);
1307 auto pointerEvent = SetupDoubleKnuckleDownEvent();
1308 ASSERT_TRUE(pointerEvent != nullptr);
1309 KeyCommandHandler keyCommandHandler;
1310 keyCommandHandler.HandlePointerActionDownEvent(singlePointerEvent);
1311 singlePointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1312 keyCommandHandler.HandlePointerActionUpEvent(singlePointerEvent);
1313 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1314 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1315 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1316 }
1317
1318 /**
1319 * @tc.name: KeyCommandHandlerTest_KnuckleTest_004
1320 * @tc.desc: Test sing knuckle double click interval time out
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_004, TestSize.Level1)
1325 {
1326 CALL_DEBUG_ENTER;
1327 auto pointerEvent = SetupSingleKnuckleDownEvent();
1328 ASSERT_TRUE(pointerEvent != nullptr);
1329 KeyCommandHandler keyCommandHandler;
1330 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1331 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
1332 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1333 pointerEvent->SetActionTime(actionTime);
1334 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1335
1336 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1337 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1338 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1339 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1340 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1341 actionTime = actionTime + INTERVAL_TIME_OUT;
1342 pointerEvent->SetActionTime(actionTime);
1343 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1344 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1345 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1346 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1347 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1348 }
1349
1350 /**
1351 * @tc.name: KeyCommandHandlerTest_KnuckleTest_005
1352 * @tc.desc: Test double knuckle double CLICK click interval time out
1353 * @tc.type: FUNC
1354 * @tc.require:
1355 */
1356 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_005, TestSize.Level1)
1357 {
1358 CALL_DEBUG_ENTER;
1359 auto pointerEvent = SetupDoubleKnuckleDownEvent();
1360 ASSERT_TRUE(pointerEvent != nullptr);
1361 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1362 pointerEvent->SetActionTime(actionTime);
1363 KeyCommandHandler keyCommandHandler;
1364 keyCommandHandler.SetKnuckleDoubleTapIntervalTime(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1365 keyCommandHandler.SetKnuckleDoubleTapDistance(DOUBLE_CLICK_DISTANCE_DEFAULT_CONFIG);
1366 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1367 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1368 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1369 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1370 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1371 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1372 actionTime = actionTime + INTERVAL_TIME_OUT;
1373 pointerEvent->SetActionTime(actionTime);
1374 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1375 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1376 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1377 }
1378
1379 /**
1380 * @tc.name: KeyCommandHandlerTest_KnuckleTest_006
1381 * @tc.desc: Test the tool type is TOOL_TYPE_TOUCHPAD Action down
1382 * @tc.type: FUNC
1383 * @tc.require:
1384 */
1385 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_006, TestSize.Level1)
1386 {
1387 CALL_DEBUG_ENTER;
1388 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1389 ASSERT_TRUE(pointerEvent != nullptr);
1390 PointerEvent::PointerItem item;
1391 item.SetPointerId(0);
1392 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
1393 int32_t downX = 100;
1394 int32_t downY = 200;
1395 item.SetDisplayX(downX);
1396 item.SetDisplayY(downY);
1397 item.SetPressed(true);
1398 pointerEvent->SetPointerId(0);
1399 pointerEvent->AddPointerItem(item);
1400 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1401 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1402 KeyCommandHandler keyCommandHandler;
1403 keyCommandHandler.HandlePointerActionDownEvent(pointerEvent);
1404 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1405 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1406 }
1407
1408 /**
1409 * @tc.name: KeyCommandHandlerTest_KnuckleTest_007
1410 * @tc.desc: Test the tool type is TOOL_TYPE_TOUCHPAD Action up
1411 * @tc.type: FUNC
1412 * @tc.require:
1413 */
1414 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KnuckleTest_007, TestSize.Level1)
1415 {
1416 CALL_DEBUG_ENTER;
1417 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1418 ASSERT_TRUE(pointerEvent != nullptr);
1419 PointerEvent::PointerItem item;
1420 item.SetPointerId(0);
1421 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
1422 int32_t downX = 100;
1423 int32_t downY = 200;
1424 item.SetDisplayX(downX);
1425 item.SetDisplayY(downY);
1426 item.SetPressed(true);
1427 pointerEvent->SetPointerId(0);
1428 pointerEvent->AddPointerItem(item);
1429 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1430 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1431 KeyCommandHandler keyCommandHandler;
1432 keyCommandHandler.HandlePointerActionUpEvent(pointerEvent);
1433 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1434 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1435 }
1436
1437 /**
1438 * @tc.name: KeyCommandHandlerTest_HandleTouchEventTest_001
1439 * @tc.desc: Test signl knuckle CLICK set HandleTouchEvent pointerEvent
1440 * @tc.type: FUNC
1441 * @tc.require:
1442 */
1443 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleTouchEventTest_001, TestSize.Level1)
1444 {
1445 CALL_DEBUG_ENTER;
1446 auto pointerEvent = SetupSingleKnuckleDownEvent();
1447 ASSERT_TRUE(pointerEvent != nullptr);
1448 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1449 pointerEvent->SetActionTime(actionTime);
1450 KeyCommandHandler keyCommandHandler;
1451 keyCommandHandler.HandleTouchEvent(pointerEvent);
1452 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1453 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1454 }
1455
1456 /**
1457 * @tc.name: KeyCommandHandlerTest_HandleTouchEventTest_002
1458 * @tc.desc: Test double knuckle CLICK set HandleTouchEvent pointerEvent
1459 * @tc.type: FUNC
1460 * @tc.require:
1461 */
1462 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleTouchEventTest_002, TestSize.Level1)
1463 {
1464 CALL_DEBUG_ENTER;
1465 auto pointerEvent = SetupDoubleKnuckleDownEvent();
1466 ASSERT_TRUE(pointerEvent != nullptr);
1467 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1468 pointerEvent->SetActionTime(actionTime);
1469 KeyCommandHandler keyCommandHandler;
1470 keyCommandHandler.HandleTouchEvent(pointerEvent);
1471 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1472 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1473 }
1474
1475 /**
1476 * @tc.name: KeyCommandHandlerTest_HandleTouchEventTest_003
1477 * @tc.desc: Test signl knuckle double CLICK set HandleTouchEvent pointerEvent
1478 * @tc.type: FUNC
1479 * @tc.require:
1480 */
1481 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleTouchEventTest_003, TestSize.Level1)
1482 {
1483 CALL_DEBUG_ENTER;
1484 auto pointerEvent = SetupSingleKnuckleDownEvent();
1485 ASSERT_TRUE(pointerEvent != nullptr);
1486 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1487 pointerEvent->SetActionTime(actionTime);
1488 KeyCommandHandler keyCommandHandler;
1489 keyCommandHandler.HandleTouchEvent(pointerEvent);
1490 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1491 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1492 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1493 keyCommandHandler.HandleTouchEvent(pointerEvent);
1494 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1495 actionTime = actionTime + INTERVAL_TIME;
1496 pointerEvent->SetActionTime(actionTime);
1497 keyCommandHandler.HandleTouchEvent(pointerEvent);
1498 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1499 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1500 }
1501
1502 /**
1503 * @tc.name: KeyCommandHandlerTest_HandleTouchEventTest_004
1504 * @tc.desc: Test double knuckle double CLICK set HandleTouchEvent pointerEvent
1505 * @tc.type: FUNC
1506 * @tc.require:
1507 */
1508 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleTouchEventTest_004, TestSize.Level1)
1509 {
1510 CALL_DEBUG_ENTER;
1511 auto pointerEvent = SetupDoubleKnuckleDownEvent();
1512 ASSERT_TRUE(pointerEvent != nullptr);
1513 int32_t actionTime = GetNanoTime() / NANOSECOND_TO_MILLISECOND;
1514 pointerEvent->SetActionTime(actionTime);
1515 KeyCommandHandler keyCommandHandler;
1516 keyCommandHandler.HandleTouchEvent(pointerEvent);
1517 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1518 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1519 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1520 keyCommandHandler.HandleTouchEvent(pointerEvent);
1521 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1522 actionTime = actionTime + INTERVAL_TIME;
1523 pointerEvent->SetActionTime(actionTime);
1524 keyCommandHandler.HandleTouchEvent(pointerEvent);
1525 ASSERT_FALSE(keyCommandHandler.GetSingleKnuckleGesture().state);
1526 ASSERT_FALSE(keyCommandHandler.GetDoubleKnuckleGesture().state);
1527 }
1528 #endif // OHOS_BUILD_ENABLE_TOUCH
1529
1530 /**
1531 * @tc.name: KeyCommandHandlerTest_UpdateSettingsXml_001
1532 * @tc.desc: Update settings xml verify
1533 * @tc.type: FUNC
1534 * @tc.require:
1535 */
1536 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_UpdateSettingsXml_001, TestSize.Level1)
1537 {
1538 KeyCommandHandler handler;
1539 ASSERT_EQ(handler.UpdateSettingsXml("", 100), COMMON_PARAMETER_ERROR);
1540 ASSERT_EQ(handler.UpdateSettingsXml("businessId", 100), COMMON_PARAMETER_ERROR);
1541 handler.businessIds_ = {"businessId1", "businessId2"};
1542 ASSERT_EQ(handler.UpdateSettingsXml("businessId3", 100), COMMON_PARAMETER_ERROR);
1543 handler.businessIds_ = {"businessId"};
1544 ASSERT_EQ(handler.UpdateSettingsXml("businessId", 1000), 0);
1545 auto result = PREFERENCES_MGR->SetShortKeyDuration("businessId", 100);
1546 ASSERT_EQ(handler.UpdateSettingsXml("businessId", 100), result);
1547 }
1548
1549 /**
1550 * @tc.name: KeyCommandHandlerTest_AdjustTimeIntervalConfigIfNeed_001
1551 * @tc.desc: Adjust timeInterval configIf need verify
1552 * @tc.type: FUNC
1553 * @tc.require:
1554 */
1555 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AdjustTimeIntervalConfigIfNeed_001, TestSize.Level1)
1556 {
1557 KeyCommandHandler handler;
1558 int64_t DOUBLE_CLICK_INTERVAL_TIME_SLOW = 450000;
1559 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_DEFAULT;
1560 handler.AdjustTimeIntervalConfigIfNeed(DOUBLE_CLICK_INTERVAL_TIME_SLOW);
1561 ASSERT_EQ(handler.downToPrevUpTimeConfig_, DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1562 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_SLOW;
1563 handler.AdjustTimeIntervalConfigIfNeed(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1564 ASSERT_NE(handler.downToPrevUpTimeConfig_, DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1565 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_DEFAULT;
1566 handler.AdjustTimeIntervalConfigIfNeed(DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1567 ASSERT_EQ(handler.downToPrevUpTimeConfig_, DOUBLE_CLICK_INTERVAL_TIME_DEFAULT);
1568 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_SLOW;
1569 handler.AdjustTimeIntervalConfigIfNeed(DOUBLE_CLICK_INTERVAL_TIME_SLOW);
1570 ASSERT_EQ(handler.downToPrevUpTimeConfig_, DOUBLE_CLICK_INTERVAL_TIME_SLOW);
1571 }
1572
1573 /**
1574 * @tc.name: KeyCommandHandlerTest_AdjustDistanceConfigIfNeed_001
1575 * @tc.desc: Adjust distance configIf need verify
1576 * @tc.type: FUNC
1577 * @tc.require:
1578 */
1579 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AdjustDistanceConfigIfNeed_001, TestSize.Level1)
1580 {
1581 KeyCommandHandler handler;
1582 handler.downToPrevDownDistanceConfig_ = handler.distanceDefaultConfig_;
1583 handler.AdjustDistanceConfigIfNeed(handler.distanceDefaultConfig_);
1584 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceDefaultConfig_);
1585 handler.AdjustDistanceConfigIfNeed(handler.distanceLongConfig_);
1586 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceDefaultConfig_);
1587 handler.downToPrevDownDistanceConfig_ = handler.distanceLongConfig_;
1588 handler.AdjustDistanceConfigIfNeed(handler.distanceDefaultConfig_);
1589 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceDefaultConfig_);
1590 handler.AdjustDistanceConfigIfNeed(handler.distanceLongConfig_);
1591 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceLongConfig_);
1592 handler.downToPrevDownDistanceConfig_ = handler.distanceDefaultConfig_;
1593 handler.AdjustDistanceConfigIfNeed(handler.distanceDefaultConfig_ - 1);
1594 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceLongConfig_);
1595 handler.downToPrevDownDistanceConfig_ = handler.distanceLongConfig_;
1596 handler.AdjustDistanceConfigIfNeed(handler.distanceDefaultConfig_ - 1);
1597 ASSERT_EQ(handler.downToPrevDownDistanceConfig_, handler.distanceDefaultConfig_);
1598 }
1599
1600 /**
1601 * @tc.name: KeyCommandHandlerTest_StartTwoFingerGesture_001
1602 * @tc.desc: Start two finger gesture verify
1603 * @tc.type: FUNC
1604 * @tc.require:
1605 */
1606 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_StartTwoFingerGesture_001, TestSize.Level1)
1607 {
1608 KeyCommandHandler handler;
1609 handler.twoFingerGesture_.abilityStartDelay = 1000;
1610 handler.StartTwoFingerGesture();
1611 ASSERT_NE(-1, handler.twoFingerGesture_.timerId);
1612 }
1613
1614 /**
1615 * @tc.name: KeyCommandHandlerTest_SkipFinalKey
1616 * @tc.desc: Skip Final Key
1617 * @tc.type: FUNC
1618 * @tc.require:
1619 */
1620 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SkipFinalKey, TestSize.Level1)
1621 {
1622 CALL_TEST_DEBUG;
1623 KeyCommandHandler handler;
1624 int32_t keyCode = 1024;
1625 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1626 ASSERT_NE(keyEvent, nullptr);
1627 ASSERT_FALSE(handler.SkipFinalKey(keyCode, keyEvent));
1628 }
1629
1630 /**
1631 * @tc.name: KeyCommandHandlerTest_HandleKeyDown_01
1632 * @tc.desc: Handle Key Down
1633 * @tc.type: FUNC
1634 * @tc.require:
1635 */
1636 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyDown_01, TestSize.Level1)
1637 {
1638 CALL_TEST_DEBUG;
1639 KeyCommandHandler handler;
1640 ShortcutKey shortcutKey;
1641 shortcutKey.keyDownDuration = 0;
1642 ASSERT_TRUE(handler.HandleKeyDown(shortcutKey));
1643 }
1644
1645 /**
1646 * @tc.name: KeyCommandHandlerTest_HandleKeyDown_02
1647 * @tc.desc: test HandleKeyDown
1648 * @tc.type: FUNC
1649 * @tc.require:
1650 */
1651 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyDown_02, TestSize.Level1)
1652 {
1653 CALL_TEST_DEBUG;
1654 KeyCommandHandler handler;
1655 ShortcutKey shortcutKey;
1656 shortcutKey.timerId = -1;
1657 ASSERT_TRUE(handler.HandleKeyDown(shortcutKey));
1658 }
1659
1660 /**
1661 * @tc.name: KeyCommandHandlerTest_GetKeyDownDurationFromXml
1662 * @tc.desc: GetKeyDownDurationFromXml
1663 * @tc.type: FUNC
1664 * @tc.require:
1665 */
1666 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_GetKeyDownDurationFromXml, TestSize.Level1)
1667 {
1668 CALL_TEST_DEBUG;
1669 KeyCommandHandler handler;
1670 std::string businessId = "power";
1671 int32_t ret = handler.GetKeyDownDurationFromXml(businessId);
1672 ASSERT_EQ(ret, ERROR_DELAY_VALUE);
1673 }
1674
1675 /**
1676 * @tc.name: KeyCommandHandlerTest_HandleKeyUp_001
1677 * @tc.desc: HandleKeyUp
1678 * @tc.type: FUNC
1679 * @tc.require:
1680 */
1681 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyUp_001, TestSize.Level1)
1682 {
1683 CALL_TEST_DEBUG;
1684 KeyCommandHandler handler;
1685 ShortcutKey shortcutKey;
1686 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1687 ASSERT_NE(keyEvent, nullptr);
1688 shortcutKey.keyDownDuration = 0;
1689 ASSERT_TRUE(handler.HandleKeyUp(keyEvent, shortcutKey));
1690 }
1691
1692 /**
1693 * @tc.name: KeyCommandHandlerTest_HandleKeyUp_002
1694 * @tc.desc: HandleKeyUp
1695 * @tc.type: FUNC
1696 * @tc.require:
1697 */
1698 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyUp_002, TestSize.Level1)
1699 {
1700 CALL_TEST_DEBUG;
1701 KeyCommandHandler handler;
1702 ShortcutKey shortcutKey;
1703 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1704 ASSERT_NE(keyEvent, nullptr);
1705 shortcutKey.keyDownDuration = 1;
1706 ASSERT_FALSE(handler.HandleKeyUp(keyEvent, shortcutKey));
1707 }
1708
1709 /**
1710 * @tc.name: KeyCommandHandlerTest_HandleKeyUp_003
1711 * @tc.desc: HandleKeyUp
1712 * @tc.type: FUNC
1713 * @tc.require:
1714 */
1715 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyUp_003, TestSize.Level1)
1716 {
1717 CALL_TEST_DEBUG;
1718 KeyCommandHandler handler;
1719 ShortcutKey shortcutKey;
1720 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1721 KeyEvent::KeyItem item;
1722 ASSERT_NE(keyEvent, nullptr);
1723 shortcutKey.keyDownDuration = 1;
1724 item.SetKeyCode(KeyEvent::KEYCODE_H);
1725 keyEvent->AddKeyItem(item);
1726 keyEvent->SetKeyCode(KeyEvent::KEYCODE_H);
1727 keyEvent->SetActionTime(10000);
1728 ASSERT_TRUE(handler.HandleKeyUp(keyEvent, shortcutKey));
1729 }
1730
1731 /**
1732 * @tc.name: KeyCommandHandlerTest_HandleKeyUp_004
1733 * @tc.desc: HandleKeyUp
1734 * @tc.type: FUNC
1735 * @tc.require:
1736 */
1737 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyUp_004, TestSize.Level1)
1738 {
1739 CALL_TEST_DEBUG;
1740 KeyCommandHandler handler;
1741 ShortcutKey shortcutKey;
1742 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
1743 KeyEvent::KeyItem item;
1744 ASSERT_NE(keyEvent, nullptr);
1745 shortcutKey.keyDownDuration = 10;
1746 item.SetKeyCode(KeyEvent::KEYCODE_H);
1747 keyEvent->AddKeyItem(item);
1748 keyEvent->SetKeyCode(KeyEvent::KEYCODE_H);
1749 keyEvent->SetActionTime(100);
1750 ASSERT_FALSE(handler.HandleKeyUp(keyEvent, shortcutKey));
1751 }
1752
1753 /**
1754 * @tc.name: KeyCommandHandlerTest_HandleKeyCancel
1755 * @tc.desc: HandleKeyCancel
1756 * @tc.type: FUNC
1757 * @tc.require:
1758 */
1759 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyCancel, TestSize.Level1)
1760 {
1761 CALL_TEST_DEBUG;
1762 KeyCommandHandler handler;
1763 ShortcutKey shortcutKey;
1764 shortcutKey.timerId = -1;
1765 ASSERT_FALSE(handler.HandleKeyCancel(shortcutKey));
1766 shortcutKey.timerId = 10;
1767 ASSERT_FALSE(handler.HandleKeyCancel(shortcutKey));
1768 }
1769
1770 /**
1771 * @tc.name: KeyCommandHandlerTest_LaunchAbility_001
1772 * @tc.desc: LaunchAbility
1773 * @tc.type: FUNC
1774 * @tc.require:
1775 */
1776 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_LaunchAbility_001, TestSize.Level1)
1777 {
1778 CALL_TEST_DEBUG;
1779 KeyCommandHandler handler;
1780 Ability ability;
1781 ability.abilityType = EXTENSION_ABILITY;
1782 ASSERT_NO_FATAL_FAILURE(handler.LaunchAbility(ability));
1783 ability.abilityType = EXTENSION_ABILITY_ABNORMAL;
1784 ASSERT_NO_FATAL_FAILURE(handler.LaunchAbility(ability));
1785 }
1786
1787 /**
1788 * @tc.name: KeyCommandHandlerTest_LaunchAbility_002
1789 * @tc.desc: LaunchAbility
1790 * @tc.type: FUNC
1791 * @tc.require:
1792 */
1793 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_LaunchAbility_002, TestSize.Level1)
1794 {
1795 CALL_TEST_DEBUG;
1796 KeyCommandHandler handler;
1797 ShortcutKey shortcutKey;
1798 ASSERT_NO_FATAL_FAILURE(handler.LaunchAbility(shortcutKey));
1799 }
1800
1801 /**
1802 * @tc.name: KeyCommandHandlerTest_LaunchAbility_003
1803 * @tc.desc: LaunchAbility
1804 * @tc.type: FUNC
1805 * @tc.require:
1806 */
1807 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_LaunchAbility_003, TestSize.Level1)
1808 {
1809 CALL_TEST_DEBUG;
1810 KeyCommandHandler handler;
1811 Sequence sequence;
1812 ASSERT_NO_FATAL_FAILURE(handler.LaunchAbility(sequence));
1813 }
1814
1815 /**
1816 * @tc.name: KeyCommandHandlerTest_LaunchAbility_004
1817 * @tc.desc: LaunchAbility
1818 * @tc.type: FUNC
1819 * @tc.require:
1820 */
1821 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_LaunchAbility_004, TestSize.Level1)
1822 {
1823 CALL_TEST_DEBUG;
1824 KeyCommandHandler handler;
1825 Ability ability;
1826 int64_t delay = 100;
1827 ability.deviceId = "deviceId";
1828 ability.bundleName = "bundleName";
1829 ability.abilityName = "abilityName";
1830 ability.uri = "abilityUri";
1831 ability.type = "type";
1832 ability.action = "abilityAction";
1833 ability.entities.push_back("entities");
1834 ability.params.insert(std::make_pair("paramsFirst", "paramsSecond"));
1835 ASSERT_NO_FATAL_FAILURE(handler.LaunchAbility(ability, delay));
1836 }
1837
1838 /**
1839 * @tc.name: KeyCommandHandlerTest_KeyCommandHandlerPrint
1840 * @tc.desc: Print
1841 * @tc.type: FUNC
1842 * @tc.require:
1843 */
1844 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_KeyCommandHandlerPrint, TestSize.Level1)
1845 {
1846 CALL_TEST_DEBUG;
1847 KeyCommandHandler handler;
1848 ShortcutKey shortcutKey;
1849 Ability ability_temp;
1850 std::string copyShortcutKey = "copyShortcutKey";
1851 shortcutKey.preKeys.insert(2072);
1852 shortcutKey.finalKey = 2019;
1853 shortcutKey.keyDownDuration = 100;
1854 ability_temp.bundleName = "bundleName";
1855 ability_temp.abilityName = "abilityName";
1856 shortcutKey.ability = ability_temp;
1857 handler.shortcutKeys_.insert(std::make_pair(copyShortcutKey, shortcutKey));
1858 ASSERT_NO_FATAL_FAILURE(handler.Print());
1859 }
1860
1861 /**
1862 * @tc.name: KeyCommandHandlerTest_shortcutKeyPrint
1863 * @tc.desc: Print
1864 * @tc.type: FUNC
1865 * @tc.require:
1866 */
1867 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_shortcutKeyPrint, TestSize.Level1)
1868 {
1869 CALL_TEST_DEBUG;
1870 ShortcutKey shortcutKey;
1871 Ability ability_temp;
1872 shortcutKey.preKeys.insert(2072);
1873 shortcutKey.finalKey = 2019;
1874 ability_temp.bundleName = "bundleName";
1875 shortcutKey.ability = ability_temp;
1876 ASSERT_NO_FATAL_FAILURE(shortcutKey.Print());
1877 }
1878
1879 /**
1880 * @tc.name: KeyCommandHandlerTest_RemoveSubscribedTimer
1881 * @tc.desc: RemoveSubscribedTimer
1882 * @tc.type: FUNC
1883 * @tc.require:
1884 */
1885 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_RemoveSubscribedTimer, TestSize.Level1)
1886 {
1887 CALL_TEST_DEBUG;
1888 KeyCommandHandler handler;
1889 int32_t keyCode = 16;
1890 std::list<int32_t> timerIds;
1891 timerIds.push_back(100);
1892 handler.specialTimers_.insert(std::make_pair(keyCode, timerIds));
1893 ASSERT_NO_FATAL_FAILURE(handler.RemoveSubscribedTimer(keyCode));
1894 keyCode = 17;
1895 ASSERT_NO_FATAL_FAILURE(handler.RemoveSubscribedTimer(keyCode));
1896 }
1897
1898 /**
1899 * @tc.name: KeyCommandHandlerTest_HandleSpecialKeys
1900 * @tc.desc: HandleSpecialKeys
1901 * @tc.type: FUNC
1902 * @tc.require:
1903 */
1904 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSpecialKeys, TestSize.Level1)
1905 {
1906 CALL_TEST_DEBUG;
1907 KeyCommandHandler handler;
1908 int32_t keyCodeVolumeUp = 16;
1909 int32_t keyCodeVolumeDown = 17;
1910 int32_t keyAction = KeyEvent::KEY_ACTION_UP;
1911 handler.specialKeys_.insert(std::make_pair(keyCodeVolumeUp, keyAction));
1912 ASSERT_NO_FATAL_FAILURE(handler.HandleSpecialKeys(keyCodeVolumeUp, keyAction));
1913 handler.specialKeys_.clear();
1914
1915 keyAction = KeyEvent::KEY_ACTION_DOWN;
1916 ASSERT_NO_FATAL_FAILURE(handler.HandleSpecialKeys(keyCodeVolumeDown, keyAction));
1917 }
1918
1919 /**
1920 * @tc.name: KeyCommandHandlerTest_HandleSpecialKeys_001
1921 * @tc.desc: Overrides the HandleSpecialKeys function exception branch
1922 * @tc.type: FUNC
1923 * @tc.require:
1924 */
1925 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSpecialKeys_001, TestSize.Level1)
1926 {
1927 CALL_DEBUG_ENTER;
1928 KeyCommandHandler handler;
1929 int32_t powerKeyCode = 18;
1930 int32_t keyCode = 2017;
1931 int32_t keyAction = KeyEvent::KEY_ACTION_UP;
1932 handler.specialKeys_.insert(std::make_pair(powerKeyCode, keyAction));
1933 ASSERT_NO_FATAL_FAILURE(handler.HandleSpecialKeys(keyCode, keyAction));
1934
1935 keyAction = KeyEvent::KEY_ACTION_DOWN;
1936 ASSERT_NO_FATAL_FAILURE(handler.HandleSpecialKeys(powerKeyCode, keyAction));
1937 }
1938
1939 /**
1940 * @tc.name: KeyCommandHandlerTest_InterruptTimers
1941 * @tc.desc: InterruptTimers
1942 * @tc.type: FUNC
1943 * @tc.require:
1944 */
1945 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_InterruptTimers, TestSize.Level1)
1946 {
1947 CALL_TEST_DEBUG;
1948 KeyCommandHandler handler;
1949 Sequence sequence;
1950 sequence.timerId = 1;
1951 handler.filterSequences_.push_back(sequence);
1952 ASSERT_NO_FATAL_FAILURE(handler.InterruptTimers());
1953
1954 handler.filterSequences_.clear();
1955 sequence.timerId = -1;
1956 handler.filterSequences_.push_back(sequence);
1957 ASSERT_NO_FATAL_FAILURE(handler.InterruptTimers());
1958 }
1959
1960 /**
1961 * @tc.name: KeyCommandHandlerTest_SetKnuckleDoubleTapIntervalTime
1962 * @tc.desc: SetKnuckleDoubleTapIntervalTime
1963 * @tc.type: FUNC
1964 * @tc.require:
1965 */
1966 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SetKnuckleDoubleTapIntervalTime, TestSize.Level1)
1967 {
1968 CALL_TEST_DEBUG;
1969 KeyCommandHandler handler;
1970 int64_t interval = -1;
1971 ASSERT_NO_FATAL_FAILURE(handler.SetKnuckleDoubleTapIntervalTime(interval));
1972 }
1973
1974 /**
1975 * @tc.name: KeyCommandHandlerTest_SetKnuckleDoubleTapDistance
1976 * @tc.desc: SetKnuckleDoubleTapDistance
1977 * @tc.type: FUNC
1978 * @tc.require:
1979 */
1980 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SetKnuckleDoubleTapDistance, TestSize.Level1)
1981 {
1982 CALL_TEST_DEBUG;
1983 KeyCommandHandler handler;
1984 float distance = -1.0f;
1985 ASSERT_NO_FATAL_FAILURE(handler.SetKnuckleDoubleTapDistance(distance));
1986 }
1987
1988 /**
1989 * @tc.name: KeyCommandHandlerTest_HandleMulFingersTap
1990 * @tc.desc: Overrides the HandleMulFingersTap function exception branch
1991 * @tc.type: FUNC
1992 * @tc.require:
1993 */
1994 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMulFingersTap, TestSize.Level1)
1995 {
1996 CALL_DEBUG_ENTER;
1997 KeyCommandHandler handler;
1998 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1999 ASSERT_NE(pointerEvent, nullptr);
2000 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_QUADTAP);
2001 ASSERT_FALSE(handler.HandleMulFingersTap(pointerEvent));
2002 }
2003
2004 /**
2005 * @tc.name: KeyCommandHandlerTest_IsKeyMatch
2006 * @tc.desc: IsKeyMatch
2007 * @tc.type: FUNC
2008 * @tc.require:
2009 */
2010 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsKeyMatch, TestSize.Level1)
2011 {
2012 CALL_TEST_DEBUG;
2013 KeyCommandHandler handler;
2014 ShortcutKey shortcutKey;
2015 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2016 ASSERT_NE(keyEvent, nullptr);
2017 KeyEvent::KeyItem item;
2018 shortcutKey.finalKey = 2019;
2019 shortcutKey.preKeys.insert(2072);
2020 shortcutKey.triggerType = KeyEvent::KEY_ACTION_DOWN;
2021 item.SetKeyCode(KeyEvent::KEYCODE_C);
2022 keyEvent->AddKeyItem(item);
2023 keyEvent->SetKeyCode(KeyEvent::KEYCODE_C);
2024 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
2025 ASSERT_FALSE(handler.IsKeyMatch(shortcutKey, keyEvent));
2026
2027 shortcutKey.preKeys.insert(2047);
2028 item.SetKeyCode(KeyEvent::KEYCODE_B);
2029 keyEvent->AddKeyItem(item);
2030 item.SetKeyCode(KeyEvent::KEYCODE_E);
2031 keyEvent->AddKeyItem(item);
2032 ASSERT_FALSE(handler.IsKeyMatch(shortcutKey, keyEvent));
2033 }
2034
2035 /**
2036 * @tc.name: KeyCommandHandlerTest_HandleSequence
2037 * @tc.desc: HandleSequence
2038 * @tc.type: FUNC
2039 * @tc.require:
2040 */
2041 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequence, TestSize.Level1)
2042 {
2043 CALL_TEST_DEBUG;
2044 KeyCommandHandler handler;
2045 Sequence sequence;
2046 SequenceKey sequenceKey;
2047 bool isLaunchAbility = false;
2048 sequence.statusConfigValue = false;
2049 ASSERT_FALSE(handler.HandleSequence(sequence, isLaunchAbility));
2050
2051 sequence.statusConfigValue = true;
2052 sequenceKey.keyCode = 2017;
2053 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
2054 handler.keys_.push_back(sequenceKey);
2055 sequenceKey.keyCode = 2018;
2056 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
2057 handler.keys_.push_back(sequenceKey);
2058
2059 sequenceKey.keyCode = 2019;
2060 sequenceKey.keyAction = KeyEvent::KEY_ACTION_UP;
2061 sequence.sequenceKeys.push_back(sequenceKey);
2062 ASSERT_FALSE(handler.HandleSequence(sequence, isLaunchAbility));
2063
2064 sequenceKey.keyCode = 2017;
2065 sequenceKey.keyAction = KeyEvent::KEY_ACTION_UP;
2066 sequence.sequenceKeys.push_back(sequenceKey);
2067 ASSERT_FALSE(handler.HandleSequence(sequence, isLaunchAbility));
2068 }
2069
2070 /**
2071 * @tc.name: KeyCommandHandlerTest_IsRepeatKeyEvent
2072 * @tc.desc: IsRepeatKeyEvent
2073 * @tc.type: FUNC
2074 * @tc.require:
2075 */
2076 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsRepeatKeyEvent, TestSize.Level1)
2077 {
2078 CALL_TEST_DEBUG;
2079 KeyCommandHandler handler;
2080 SequenceKey sequenceKey;
2081 sequenceKey.keyCode = 2018;
2082 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
2083 handler.keys_.push_back(sequenceKey);
2084
2085 sequenceKey.keyCode = 2018;
2086 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
2087 ASSERT_TRUE(handler.IsRepeatKeyEvent(sequenceKey));
2088
2089 sequenceKey.keyAction = KeyEvent::KEY_ACTION_UP;
2090 ASSERT_FALSE(handler.IsRepeatKeyEvent(sequenceKey));
2091
2092 handler.keys_.clear();
2093 sequenceKey.keyCode = 2019;
2094 handler.keys_.push_back(sequenceKey);
2095 sequenceKey.keyCode = 2020;
2096 ASSERT_FALSE(handler.IsRepeatKeyEvent(sequenceKey));
2097 }
2098
2099 /**
2100 * @tc.name: KeyCommandHandlerTest_HandleSequences
2101 * @tc.desc: HandleSequences
2102 * @tc.type: FUNC
2103 * @tc.require:
2104 */
2105 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequences, TestSize.Level1)
2106 {
2107 CALL_TEST_DEBUG;
2108 KeyCommandHandler handler;
2109 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2110 ASSERT_NE(keyEvent, nullptr);
2111 handler.matchedSequence_.timerId = 10;
2112 ASSERT_FALSE(handler.HandleSequences(keyEvent));
2113 handler.matchedSequence_.timerId = -1;
2114 ASSERT_FALSE(handler.HandleSequences(keyEvent));
2115
2116 keyEvent->SetKeyCode(2017);
2117 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
2118 keyEvent->SetActionTime(10000);
2119 SequenceKey sequenceKey;
2120 Sequence sequence;
2121 handler.sequences_.push_back(sequence);
2122 sequenceKey.actionTime = 15000;
2123 handler.keys_.push_back(sequenceKey);
2124 ASSERT_FALSE(handler.HandleSequences(keyEvent));
2125
2126 handler.keys_.clear();
2127 keyEvent->SetActionTime(1500000);
2128 sequenceKey.actionTime = 200000;
2129 sequence.statusConfigValue = false;
2130 handler.filterSequences_.push_back(sequence);
2131 ASSERT_FALSE(handler.HandleSequences(keyEvent));
2132 }
2133
2134 /**
2135 * @tc.name: KeyCommandHandlerTest_HandleRepeatKeyCount
2136 * @tc.desc: HandleRepeatKeyCount
2137 * @tc.type: FUNC
2138 * @tc.require:
2139 */
2140 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleRepeatKeyCount, TestSize.Level1)
2141 {
2142 CALL_TEST_DEBUG;
2143 KeyCommandHandler handler;
2144 RepeatKey repeatKey;
2145 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2146 ASSERT_NE(keyEvent, nullptr);
2147 repeatKey.keyCode = 2017;
2148 keyEvent->SetKeyCode(2017);
2149 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
2150 keyEvent->SetActionTime(20);
2151 handler.repeatKey_.keyCode = 2018;
2152 ASSERT_TRUE(handler.HandleRepeatKeyCount(repeatKey, keyEvent));
2153
2154 handler.repeatKey_.keyCode = 2017;
2155 ASSERT_TRUE(handler.HandleRepeatKeyCount(repeatKey, keyEvent));
2156
2157 handler.intervalTime_ = 100;
2158 keyEvent->SetActionTime(50);
2159 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
2160 ASSERT_TRUE(handler.HandleRepeatKeyCount(repeatKey, keyEvent));
2161
2162 keyEvent->SetKeyCode(2018);
2163 ASSERT_FALSE(handler.HandleRepeatKeyCount(repeatKey, keyEvent));
2164 }
2165
2166 /**
2167 * @tc.name: KeyCommandHandlerTest_HandleKeyUpCancel
2168 * @tc.desc: HandleKeyUpCancel
2169 * @tc.type: FUNC
2170 * @tc.require:
2171 */
2172 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyUpCancel, TestSize.Level1)
2173 {
2174 CALL_TEST_DEBUG;
2175 KeyCommandHandler handler;
2176 RepeatKey repeatKey;
2177 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2178 ASSERT_NE(keyEvent, nullptr);
2179 repeatKey.keyCode = KeyEvent::KEYCODE_VOLUME_DOWN;
2180 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
2181 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
2182 ASSERT_TRUE(handler.HandleKeyUpCancel(repeatKey, keyEvent));
2183 }
2184
2185 /**
2186 * @tc.name: KeyCommandHandlerTest_HandleRepeatKey
2187 * @tc.desc: HandleRepeatKey
2188 * @tc.type: FUNC
2189 * @tc.require:
2190 */
2191 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleRepeatKey, TestSize.Level1)
2192 {
2193 CALL_TEST_DEBUG;
2194 KeyCommandHandler handler;
2195 RepeatKey repeatKey;
2196 bool isLaunched = false;
2197 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2198 ASSERT_NE(keyEvent, nullptr);
2199 handler.count_ = 2;
2200 repeatKey.times = 2;
2201 repeatKey.statusConfig = true;
2202 repeatKey.keyCode = KeyEvent::KEYCODE_VOLUME_DOWN;
2203 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
2204 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
2205 ASSERT_FALSE(handler.HandleRepeatKey(repeatKey, isLaunched, keyEvent));
2206 }
2207
2208 /**
2209 * @tc.name: KeyCommandHandlerTest_CreateKeyEvent
2210 * @tc.desc: CreateKeyEvent
2211 * @tc.type: FUNC
2212 * @tc.require:
2213 */
2214 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CreateKeyEvent, TestSize.Level1)
2215 {
2216 CALL_TEST_DEBUG;
2217 KeyCommandHandler handler;
2218 int32_t keyCode = 2017;
2219 int32_t keyAction = KeyEvent::KEY_ACTION_DOWN;
2220 bool isPressed = true;
2221 ASSERT_NE(handler.CreateKeyEvent(keyCode, keyAction, isPressed), nullptr);
2222 }
2223
2224 /**
2225 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey
2226 * @tc.desc: Test IsEnableCombineKey
2227 * @tc.type: FUNC
2228 * @tc.require:
2229 */
2230 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey, TestSize.Level1)
2231 {
2232 CALL_TEST_DEBUG;
2233 KeyCommandHandler handler;
2234 KeyEvent::KeyItem item;
2235 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
2236 ASSERT_NE(key, nullptr);
2237 handler.enableCombineKey_ = false;
2238 item.SetKeyCode(KeyEvent::KEYCODE_A);
2239 key->SetKeyCode(KeyEvent::KEYCODE_POWER);
2240 key->SetKeyAction(KeyEvent::KEY_ACTION_UP);
2241 key->AddKeyItem(item);
2242 ASSERT_FALSE(handler.IsEnableCombineKey(key));
2243 item.SetKeyCode(KeyEvent::KEYCODE_B);
2244 key->AddKeyItem(item);
2245 ASSERT_FALSE(handler.IsEnableCombineKey(key));
2246 key->SetKeyCode(KeyEvent::KEYCODE_L);
2247 ASSERT_FALSE(handler.IsEnableCombineKey(key));
2248 }
2249
2250 /**
2251 * @tc.name: KeyCommandHandlerTest_AdjustTimeIntervalConfigIfNeed
2252 * @tc.desc: Test AdjustTimeIntervalConfigIfNeed
2253 * @tc.type: FUNC
2254 * @tc.require:
2255 */
2256 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AdjustTimeIntervalConfigIfNeed, TestSize.Level1)
2257 {
2258 CALL_TEST_DEBUG;
2259 KeyCommandHandler handler;
2260 int64_t intervalTime = 300000;
2261 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_DEFAULT;
2262 handler.checkAdjustIntervalTimeCount_ = 0;
2263 ASSERT_NO_FATAL_FAILURE(handler.AdjustTimeIntervalConfigIfNeed(intervalTime));
2264
2265 handler.downToPrevUpTimeConfig_ = DOUBLE_CLICK_INTERVAL_TIME_SLOW;
2266 ASSERT_NO_FATAL_FAILURE(handler.AdjustTimeIntervalConfigIfNeed(intervalTime));
2267
2268 intervalTime = 10000;
2269 handler.checkAdjustIntervalTimeCount_ = 6;
2270 ASSERT_NO_FATAL_FAILURE(handler.AdjustTimeIntervalConfigIfNeed(intervalTime));
2271
2272 handler.downToPrevUpTimeConfig_ = 100000;
2273 ASSERT_NO_FATAL_FAILURE(handler.AdjustTimeIntervalConfigIfNeed(intervalTime));
2274 }
2275
2276 /**
2277 * @tc.name: KeyCommandHandlerTest_AdjustDistanceConfigIfNeed
2278 * @tc.desc: Test AdjustDistanceConfigIfNeed
2279 * @tc.type: FUNC
2280 * @tc.require:
2281 */
2282 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AdjustDistanceConfigIfNeed, TestSize.Level1)
2283 {
2284 CALL_TEST_DEBUG;
2285 KeyCommandHandler handler;
2286 float distance = 5.0f;
2287 handler.downToPrevDownDistanceConfig_ = 10.0f;
2288 handler.distanceDefaultConfig_ = 10.0f;
2289 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2290
2291 distance = 20.0f;
2292 handler.distanceLongConfig_ = 15.0f;
2293 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2294
2295 distance = 12.0f;
2296 handler.checkAdjustDistanceCount_ = 6;
2297 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2298
2299 handler.downToPrevDownDistanceConfig_ = 15.0f;
2300 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2301
2302 distance = 5.0f;
2303 handler.checkAdjustDistanceCount_ = 0;
2304 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2305
2306 handler.downToPrevDownDistanceConfig_ = 11.5f;
2307 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2308 }
2309
2310 /**
2311 * @tc.name: KeyCommandHandlerTest_AdjustDistanceConfigIfNeed_002
2312 * @tc.desc: Test AdjustDistanceConfigIfNeed
2313 * @tc.type: FUNC
2314 * @tc.require:
2315 */
2316 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AdjustDistanceConfigIfNeed_002, TestSize.Level1)
2317 {
2318 CALL_TEST_DEBUG;
2319 KeyCommandHandler handler;
2320 float distance = 15.0f;
2321 handler.downToPrevDownDistanceConfig_ = 10.0f;
2322 handler.distanceLongConfig_ = 10.0f;
2323 handler.distanceDefaultConfig_ = 5.0f;
2324 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2325 handler.distanceDefaultConfig_ = 20.0f;
2326 handler.checkAdjustDistanceCount_ = 6;
2327 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2328 handler.downToPrevDownDistanceConfig_ = 30.0f;
2329 ASSERT_NO_FATAL_FAILURE(handler.AdjustDistanceConfigIfNeed(distance));
2330 }
2331
2332 #ifdef OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
2333 /**
2334 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchDown_001
2335 * @tc.desc: Test knuckle gesture touch down event
2336 * @tc.type: FUNC
2337 * @tc.require:
2338 */
2339 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchDown_001, TestSize.Level1)
2340 {
2341 CALL_TEST_DEBUG;
2342 KeyCommandHandler handler;
2343 PointerEvent::PointerItem item;
2344 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2345 ASSERT_NE(touchEvent, nullptr);
2346
2347 item.SetPointerId(1);
2348 item.SetRawDisplayX(4);
2349 item.SetRawDisplayY(4);
2350 touchEvent->SetPointerId(1);
2351 touchEvent->SetActionTime(1);
2352 touchEvent->AddPointerItem(item);
2353 KeyCommandHandler keyCommandHandler;
2354 keyCommandHandler.HandleKnuckleGestureTouchDown(touchEvent);
2355
2356 ASSERT_TRUE(handler.gestureTimeStamps_.empty());
2357 }
2358
2359 /**
2360 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchMove_001
2361 * @tc.desc: Test knuckle gesture touch move event
2362 * @tc.type: FUNC
2363 * @tc.require:
2364 */
2365 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchMove_001, TestSize.Level1)
2366 {
2367 CALL_TEST_DEBUG;
2368 KeyCommandHandler handler;
2369 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2370 ASSERT_NE(touchEvent, nullptr);
2371
2372 handler.gestureLastX_ = 4.0;
2373 handler.gestureLastY_ = 4.0;
2374
2375 PointerEvent::PointerItem item1;
2376 item1.SetPointerId(2);
2377 item1.SetRawDisplayX(24);
2378 item1.SetRawDisplayY(24);
2379 touchEvent->AddPointerItem(item1);
2380 touchEvent->SetActionTime(6);
2381 touchEvent->SetPointerId(2);
2382
2383 handler.HandleKnuckleGestureTouchMove(touchEvent);
2384 ASSERT_FALSE(handler.isLetterGesturing_);
2385 }
2386
2387 /**
2388 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_001
2389 * @tc.desc: Test knuckle gesture touch up event partial screenshot
2390 * @tc.type: FUNC
2391 * @tc.require:
2392 */
2393 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_001, TestSize.Level1)
2394 {
2395 CALL_TEST_DEBUG;
2396 KeyCommandHandler handler;
2397 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2398 ASSERT_NE(touchEvent, nullptr);
2399
2400 handler.gesturePoints_.assign(CIRCLE_COORDINATES.begin(), CIRCLE_COORDINATES.end());
2401 handler.gestureTimeStamps_.assign(CIRCLE_TIMESTAMPS.begin(), CIRCLE_TIMESTAMPS.end());
2402 handler.isGesturing_ = true;
2403 handler.isLetterGesturing_ = true;
2404
2405 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
2406 }
2407
2408 /**
2409 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_002
2410 * @tc.desc: Test knuckle gesture touch up event long screenshot
2411 * @tc.type: FUNC
2412 * @tc.require:
2413 */
2414 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_002, TestSize.Level1)
2415 {
2416 CALL_TEST_DEBUG;
2417 KeyCommandHandler handler;
2418 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2419 ASSERT_NE(touchEvent, nullptr);
2420
2421 handler.gesturePoints_.assign(CURVE_COORDINATES.begin(), CURVE_COORDINATES.end());
2422 handler.gestureTimeStamps_.assign(CURVE_TIMESTAMPS.begin(), CURVE_TIMESTAMPS.end());
2423 handler.isGesturing_ = true;
2424 handler.isLetterGesturing_ = true;
2425
2426 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
2427 }
2428
2429 /**
2430 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_003
2431 * @tc.desc: Test knuckle gesture touch up event straight line
2432 * @tc.type: FUNC
2433 * @tc.require:
2434 */
2435 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_003, TestSize.Level1)
2436 {
2437 CALL_TEST_DEBUG;
2438 KeyCommandHandler handler;
2439 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2440 ASSERT_NE(touchEvent, nullptr);
2441
2442 handler.gesturePoints_.assign(LINE_COORDINATES.begin(), LINE_COORDINATES.end());
2443 handler.gestureTimeStamps_.assign(LINE_TIMESTAMPS.begin(), LINE_TIMESTAMPS.end());
2444 handler.isGesturing_ = true;
2445 handler.isLetterGesturing_ = true;
2446
2447 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
2448 }
2449
2450 /**
2451 * @tc.name: KeyCommandHandlerTest_ResetKnuckleGesture_001
2452 * @tc.desc: Test ResetKnuckleGesture function
2453 * @tc.type: FUNC
2454 * @tc.require:
2455 */
2456 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ResetKnuckleGesture_001, TestSize.Level1)
2457 {
2458 CALL_TEST_DEBUG;
2459 KeyCommandHandler handler;
2460 handler.gestureLastX_ = 1.0f;
2461 handler.gestureLastY_ = 1.0f;
2462 handler.isGesturing_ = true;
2463 handler.isDistanceConfig_ = true;
2464 handler.gestureTrackLength_ = 2.0f;
2465 handler.gesturePoints_.assign(CURVE_COORDINATES.begin(), CURVE_COORDINATES.end());
2466 handler.gestureTimeStamps_.assign(CURVE_TIMESTAMPS.begin(), CURVE_TIMESTAMPS.end());
2467
2468 handler.ResetKnuckleGesture();
2469 ASSERT_EQ(handler.gestureLastX_, 0.0f);
2470 ASSERT_EQ(handler.gestureLastY_, 0.0f);
2471 ASSERT_FALSE(handler.isGesturing_);
2472 ASSERT_TRUE(handler.isDistanceConfig_);
2473 ASSERT_EQ(handler.gestureTrackLength_, 0.0f);
2474 ASSERT_TRUE(handler.gesturePoints_.empty());
2475 ASSERT_TRUE(handler.gestureTimeStamps_.empty());
2476 }
2477
2478 /**
2479 * @tc.name: KeyCommandHandlerTest_GesturePointsToStr_001
2480 * @tc.desc: Test GesturePointsToStr function
2481 * @tc.type: FUNC
2482 * @tc.require:
2483 */
2484 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_GesturePointsToStr_001, TestSize.Level1)
2485 {
2486 CALL_TEST_DEBUG;
2487 KeyCommandHandler handler;
2488 handler.gesturePoints_ = { 0.0f, 1.0f, 2.0f, 3.0f };
2489
2490 auto result = handler.GesturePointsToStr();
2491 ASSERT_EQ(result.length(), 50);
2492 ASSERT_EQ(handler.gesturePoints_.size(), 4);
2493 }
2494
2495 /**
2496 * @tc.name: KeyCommandHandlerTest_GesturePointsToStr_002
2497 * @tc.desc: Test GesturePointsToStr function
2498 * @tc.type: FUNC
2499 * @tc.require:
2500 */
2501 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_GesturePointsToStr_002, TestSize.Level1)
2502 {
2503 CALL_TEST_DEBUG;
2504 KeyCommandHandler handler;
2505
2506 auto result = handler.GesturePointsToStr();
2507 ASSERT_TRUE(result.empty());
2508 ASSERT_TRUE(handler.gesturePoints_.empty());
2509 }
2510
2511 /**
2512 * @tc.name: KeyCommandHandlerTest_GesturePointsToStr_003
2513 * @tc.desc: Test GesturePointsToStr function
2514 * @tc.type: FUNC
2515 * @tc.require:
2516 */
2517 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_GesturePointsToStr_003, TestSize.Level1)
2518 {
2519 CALL_TEST_DEBUG;
2520 KeyCommandHandler handler;
2521 handler.gesturePoints_ = { 0.0f };
2522
2523 auto result = handler.GesturePointsToStr();
2524 ASSERT_TRUE(result.empty());
2525 ASSERT_EQ(handler.gesturePoints_.size(), 1);
2526 }
2527
2528 /**
2529 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureEvent_001
2530 * @tc.desc: Test HandleKnuckleGestureEvent function
2531 * @tc.type: FUNC
2532 * @tc.require:
2533 */
2534 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureEvent_001, TestSize.Level1)
2535 {
2536 CALL_TEST_DEBUG;
2537 KeyCommandHandler handler;
2538 PointerEvent::PointerItem item;
2539 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2540 ASSERT_NE(touchEvent, nullptr);
2541 item.SetPointerId(1);
2542 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
2543 touchEvent->AddPointerItem(item);
2544 touchEvent->SetPointerId(1);
2545 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2546 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
2547
2548 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
2549 touchEvent->AddPointerItem(item);
2550 touchEvent->SetPointerId(1);
2551 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2552 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
2553
2554 handler.singleKnuckleGesture_.state = true;
2555 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
2556 }
2557
2558 /**
2559 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureEvent_002
2560 * @tc.desc: Test HandleKnuckleGestureEvent function
2561 * @tc.type: FUNC
2562 * @tc.require:
2563 */
2564 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureEvent_002, TestSize.Level1)
2565 {
2566 CALL_TEST_DEBUG;
2567 KeyCommandHandler handler;
2568 PointerEvent::PointerItem item;
2569 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2570 ASSERT_NE(touchEvent, nullptr);
2571 item.SetPointerId(1);
2572 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
2573 touchEvent->AddPointerItem(item);
2574 touchEvent->SetPointerId(1);
2575 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2576
2577 handler.singleKnuckleGesture_.state = false;
2578 handler.knuckleSwitch_.statusConfigValue = false;
2579 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
2580 }
2581
2582 /**
2583 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureEvent_003
2584 * @tc.desc: Test HandleKnuckleGestureEvent function
2585 * @tc.type: FUNC
2586 * @tc.require:
2587 */
2588 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureEvent_003, TestSize.Level1)
2589 {
2590 CALL_TEST_DEBUG;
2591 KeyCommandHandler handler;
2592 PointerEvent::PointerItem item;
2593 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
2594 ASSERT_NE(touchEvent, nullptr);
2595 item.SetPointerId(1);
2596 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
2597 touchEvent->AddPointerItem(item);
2598 touchEvent->SetPointerId(1);
2599 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
2600
2601 handler.singleKnuckleGesture_.state = false;
2602 handler.knuckleSwitch_.statusConfigValue = true;
2603 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureEvent(touchEvent));
2604 }
2605
2606 /**
2607 * @tc.name: KeyCommandHandlerTest_IsValidAction
2608 * @tc.desc: Test IsValidAction
2609 * @tc.type: FUNC
2610 * @tc.require:
2611 */
2612 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsValidAction, TestSize.Level1)
2613 {
2614 CALL_TEST_DEBUG;
2615 KeyCommandHandler handler;
2616 int32_t action = PointerEvent::POINTER_ACTION_DOWN;
2617 ASSERT_NO_FATAL_FAILURE(handler.IsValidAction(action));
2618
2619 action = PointerEvent::POINTER_ACTION_MOVE;
2620 handler.gesturePoints_ = { 0.0f };
2621 ASSERT_NO_FATAL_FAILURE(handler.IsValidAction(action));
2622
2623 action = PointerEvent::POINTER_ACTION_UP;
2624 handler.gesturePoints_.assign(CIRCLE_COORDINATES.begin(), CIRCLE_COORDINATES.end());
2625 ASSERT_NO_FATAL_FAILURE(handler.IsValidAction(action));
2626 }
2627 #endif // OHOS_BUILD_ENABLE_GESTURESENSE_WRAPPER
2628
2629 /**
2630 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_001
2631 * @tc.desc: Test the funcation HandleShortKeys
2632 * @tc.type: FUNC
2633 * @tc.require:
2634 */
2635 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_001, TestSize.Level1)
2636 {
2637 CALL_TEST_DEBUG;
2638 KeyCommandHandler handler;
2639 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2640 ASSERT_NE(keyEvent, nullptr);
2641 bool ret = handler.HandleShortKeys(keyEvent);
2642 ASSERT_FALSE(ret);
2643 ShortcutKey key;
2644 key.preKeys = {1, 2, 3};
2645 key.businessId = "business1";
2646 key.statusConfig = "config1";
2647 key.statusConfigValue = true;
2648 key.finalKey = 4;
2649 key.keyDownDuration = 5;
2650 key.triggerType = KeyEvent::KEY_ACTION_DOWN;
2651 key.timerId = 6;
2652 Ability ability_temp;
2653 ability_temp.bundleName = "bundleName1";
2654 ability_temp.abilityName = "abilityName1";
2655 key.ability = ability_temp;
2656 handler.shortcutKeys_.insert(std::make_pair("key1", key));
2657 ret = handler.HandleShortKeys(keyEvent);
2658 ASSERT_FALSE(ret);
2659 handler.lastMatchedKey_.timerId = 1;
2660 ret = handler.HandleShortKeys(keyEvent);
2661 ASSERT_FALSE(ret);
2662 handler.lastMatchedKey_.timerId = -1;
2663 ret = handler.HandleShortKeys(keyEvent);
2664 ASSERT_FALSE(ret);
2665 std::string businessId = "power";
2666 ret = handler.HandleShortKeys(keyEvent);
2667 ASSERT_FALSE(ret);
2668 }
2669
2670 /**
2671 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_002
2672 * @tc.desc: Test the funcation HandleShortKeys
2673 * @tc.type: FUNC
2674 * @tc.require:
2675 */
2676 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_002, TestSize.Level1)
2677 {
2678 CALL_TEST_DEBUG;
2679 KeyCommandHandler handler;
2680 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2681 ASSERT_NE(keyEvent, nullptr);
2682 ShortcutKey key;
2683 key.preKeys = {1, 2, 3};
2684 key.businessId = "business2";
2685 key.statusConfig = "config2";
2686 key.statusConfigValue = true;
2687 key.finalKey = 5;
2688 key.keyDownDuration = 6;
2689 key.triggerType = KeyEvent::KEY_ACTION_UP;
2690 key.timerId = 6;
2691 Ability ability_temp;
2692 ability_temp.bundleName = "bundleName2";
2693 ability_temp.abilityName = "abilityName2";
2694 key.ability = ability_temp;
2695 handler.shortcutKeys_.insert(std::make_pair("key2", key));
2696 bool ret = handler.HandleShortKeys(keyEvent);
2697 ASSERT_FALSE(ret);
2698 handler.lastMatchedKey_.timerId = -1;
2699 ret = handler.HandleShortKeys(keyEvent);
2700 ASSERT_FALSE(ret);
2701 std::string businessId = "power";
2702 ret = handler.HandleShortKeys(keyEvent);
2703 ASSERT_FALSE(ret);
2704 }
2705
2706 /**
2707 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_003
2708 * @tc.desc: Test the funcation HandleShortKeys
2709 * @tc.type: FUNC
2710 * @tc.require:
2711 */
2712 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_003, TestSize.Level1)
2713 {
2714 CALL_TEST_DEBUG;
2715 KeyCommandHandler handler;
2716 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2717 ASSERT_NE(keyEvent, nullptr);
2718 ShortcutKey key;
2719 key.preKeys = {1, 2, 3};
2720 key.businessId = "business3";
2721 key.statusConfig = "config3";
2722 key.statusConfigValue = true;
2723 key.finalKey = 7;
2724 key.keyDownDuration = 8;
2725 key.triggerType = KeyEvent::KEY_ACTION_CANCEL;
2726 key.timerId = 6;
2727 Ability ability_temp;
2728 ability_temp.bundleName = "bundleName3";
2729 ability_temp.abilityName = "abilityName3";
2730 key.ability = ability_temp;
2731 handler.shortcutKeys_.insert(std::make_pair("key3", key));
2732 bool ret = handler.HandleShortKeys(keyEvent);
2733 ASSERT_FALSE(ret);
2734 handler.lastMatchedKey_.timerId = -1;
2735 ret = handler.HandleShortKeys(keyEvent);
2736 ASSERT_FALSE(ret);
2737 std::string businessId = "power";
2738 ret = handler.HandleShortKeys(keyEvent);
2739 ASSERT_FALSE(ret);
2740 }
2741
2742 /**
2743 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_04
2744 * @tc.desc: Test the funcation HandleShortKeys
2745 * @tc.type: FUNC
2746 * @tc.require:
2747 */
2748 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_04, TestSize.Level1)
2749 {
2750 CALL_TEST_DEBUG;
2751 KeyCommandHandler handler;
2752 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2753 ASSERT_NE(keyEvent, nullptr);
2754 ShortcutKey key;
2755 key.preKeys = {1, 2, 3};
2756 key.businessId = "business2";
2757 key.statusConfig = "config2";
2758 key.statusConfigValue = true;
2759 key.finalKey = 5;
2760 key.keyDownDuration = 6;
2761 key.triggerType = KeyEvent::KEY_ACTION_UP;
2762 key.timerId = 6;
2763 Ability ability_temp;
2764 ability_temp.bundleName = "bundleName2";
2765 ability_temp.abilityName = "abilityName2";
2766 key.ability = ability_temp;
2767 handler.shortcutKeys_.insert(std::make_pair("key2", key));
2768 bool ret = handler.HandleShortKeys(keyEvent);
2769 EXPECT_FALSE(ret);
2770 handler.lastMatchedKey_.timerId = -1;
2771 ret = handler.HandleShortKeys(keyEvent);
2772 EXPECT_FALSE(ret);
2773
2774 key.businessId = "power";
2775 int32_t delay = handler.GetKeyDownDurationFromXml(key.businessId);
2776 EXPECT_TRUE(delay < 0);
2777 key.triggerType = KeyEvent::KEY_ACTION_DOWN;
2778 ret = handler.HandleShortKeys(keyEvent);
2779 EXPECT_FALSE(ret);
2780
2781 key.triggerType = KeyEvent::KEY_ACTION_UP;
2782 bool handleResult = handler.HandleKeyUp(keyEvent, key);
2783 EXPECT_FALSE(handleResult);
2784 ret = handler.HandleShortKeys(keyEvent);
2785 EXPECT_FALSE(ret);
2786 }
2787
2788 /**
2789 * @tc.name: KeyCommandHandlerTest_AddSequenceKey_001
2790 * @tc.desc: Test the funcation AddSequenceKey
2791 * @tc.type: FUNC
2792 * @tc.require:
2793 */
2794 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AddSequenceKey_001, TestSize.Level1)
2795 {
2796 CALL_TEST_DEBUG;
2797 KeyCommandHandler handler;
2798 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2799 ASSERT_NE(keyEvent, nullptr);
2800 SequenceKey sequenceKey;
2801 sequenceKey.keyCode = 1;
2802 sequenceKey.keyAction = 2;
2803 sequenceKey.actionTime = 3;
2804 sequenceKey.delay = 4;
2805 handler.keys_.push_back(sequenceKey);
2806 bool ret = handler.AddSequenceKey(keyEvent);
2807 ASSERT_TRUE(ret);
2808 }
2809
2810 /**
2811 * @tc.name: KeyCommandHandlerTest_AddSequenceKey_002
2812 * @tc.desc: Test the funcation AddSequenceKey
2813 * @tc.type: FUNC
2814 * @tc.require:
2815 */
2816 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AddSequenceKey_002, TestSize.Level1)
2817 {
2818 CALL_TEST_DEBUG;
2819 KeyCommandHandler handler;
2820 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2821 ASSERT_NE(keyEvent, nullptr);
2822 SequenceKey sequenceKey;
2823 sequenceKey.keyCode = 1;
2824 sequenceKey.keyAction = 2;
2825 sequenceKey.actionTime = 15;
2826 sequenceKey.delay = 16;
2827 handler.keys_.push_back(sequenceKey);
2828 bool ret = handler.AddSequenceKey(keyEvent);
2829 ASSERT_TRUE(ret);
2830 }
2831
2832 /**
2833 * @tc.name: KeyCommandHandlerTest_AddSequenceKey_003
2834 * @tc.desc: Test the funcation AddSequenceKey
2835 * @tc.type: FUNC
2836 * @tc.require:
2837 */
2838 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AddSequenceKey_003, TestSize.Level1)
2839 {
2840 CALL_TEST_DEBUG;
2841 KeyCommandHandler handler;
2842 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2843 ASSERT_NE(keyEvent, nullptr);
2844 SequenceKey sequenceKey;
2845 sequenceKey.keyCode = 1;
2846 sequenceKey.keyAction = 2;
2847 sequenceKey.actionTime = -2;
2848 sequenceKey.delay = -3;
2849 handler.keys_.push_back(sequenceKey);
2850 bool ret = handler.AddSequenceKey(keyEvent);
2851 ASSERT_TRUE(ret);
2852 handler.keys_.clear();
2853 ret = handler.AddSequenceKey(keyEvent);
2854 ASSERT_TRUE(ret);
2855 }
2856
2857 /**
2858 * @tc.name: KeyCommandHandlerTest_HandleNormalSequence_001
2859 * @tc.desc: Test the funcation HandleNormalSequence
2860 * @tc.type: FUNC
2861 * @tc.require:
2862 */
2863 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleNormalSequence_001, TestSize.Level1)
2864 {
2865 CALL_TEST_DEBUG;
2866 KeyCommandHandler handler;
2867 Sequence sequence;
2868 bool isLaunchAbility = true;
2869 sequence.abilityStartDelay = 0;
2870 bool ret = handler.HandleNormalSequence(sequence, isLaunchAbility);
2871 ASSERT_TRUE(ret);
2872 sequence.abilityStartDelay = 1;
2873 sequence.timerId = -1;
2874 ret = handler.HandleNormalSequence(sequence, isLaunchAbility);
2875 ASSERT_TRUE(ret);
2876 sequence.timerId = 1;
2877 ret = handler.HandleNormalSequence(sequence, isLaunchAbility);
2878 ASSERT_TRUE(ret);
2879 }
2880
2881 /**
2882 * @tc.name: KeyCommandHandlerTest_HandleMatchedSequence_001
2883 * @tc.desc: Test the funcation HandleMatchedSequence
2884 * @tc.type: FUNC
2885 * @tc.require:
2886 */
2887 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMatchedSequence_001, TestSize.Level1)
2888 {
2889 CALL_TEST_DEBUG;
2890 KeyCommandHandler handler;
2891 Sequence sequence;
2892 bool isLaunchAbility = true;
2893 sequence.ability.bundleName = ".screenshot";
2894 bool ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
2895 ASSERT_TRUE(ret);
2896 sequence.ability.bundleName = "abc";
2897 DisplayEventMonitor displayEventMonitor;
2898 displayEventMonitor.screenStatus_ = "usual.event.SCREEN_OFF";
2899 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
2900 ASSERT_TRUE(ret);
2901 displayEventMonitor.screenStatus_ = "usual.event.SCREEN_ON";
2902 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
2903 ASSERT_TRUE(ret);
2904 displayEventMonitor.isScreenLocked_ = true;
2905 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
2906 ASSERT_TRUE(ret);
2907 displayEventMonitor.isScreenLocked_ = false;
2908 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
2909 ASSERT_TRUE(ret);
2910 }
2911
2912 /**
2913 * @tc.name: KeyCommandHandlerTest_HandleSequence_001
2914 * @tc.desc: Test the funcation HandleSequence
2915 * @tc.type: FUNC
2916 * @tc.require:
2917 */
2918 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequence_001, TestSize.Level1)
2919 {
2920 CALL_TEST_DEBUG;
2921 KeyCommandHandler handler;
2922 Sequence sequence;
2923 SequenceKey sequenceKey;
2924 bool isLaunchAbility = true;
2925 sequence.statusConfigValue = false;
2926 bool ret = handler.HandleSequence(sequence, isLaunchAbility);
2927 ASSERT_FALSE(ret);
2928 sequence.statusConfigValue = true;
2929 sequenceKey.keyCode = 10;
2930 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
2931 sequenceKey.actionTime = 10;
2932 sequenceKey.delay = 10;
2933 handler.keys_.push_back(sequenceKey);
2934 sequence.sequenceKeys.push_back(sequenceKey);
2935 ret = handler.HandleSequence(sequence, isLaunchAbility);
2936 ASSERT_TRUE(ret);
2937 }
2938
2939 /**
2940 * @tc.name: KeyCommandHandlerTest_ConvertKeyActionToString_001
2941 * @tc.desc: Test the funcation ConvertKeyActionToString
2942 * @tc.type: FUNC
2943 * @tc.require:
2944 */
2945 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ConvertKeyActionToString_001, TestSize.Level1)
2946 {
2947 CALL_TEST_DEBUG;
2948 KeyCommandHandler handler;
2949 int32_t keyAction = 0;
2950 std::string ret = handler.ConvertKeyActionToString(keyAction);
2951 ASSERT_EQ(ret, "UNKNOWN");
2952 keyAction = 1;
2953 ret = handler.ConvertKeyActionToString(keyAction);
2954 ASSERT_EQ(ret, "CANCEL");
2955 keyAction = 2;
2956 ret = handler.ConvertKeyActionToString(keyAction);
2957 ASSERT_EQ(ret, "DOWN");
2958 keyAction = 3;
2959 ret = handler.ConvertKeyActionToString(keyAction);
2960 ASSERT_EQ(ret, "UP");
2961 keyAction = 4;
2962 ret = handler.ConvertKeyActionToString(keyAction);
2963 ASSERT_EQ(ret, "UNKNOWN_ACTION");
2964 }
2965
2966 /**
2967 * @tc.name: KeyCommandHandlerTest_HandleKeyEvent_001
2968 * @tc.desc: Test the funcation HandleKeyEvent
2969 * @tc.type: FUNC
2970 * @tc.require:
2971 */
2972 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKeyEvent_001, TestSize.Level1)
2973 {
2974 CALL_TEST_DEBUG;
2975 KeyCommandHandler handler;
2976 handler.EnableCombineKey(false);
2977 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
2978 ASSERT_NE(keyEvent, nullptr);
2979 KeyEvent::KeyItem item;
2980 item.SetKeyCode(KeyEvent::KEYCODE_POWER);
2981 keyEvent->AddKeyItem(item);
2982 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER);
2983 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
2984 }
2985
2986 /**
2987 * @tc.name: KeyCommandHandlerTest_HandlePointerEvent_001
2988 * @tc.desc: Test the funcation HandlePointerEvent
2989 * @tc.type: FUNC
2990 * @tc.require:
2991 */
2992 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandlePointerEvent_001, TestSize.Level1)
2993 {
2994 CALL_TEST_DEBUG;
2995 KeyCommandHandler handler;
2996 handler.EnableCombineKey(false);
2997 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2998 ASSERT_TRUE(pointerEvent != nullptr);
2999 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3000 ASSERT_NE(keyEvent, nullptr);
3001 KeyEvent::KeyItem item;
3002 item.SetKeyCode(KeyEvent::KEYCODE_POWER);
3003 keyEvent->AddKeyItem(item);
3004 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER);
3005 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
3006 }
3007
3008 /**
3009 * @tc.name: KeyCommandHandlerTest_HandleTouchEventTest_005
3010 * @tc.desc: Test the funcation HandleTouchEvent
3011 * @tc.require:
3012 */
3013 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleTouchEventTest_005, TestSize.Level1)
3014 {
3015 CALL_DEBUG_ENTER;
3016 KeyCommandHandler handler;
3017 std::shared_ptr<PointerEvent> pointerEvent = SetupDoubleKnuckleDownEvent();
3018 ASSERT_TRUE(pointerEvent != nullptr);
3019 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
3020 handler.SetNext(handler.nextHandler_);
3021 PointerEvent::PointerItem item;
3022 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3023 ASSERT_NE(touchEvent, nullptr);
3024 item.SetPointerId(1);
3025 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
3026 touchEvent->AddPointerItem(item);
3027 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
3028 item.SetPointerId(2);
3029 item.SetToolType(PointerEvent::TOOL_TYPE_PALM);
3030 touchEvent->AddPointerItem(item);
3031 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
3032 }
3033
3034 /**
3035 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_001
3036 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
3037 * @tc.type: FUNC
3038 * @tc.require:
3039 */
3040 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_001, TestSize.Level1)
3041 {
3042 CALL_TEST_DEBUG;
3043 KeyCommandHandler handler;
3044 handler.twoFingerGesture_.active = false;
3045 bool ret = handler.CheckTwoFingerGestureAction();
3046 EXPECT_FALSE(ret);
3047 handler.twoFingerGesture_.active = true;
3048 handler.twoFingerGesture_.touches[0].id = 1;
3049 handler.twoFingerGesture_.touches[0].x = 100;
3050 handler.twoFingerGesture_.touches[0].y = 200;
3051 handler.twoFingerGesture_.touches[0].downTime = 250000;
3052 handler.twoFingerGesture_.touches[1].id = 2;
3053 handler.twoFingerGesture_.touches[1].x = 300;
3054 handler.twoFingerGesture_.touches[1].y = 400;
3055 handler.twoFingerGesture_.touches[1].downTime = 50000;
3056 ret = handler.CheckTwoFingerGestureAction();
3057 EXPECT_FALSE(ret);
3058 }
3059
3060 /**
3061 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_002
3062 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
3063 * @tc.type: FUNC
3064 * @tc.require:
3065 */
3066 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_002, TestSize.Level1)
3067 {
3068 CALL_TEST_DEBUG;
3069 KeyCommandHandler handler;
3070 handler.twoFingerGesture_.active = true;
3071 handler.twoFingerGesture_.touches[0].id = 1;
3072 handler.twoFingerGesture_.touches[0].x = 100;
3073 handler.twoFingerGesture_.touches[0].y = 200;
3074 handler.twoFingerGesture_.touches[0].downTime = 150000;
3075 handler.twoFingerGesture_.touches[1].id = 2;
3076 handler.twoFingerGesture_.touches[1].x = 300;
3077 handler.twoFingerGesture_.touches[1].y = 400;
3078 handler.twoFingerGesture_.touches[1].downTime = 50000;
3079 bool ret = handler.CheckTwoFingerGestureAction();
3080 EXPECT_FALSE(ret);
3081 }
3082
3083 /**
3084 * @tc.name: KeyCommandHandlerTest_ConvertVPToPX_001
3085 * @tc.desc: Test the funcation ConvertVPToPX
3086 * @tc.type: FUNC
3087 * @tc.require:
3088 */
3089 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ConvertVPToPX_001, TestSize.Level1)
3090 {
3091 CALL_TEST_DEBUG;
3092 KeyCommandHandler handler;
3093 int32_t vp = -1;
3094 ASSERT_NO_FATAL_FAILURE(handler.ConvertVPToPX(vp));
3095 vp = 1;
3096 ASSERT_NO_FATAL_FAILURE(handler.ConvertVPToPX(vp));
3097 }
3098
3099 /**
3100 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchMove_002
3101 * @tc.desc: Test the funcation HandleKnuckleGestureTouchMove
3102 * @tc.type: FUNC
3103 * @tc.require:
3104 */
3105 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchMove_002, TestSize.Level1)
3106 {
3107 CALL_TEST_DEBUG;
3108 KeyCommandHandler handler;
3109 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3110 ASSERT_NE(touchEvent, nullptr);
3111 PointerEvent::PointerItem item;
3112 item.displayX_ = 8.0;
3113 item.displayY_ = 8.0;
3114 handler.gestureLastX_ = 4.0;
3115 handler.gestureLastY_ = 4.0;
3116 handler.isGesturing_ = false;
3117 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchMove(touchEvent));
3118 handler.isGesturing_ = true;
3119 handler.isLetterGesturing_ = false;
3120 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchMove(touchEvent));
3121 handler.isLetterGesturing_ = true;
3122 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchMove(touchEvent));
3123 handler.gestureLastX_ = 6.0;
3124 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchMove(touchEvent));
3125 handler.gestureLastY_ = 6.0;
3126 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchMove(touchEvent));
3127 }
3128
3129 /**
3130 * @tc.name: KeyCommandHandlerTest_ReportIfNeed_001
3131 * @tc.desc: Test the funcation ReportIfNeed
3132 * @tc.type: FUNC
3133 * @tc.require:
3134 */
3135 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ReportIfNeed_001, TestSize.Level1)
3136 {
3137 CALL_TEST_DEBUG;
3138 KeyCommandHandler handler;
3139 ASSERT_NO_FATAL_FAILURE(handler.ReportIfNeed());
3140 handler.isGesturing_ = true;
3141 handler.isLastGestureSucceed_ = true;
3142 ASSERT_NO_FATAL_FAILURE(handler.ReportIfNeed());
3143 handler.isLastGestureSucceed_ = false;
3144 ASSERT_NO_FATAL_FAILURE(handler.ReportIfNeed());
3145 }
3146
3147 /**
3148 * @tc.name: KeyCommandHandlerTest_ReportGestureInfo_001
3149 * @tc.desc: Test the funcation ReportGestureInfo
3150 * @tc.type: FUNC
3151 * @tc.require:
3152 */
3153 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ReportGestureInfo_001, TestSize.Level1)
3154 {
3155 CALL_TEST_DEBUG;
3156 KeyCommandHandler handler;
3157 handler.isLastGestureSucceed_ = true;
3158 ASSERT_NO_FATAL_FAILURE(handler.ReportGestureInfo());
3159 handler.isLastGestureSucceed_ = false;
3160 ASSERT_NO_FATAL_FAILURE(handler.ReportGestureInfo());
3161 }
3162
3163 /**
3164 * @tc.name: KeyCommandHandlerTest_AddSequenceKey_004
3165 * @tc.desc: Test the funcation AddSequenceKey
3166 * @tc.type: FUNC
3167 * @tc.require:
3168 */
3169 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_AddSequenceKey_004, TestSize.Level1)
3170 {
3171 CALL_TEST_DEBUG;
3172 KeyCommandHandler handler;
3173 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3174 ASSERT_NE(keyEvent, nullptr);
3175 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
3176 EXPECT_NE(inputEvent, nullptr);
3177 inputEvent->actionTime_ = 1;
3178 SequenceKey sequenceKey;
3179 sequenceKey.keyCode = 1;
3180 sequenceKey.keyAction = 2;
3181 sequenceKey.actionTime = 3;
3182 sequenceKey.delay = 4;
3183 handler.keys_.push_back(sequenceKey);
3184 bool ret = handler.AddSequenceKey(keyEvent);
3185 ASSERT_TRUE(ret);
3186 inputEvent->actionTime_ = 1100000;
3187 ret = handler.AddSequenceKey(keyEvent);
3188 ASSERT_FALSE(ret);
3189 inputEvent->actionTime_ = 100000;
3190 ret = handler.AddSequenceKey(keyEvent);
3191 ASSERT_FALSE(ret);
3192 }
3193
3194 /**
3195 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_004
3196 * @tc.desc: Test knuckle gesture touch up event straight line
3197 * @tc.type: FUNC
3198 * @tc.require:
3199 */
3200 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_004, TestSize.Level1)
3201 {
3202 CALL_TEST_DEBUG;
3203 KeyCommandHandler handler;
3204 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3205 ASSERT_NE(touchEvent, nullptr);
3206 GESTURESENSE_WRAPPER->touchUp_ = [](const std::vector<float> &, const std::vector<int64_t> &, bool, bool)
__anonaf89f2d60202(const std::vector<float> &, const std::vector<int64_t> &, bool, bool) 3207 -> int32_t {
3208 return 0;
3209 };
3210 ASSERT_NE(GESTURESENSE_WRAPPER->touchUp_, nullptr);
3211 handler.gesturePoints_.assign(LINE_COORDINATES.begin(), LINE_COORDINATES.end());
3212 handler.gestureTimeStamps_.assign(LINE_TIMESTAMPS.begin(), LINE_TIMESTAMPS.end());
3213 handler.isGesturing_ = true;
3214 handler.isLetterGesturing_ = true;
3215 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3216 handler.gesturePoints_.assign(CIRCLE_COORDINATES.begin(), CIRCLE_COORDINATES.end());
3217 handler.gestureTimeStamps_.assign(CIRCLE_TIMESTAMPS.begin(), CIRCLE_TIMESTAMPS.end());
3218 handler.isGesturing_ = true;
3219 handler.isLetterGesturing_ = true;
3220 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3221 handler.gesturePoints_.assign(CURVE_COORDINATES.begin(), CURVE_COORDINATES.end());
3222 handler.gestureTimeStamps_.assign(CURVE_TIMESTAMPS.begin(), CURVE_TIMESTAMPS.end());
3223 handler.isGesturing_ = true;
3224 handler.isLetterGesturing_ = true;
3225 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3226 }
3227
3228 /**
3229 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_004
3230 * @tc.desc: Test the funcation HandleShortKeys
3231 * @tc.type: FUNC
3232 * @tc.require:
3233 */
3234 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_004, TestSize.Level1)
3235 {
3236 KeyCommandHandler handler;
3237 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3238 ASSERT_NE(keyEvent, nullptr);
3239 ShortcutKey key;
3240 key.preKeys = {1, 2, 3};
3241 key.businessId = "business1";
3242 key.statusConfig = "config1";
3243 key.statusConfigValue = true;
3244 key.finalKey = 4;
3245 key.keyDownDuration = 5;
3246 key.triggerType = KeyEvent::KEY_ACTION_DOWN;
3247 key.timerId = 6;
3248 handler.lastMatchedKey_.finalKey = 1;
3249 handler.lastMatchedKey_.triggerType = 2;
3250 keyEvent->SetKeyCode(1);
3251 keyEvent->SetKeyAction(2);
3252 bool result = handler.IsKeyMatch(handler.lastMatchedKey_, keyEvent);
3253 ASSERT_FALSE(result);
3254 handler.shortcutKeys_.insert(std::make_pair("key1", key));
3255 bool ret = handler.HandleShortKeys(keyEvent);
3256 ASSERT_FALSE(ret);
3257 }
3258
3259 /**
3260 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_005
3261 * @tc.desc: Test the funcation HandleShortKeys
3262 * @tc.type: FUNC
3263 * @tc.require:
3264 */
3265 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_005, TestSize.Level1)
3266 {
3267 KeyCommandHandler handler;
3268 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3269 ASSERT_NE(keyEvent, nullptr);
3270 ShortcutKey key;
3271 key.preKeys = {1, 2, 3};
3272 key.businessId = "business1";
3273 key.statusConfig = "config1";
3274 key.statusConfigValue = true;
3275 key.finalKey = 4;
3276 key.keyDownDuration = 5;
3277 key.triggerType = KeyEvent::KEY_ACTION_DOWN;
3278 key.timerId = 6;
3279 handler.currentLaunchAbilityKey_.finalKey = 1;
3280 handler.currentLaunchAbilityKey_.triggerType = 2;
3281 keyEvent->SetKeyCode(1);
3282 keyEvent->SetKeyAction(2);
3283 bool result = handler.IsKeyMatch(handler.currentLaunchAbilityKey_, keyEvent);
3284 ASSERT_FALSE(result);
3285 handler.shortcutKeys_.insert(std::make_pair("key1", key));
3286 handler.currentLaunchAbilityKey_.timerId = 0;
3287 bool ret = handler.HandleShortKeys(keyEvent);
3288 ASSERT_FALSE(ret);
3289 handler.currentLaunchAbilityKey_.timerId = -1;
3290 ret = handler.HandleShortKeys(keyEvent);
3291 ASSERT_FALSE(ret);
3292 handler.currentLaunchAbilityKey_.timerId = 0;
3293 handler.currentLaunchAbilityKey_.finalKey = 1;
3294 handler.currentLaunchAbilityKey_.triggerType = 2;
3295 keyEvent->SetKeyCode(3);
3296 keyEvent->SetKeyAction(4);
3297 ret = handler.HandleShortKeys(keyEvent);
3298 ASSERT_FALSE(ret);
3299 handler.currentLaunchAbilityKey_.timerId = -1;
3300 handler.currentLaunchAbilityKey_.finalKey = 1;
3301 handler.currentLaunchAbilityKey_.triggerType = 2;
3302 keyEvent->SetKeyCode(3);
3303 keyEvent->SetKeyAction(4);
3304 ret = handler.HandleShortKeys(keyEvent);
3305 ASSERT_FALSE(ret);
3306 }
3307
3308 /**
3309 * @tc.name: KeyCommandHandlerTest_HandleMatchedSequence_002
3310 * @tc.desc: Test the funcation HandleMatchedSequence
3311 * @tc.type: FUNC
3312 * @tc.require:
3313 */
3314 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleMatchedSequence_002, TestSize.Level1)
3315 {
3316 CALL_TEST_DEBUG;
3317 KeyCommandHandler handler;
3318 Sequence sequence;
3319 bool isLaunchAbility = true;
3320 DISPLAY_MONITOR->isScreenLocked_ = false;
3321 sequence.ability.bundleName = ".screenshot";
3322 DISPLAY_MONITOR->screenStatus_ = "usual.event.SCREEN_OFF";
3323 bool ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3324 ASSERT_TRUE(ret);
3325 DISPLAY_MONITOR->screenStatus_ = "usual.event.SCREEN_OFF";
3326 sequence.ability.bundleName = "abc";
3327 DisplayEventMonitor displayEventMonitor;
3328 displayEventMonitor.screenStatus_ = "usual.event.SCREEN_OFF";
3329 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3330 ASSERT_TRUE(ret);
3331 DISPLAY_MONITOR->screenStatus_ = "usual.event.SCREEN_LOCKED";
3332 DISPLAY_MONITOR->isScreenLocked_ = true;
3333 sequence.ability.bundleName = ".screenshot";
3334 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3335 ASSERT_TRUE(ret);
3336 DISPLAY_MONITOR->isScreenLocked_ = false;
3337 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3338 ASSERT_TRUE(ret);
3339 DISPLAY_MONITOR->isScreenLocked_ = true;
3340 sequence.ability.bundleName = "abc";
3341 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3342 ASSERT_TRUE(ret);
3343 DISPLAY_MONITOR->isScreenLocked_ = false;
3344 sequence.ability.bundleName = "abc";
3345 ret = handler.HandleMatchedSequence(sequence, isLaunchAbility);
3346 ASSERT_TRUE(ret);
3347 }
3348
3349 /**
3350 * @tc.name: KeyCommandHandlerTest_HandlePointerVisibleKeys_001
3351 * @tc.desc: Test HandlePointerVisibleKeys
3352 * @tc.type: FUNC
3353 * @tc.require:
3354 */
3355 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandlePointerVisibleKeys_001, TestSize.Level1)
3356 {
3357 CALL_TEST_DEBUG;
3358 KeyCommandHandler handler;
3359 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3360 ASSERT_NE(keyEvent, nullptr);
3361 keyEvent->keyCode_ = KeyEvent::KEYCODE_F9;
3362 handler.lastKeyEventCode_ = KeyEvent::KEYCODE_CTRL_LEFT;
3363 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerVisibleKeys(keyEvent));
3364 keyEvent->keyCode_ = KeyEvent::KEYCODE_F1;
3365 handler.lastKeyEventCode_ = KeyEvent::KEYCODE_CTRL_LEFT;
3366 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerVisibleKeys(keyEvent));
3367 keyEvent->keyCode_ = KeyEvent::KEYCODE_F9;
3368 handler.lastKeyEventCode_ = KeyEvent::KEYCODE_CAPS_LOCK;
3369 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerVisibleKeys(keyEvent));
3370 keyEvent->keyCode_ = KeyEvent::KEYCODE_F1;
3371 handler.lastKeyEventCode_ = KeyEvent::KEYCODE_CAPS_LOCK;
3372 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerVisibleKeys(keyEvent));
3373 }
3374
3375 /**
3376 * @tc.name: KeyCommandHandlerTest_ConvertVPToPX_002
3377 * @tc.desc: Test the funcation ConvertVPToPX
3378 * @tc.type: FUNC
3379 * @tc.require:
3380 */
3381 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ConvertVPToPX_002, TestSize.Level1)
3382 {
3383 CALL_TEST_DEBUG;
3384 KeyCommandHandler handler;
3385 int32_t vp = -5;
3386 int32_t ret = handler.ConvertVPToPX(vp);
3387 ASSERT_EQ(ret, 0);
3388 vp = 5;
3389 InputWindowsManager inputWindowsManager;
3390 DisplayInfo displayInfo;
3391 displayInfo.id = 1;
3392 displayInfo.x = 2;
3393 displayInfo.y = 3;
3394 displayInfo.width = 4;
3395 displayInfo.height = 5;
3396 displayInfo.dpi = -1;
3397 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3398 ret = handler.ConvertVPToPX(vp);
3399 ASSERT_EQ(ret, 0);
3400 }
3401
3402 /**
3403 * @tc.name: KeyCommandHandlerTest_ConvertVPToPX_003
3404 * @tc.desc: Test the funcation ConvertVPToPX
3405 * @tc.type: FUNC
3406 * @tc.require:
3407 */
3408 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ConvertVPToPX_003, TestSize.Level1)
3409 {
3410 CALL_TEST_DEBUG;
3411 KeyCommandHandler handler;
3412 int32_t vp = 5;
3413 InputWindowsManager inputWindowsManager;
3414 DisplayInfo displayInfo;
3415 displayInfo.id = 1;
3416 displayInfo.x = 2;
3417 displayInfo.y = 3;
3418 displayInfo.width = 4;
3419 displayInfo.height = 5;
3420 displayInfo.dpi = 160;
3421 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3422 int32_t ret = handler.ConvertVPToPX(vp);
3423 ASSERT_EQ(ret, 0);
3424 }
3425
3426 /**
3427 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_003
3428 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
3429 * @tc.type: FUNC
3430 * @tc.require:
3431 */
3432 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_003, TestSize.Level1)
3433 {
3434 CALL_TEST_DEBUG;
3435 KeyCommandHandler handler;
3436 handler.twoFingerGesture_.active = true;
3437 handler.twoFingerGesture_.touches[0].id = 1;
3438 handler.twoFingerGesture_.touches[0].x = -100;
3439 handler.twoFingerGesture_.touches[0].y = -200;
3440 handler.twoFingerGesture_.touches[0].downTime = 100000;
3441 handler.twoFingerGesture_.touches[1].id = 2;
3442 handler.twoFingerGesture_.touches[1].x = -300;
3443 handler.twoFingerGesture_.touches[1].y = -400;
3444 handler.twoFingerGesture_.touches[1].downTime = 50000;
3445 InputWindowsManager inputWindowsManager;
3446 DisplayInfo displayInfo;
3447 displayInfo.id = 1;
3448 displayInfo.x = 2;
3449 displayInfo.y = 3;
3450 displayInfo.width = 4;
3451 displayInfo.height = 5;
3452 displayInfo.dpi = -1;
3453 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3454 bool ret = handler.CheckTwoFingerGestureAction();
3455 EXPECT_FALSE(ret);
3456 }
3457
3458 /**
3459 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_004
3460 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
3461 * @tc.type: FUNC
3462 * @tc.require:
3463 */
3464 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_004, TestSize.Level1)
3465 {
3466 CALL_TEST_DEBUG;
3467 KeyCommandHandler handler;
3468 handler.twoFingerGesture_.active = true;
3469 handler.twoFingerGesture_.touches[0].id = 1;
3470 handler.twoFingerGesture_.touches[0].x = 100;
3471 handler.twoFingerGesture_.touches[0].y = 200;
3472 handler.twoFingerGesture_.touches[0].downTime = 100000;
3473 handler.twoFingerGesture_.touches[1].id = 2;
3474 handler.twoFingerGesture_.touches[1].x = 300;
3475 handler.twoFingerGesture_.touches[1].y = 400;
3476 handler.twoFingerGesture_.touches[1].downTime = 50000;
3477 InputWindowsManager inputWindowsManager;
3478 DisplayInfo displayInfo;
3479 displayInfo.id = 1;
3480 displayInfo.x = 2;
3481 displayInfo.y = 3;
3482 displayInfo.width = 40;
3483 displayInfo.height = 50;
3484 displayInfo.dpi = -1;
3485 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3486 bool ret = handler.CheckTwoFingerGestureAction();
3487 EXPECT_FALSE(ret);
3488 }
3489
3490 /**
3491 * @tc.name: KeyCommandHandlerTest_CheckTwoFingerGestureAction_005
3492 * @tc.desc: Test the funcation CheckTwoFingerGestureAction
3493 * @tc.type: FUNC
3494 * @tc.require:
3495 */
3496 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckTwoFingerGestureAction_005, TestSize.Level1)
3497 {
3498 CALL_TEST_DEBUG;
3499 KeyCommandHandler handler;
3500 handler.twoFingerGesture_.active = true;
3501 handler.twoFingerGesture_.touches[0].id = 1;
3502 handler.twoFingerGesture_.touches[0].x = 10;
3503 handler.twoFingerGesture_.touches[0].y = 20;
3504 handler.twoFingerGesture_.touches[0].downTime = 100000;
3505 handler.twoFingerGesture_.touches[1].id = 2;
3506 handler.twoFingerGesture_.touches[1].x = 30;
3507 handler.twoFingerGesture_.touches[1].y = 20;
3508 handler.twoFingerGesture_.touches[1].downTime = 50000;
3509 InputWindowsManager inputWindowsManager;
3510 DisplayInfo displayInfo;
3511 displayInfo.id = 1;
3512 displayInfo.x = 2;
3513 displayInfo.y = 3;
3514 displayInfo.width = 40;
3515 displayInfo.height = 50;
3516 displayInfo.dpi = -1;
3517 inputWindowsManager.displayGroupInfo_.displaysInfo.push_back(displayInfo);
3518 bool ret = handler.CheckTwoFingerGestureAction();
3519 EXPECT_FALSE(ret);
3520 }
3521
3522 /**
3523 * @tc.name: KeyCommandHandlerTest_StartTwoFingerGesture_002
3524 * @tc.desc: Test the funcation StartTwoFingerGesture
3525 * @tc.type: FUNC
3526 * @tc.require:
3527 */
3528 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_StartTwoFingerGesture_002, TestSize.Level1)
3529 {
3530 KeyCommandHandler handler;
3531 handler.twoFingerGesture_.active = false;
3532 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
3533 handler.twoFingerGesture_.active = true;
3534 handler.twoFingerGesture_.touches[0].id = 5;
3535 handler.twoFingerGesture_.touches[0].x = 50;
3536 handler.twoFingerGesture_.touches[0].y = 60;
3537 handler.twoFingerGesture_.touches[0].downTime = 13000;
3538 handler.twoFingerGesture_.touches[1].id = 9;
3539 handler.twoFingerGesture_.touches[1].x = 100;
3540 handler.twoFingerGesture_.touches[1].y = 400;
3541 handler.twoFingerGesture_.touches[1].downTime = 96000;
3542 ASSERT_NO_FATAL_FAILURE(handler.StartTwoFingerGesture());
3543 }
3544
3545 /**
3546 * @tc.name: KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_005
3547 * @tc.desc: Test the funcation HandleKnuckleGestureTouchUp
3548 * @tc.type: FUNC
3549 * @tc.require:
3550 */
3551 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleKnuckleGestureTouchUp_005, TestSize.Level1)
3552 {
3553 CALL_TEST_DEBUG;
3554 KeyCommandHandler handler;
3555 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3556 ASSERT_NE(touchEvent, nullptr);
3557 GESTURESENSE_WRAPPER->touchUp_ = [](const std::vector<float> &, const std::vector<int64_t> &, bool, bool)
__anonaf89f2d60302(const std::vector<float> &, const std::vector<int64_t> &, bool, bool) 3558 -> int32_t {
3559 return 0;
3560 };
3561 ASSERT_NE(GESTURESENSE_WRAPPER->touchUp_, nullptr);
3562 handler.isGesturing_ = false;
3563 handler.isLetterGesturing_ = false;
3564 handler.gesturePoints_.assign(LINE_TIMESTAMPS.begin(), LINE_TIMESTAMPS.end());
3565 handler.gestureTimeStamps_.assign(LINE_COORDINATES.begin(), LINE_COORDINATES.end());
3566 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3567 handler.gesturePoints_.assign(CURVE_COORDINATES.begin(), CURVE_COORDINATES.end());
3568 handler.gestureTimeStamps_.assign(CURVE_TIMESTAMPS.begin(), CURVE_TIMESTAMPS.end());
3569 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3570 handler.isGesturing_ = true;
3571 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3572 handler.isLetterGesturing_ = true;
3573 ASSERT_NO_FATAL_FAILURE(handler.HandleKnuckleGestureTouchUp(touchEvent));
3574 }
3575
3576 /**
3577 * @tc.name: KeyCommandHandlerTest_ParseJson_001
3578 * @tc.desc: Test the funcation ParseJson
3579 * @tc.type: FUNC
3580 * @tc.require:
3581 */
3582 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_ParseJson_001, TestSize.Level1)
3583 {
3584 CALL_TEST_DEBUG;
3585 KeyCommandHandler handler;
3586 std::string configFile;
3587 bool ret = handler.ParseJson(configFile);
3588 EXPECT_FALSE(ret);
3589 configFile = "config";
3590 std::string copyShortcutKey = "copyShortcutKey";
3591 ShortcutKey shortcutKey;
3592 Ability ability_temp;
3593 shortcutKey.preKeys.insert(2072);
3594 shortcutKey.finalKey = 2019;
3595 shortcutKey.keyDownDuration = 100;
3596 ability_temp.bundleName = "bundleName";
3597 ability_temp.abilityName = "abilityName";
3598 shortcutKey.ability = ability_temp;
3599 handler.shortcutKeys_.insert(std::make_pair(copyShortcutKey, shortcutKey));
3600 handler.businessIds_ = {"businessId"};
3601 handler.twoFingerGesture_.active = true;
3602 handler.twoFingerGesture_.timerId = 1;
3603 ret = handler.ParseJson(configFile);
3604 EXPECT_FALSE(ret);
3605 }
3606
3607 /**
3608 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_003
3609 * @tc.desc: Test the funcation IsEnableCombineKey
3610 * @tc.type: FUNC
3611 * @tc.require:
3612 */
3613 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_003, TestSize.Level1)
3614 {
3615 CALL_TEST_DEBUG;
3616 KeyCommandHandler handler;
3617 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
3618 ASSERT_NE(key, nullptr);
3619 handler.enableCombineKey_ = false;
3620 handler.isParseExcludeConfig_ = false;
3621 ASSERT_FALSE(handler.IsEnableCombineKey(key));
3622 handler.isParseExcludeConfig_ = true;
3623 ExcludeKey excludeKey;
3624 excludeKey.keyCode = 1;
3625 excludeKey.keyAction = 2;
3626 excludeKey.delay = 3;
3627 handler.excludeKeys_.push_back(excludeKey);
3628 key->keyCode_ = 1;
3629 key->keyAction_ = 2;
3630 SequenceKey sequenceKey;
3631 sequenceKey.keyCode = 2017;
3632 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
3633 handler.keys_.push_back(sequenceKey);
3634 ASSERT_FALSE(handler.IsEnableCombineKey(key));
3635 sequenceKey.keyCode = 2018;
3636 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
3637 handler.keys_.push_back(sequenceKey);
3638 ASSERT_FALSE(handler.IsEnableCombineKey(key));
3639 }
3640
3641 /**
3642 * @tc.name: KeyCommandHandlerTest_IsEnableCombineKey_004
3643 * @tc.desc: Test the funcation IsEnableCombineKey
3644 * @tc.type: FUNC
3645 * @tc.require:
3646 */
3647 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_IsEnableCombineKey_004, TestSize.Level1)
3648 {
3649 CALL_TEST_DEBUG;
3650 KeyCommandHandler handler;
3651 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
3652 ASSERT_NE(key, nullptr);
3653 handler.enableCombineKey_ = false;
3654 handler.isParseExcludeConfig_ = true;
3655 ExcludeKey excludeKey;
3656 excludeKey.keyCode = 1;
3657 excludeKey.keyAction = 2;
3658 excludeKey.delay = 3;
3659 handler.excludeKeys_.push_back(excludeKey);
3660 key->keyCode_ = KeyEvent::KEYCODE_L;
3661 key->keyAction_ = 200;
3662 SequenceKey sequenceKey;
3663 sequenceKey.keyCode = KeyEvent::KEYCODE_SPACE;
3664 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
3665 handler.keys_.push_back(sequenceKey);
3666 ASSERT_TRUE(handler.IsEnableCombineKey(key));
3667 sequenceKey.keyCode = KeyEvent::KEYCODE_L;
3668 handler.keys_.push_back(sequenceKey);
3669 ASSERT_TRUE(handler.IsEnableCombineKey(key));
3670 sequenceKey.keyCode = KeyEvent::KEYCODE_META_LEFT;
3671 handler.keys_.push_back(sequenceKey);
3672 ASSERT_TRUE(handler.IsEnableCombineKey(key));
3673 sequenceKey.keyCode = KeyEvent::KEYCODE_META_RIGHT;
3674 handler.keys_.push_back(sequenceKey);
3675 ASSERT_TRUE(handler.IsEnableCombineKey(key));
3676 }
3677
3678 /**
3679 * @tc.name: KeyCommandHandlerTest_HandleEvent_001
3680 * @tc.desc: Test the funcation HandleEvent
3681 * @tc.type: FUNC
3682 * @tc.require:
3683 */
3684 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_001, TestSize.Level1)
3685 {
3686 CALL_TEST_DEBUG;
3687 KeyCommandHandler handler;
3688 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
3689 ASSERT_NE(key, nullptr);
3690 handler.enableCombineKey_ = false;
3691 handler.isParseExcludeConfig_ = true;
3692 ExcludeKey excludeKey;
3693 excludeKey.keyCode = 3;
3694 excludeKey.keyAction = 5;
3695 excludeKey.delay = 8;
3696 handler.excludeKeys_.push_back(excludeKey);
3697 key->keyCode_ = KeyEvent::KEYCODE_L;
3698 key->keyAction_ = 200;
3699 SequenceKey sequenceKey;
3700 sequenceKey.keyCode = KeyEvent::KEYCODE_SPACE;
3701 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
3702 handler.keys_.push_back(sequenceKey);
3703 ShortcutKey shortcutKey;
3704 shortcutKey.preKeys = {1, 2, 3};
3705 shortcutKey.businessId = "business1";
3706 shortcutKey.statusConfig = "config1";
3707 shortcutKey.statusConfigValue = true;
3708 shortcutKey.finalKey = 4;
3709 shortcutKey.keyDownDuration = 5;
3710 shortcutKey.triggerType = KeyEvent::KEY_ACTION_DOWN;
3711 shortcutKey.timerId = 6;
3712 handler.currentLaunchAbilityKey_.finalKey = 1;
3713 handler.currentLaunchAbilityKey_.triggerType = 2;
3714 key->SetKeyCode(1);
3715 key->SetKeyAction(2);
3716 handler.IsKeyMatch(handler.currentLaunchAbilityKey_, key);
3717 handler.shortcutKeys_.insert(std::make_pair("key1", shortcutKey));
3718 handler.currentLaunchAbilityKey_.timerId = 0;
3719 handler.HandleShortKeys(key);
3720 handler.isKeyCancel_ = true;
3721 bool ret = handler.HandleEvent(key);
3722 EXPECT_FALSE(ret);
3723 handler.isKeyCancel_ = false;
3724 ret = handler.HandleEvent(key);
3725 EXPECT_FALSE(ret);
3726 }
3727
3728 /**
3729 * @tc.name: KeyCommandHandlerTest_HandleEvent_002
3730 * @tc.desc: Test the funcation HandleEvent
3731 * @tc.type: FUNC
3732 * @tc.require:
3733 */
3734 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleEvent_002, TestSize.Level1)
3735 {
3736 CALL_TEST_DEBUG;
3737 KeyCommandHandler handler;
3738 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
3739 ASSERT_NE(key, nullptr);
3740 handler.enableCombineKey_ = false;
3741 handler.isParseExcludeConfig_ = true;
3742 ExcludeKey excludeKey;
3743 excludeKey.keyCode = 2;
3744 excludeKey.keyAction = 6;
3745 excludeKey.delay = 9;
3746 handler.excludeKeys_.push_back(excludeKey);
3747 key->keyCode_ = KeyEvent::KEYCODE_L;
3748 key->keyAction_ = 300;
3749 SequenceKey sequenceKey;
3750 sequenceKey.keyCode = KeyEvent::KEYCODE_SPACE;
3751 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
3752 handler.keys_.push_back(sequenceKey);
3753 ShortcutKey shortcutKey;
3754 shortcutKey.preKeys = {1, 2, 3};
3755 shortcutKey.businessId = "business2";
3756 shortcutKey.statusConfig = "config2";
3757 shortcutKey.statusConfigValue = true;
3758 shortcutKey.finalKey = 5;
3759 shortcutKey.keyDownDuration = 6;
3760 shortcutKey.triggerType = KeyEvent::KEY_ACTION_UP;
3761 shortcutKey.timerId = 6;
3762 Ability ability_temp;
3763 ability_temp.bundleName = "bundleName2";
3764 ability_temp.abilityName = "abilityName2";
3765 shortcutKey.ability = ability_temp;
3766 handler.shortcutKeys_.insert(std::make_pair("key2", shortcutKey));
3767 handler.HandleShortKeys(key);
3768 handler.isDownStart_ = false;
3769 bool ret = handler.HandleEvent(key);
3770 EXPECT_FALSE(ret);
3771 handler.isDownStart_ = true;
3772 ret = handler.HandleEvent(key);
3773 EXPECT_FALSE(ret);
3774 }
3775
3776 /**
3777 * @tc.name: KeyCommandHandlerTest_OnHandleEvent_001
3778 * @tc.desc: Test the funcation OnHandleEvent
3779 * @tc.type: FUNC
3780 * @tc.require:
3781 */
3782 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_OnHandleEvent_001, TestSize.Level1)
3783 {
3784 CALL_TEST_DEBUG;
3785 KeyCommandHandler handler;
3786 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
3787 ASSERT_NE(key, nullptr);
3788 key->SetKeyCode(KeyEvent::KEYCODE_POWER);
3789 int32_t keyAction = KeyEvent::KEYCODE_VOLUME_UP;
3790 handler.specialKeys_.insert(std::make_pair(10, keyAction));
3791 bool ret = handler.OnHandleEvent(key);
3792 EXPECT_FALSE(ret);
3793 key->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP);
3794 int32_t keyCode = 99;
3795 std::list<int32_t> timerIds;
3796 timerIds.push_back(100);
3797 handler.specialTimers_.insert(std::make_pair(keyCode, timerIds));
3798 ret = handler.OnHandleEvent(key);
3799 EXPECT_FALSE(ret);
3800 keyCode = KeyEvent::KEYCODE_VOLUME_UP;
3801 handler.specialTimers_.insert(std::make_pair(keyCode, timerIds));
3802 ret = handler.OnHandleEvent(key);
3803 EXPECT_FALSE(ret);
3804 }
3805
3806 /**
3807 * @tc.name: KeyCommandHandlerTest_HandleRepeatKey_001
3808 * @tc.desc: Test the funcation HandleRepeatKey
3809 * @tc.type: FUNC
3810 * @tc.require:
3811 */
3812 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleRepeatKey_001, TestSize.Level1)
3813 {
3814 CALL_TEST_DEBUG;
3815 KeyCommandHandler handler;
3816 RepeatKey item;
3817 bool isLaunched = true;
3818 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3819 ASSERT_NE(keyEvent, nullptr);
3820 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP);
3821 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
3822 item.keyCode = KeyEvent::KEYCODE_VOLUME_DOWN;
3823 item.times = 5;
3824 handler.count_ = 5;
3825 ASSERT_FALSE(handler.HandleRepeatKey(item, isLaunched, keyEvent));
3826 handler.count_ = 10;
3827 ASSERT_FALSE(handler.HandleRepeatKey(item, isLaunched, keyEvent));
3828 }
3829
3830 /**
3831 * @tc.name: KeyCommandHandlerTest_HandleRepeatKey_002
3832 * @tc.desc: Test the funcation HandleRepeatKey
3833 * @tc.type: FUNC
3834 * @tc.require:
3835 */
3836 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleRepeatKey_002, TestSize.Level1)
3837 {
3838 CALL_TEST_DEBUG;
3839 KeyCommandHandler handler;
3840 RepeatKey item;
3841 bool isLaunched = false;
3842 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
3843 ASSERT_NE(keyEvent, nullptr);
3844 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN);
3845 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
3846 item.keyCode = KeyEvent::KEYCODE_VOLUME_DOWN;
3847 item.times = 6;
3848 handler.count_ = 5;
3849 ASSERT_FALSE(handler.HandleRepeatKey(item, isLaunched, keyEvent));
3850 }
3851
3852 /**
3853 * @tc.name: KeyCommandHandlerTest_CheckInputMethodArea_001
3854 * @tc.desc: Test the funcation CheckInputMethodArea
3855 * @tc.type: FUNC
3856 * @tc.require:
3857 */
3858 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckInputMethodArea_001, TestSize.Level1)
3859 {
3860 CALL_TEST_DEBUG;
3861 KeyCommandHandler handler;
3862 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3863 ASSERT_NE(touchEvent, nullptr);
3864 WindowInfo windowInfo;
3865 windowInfo.windowType = 2000;
3866 bool ret = handler.CheckInputMethodArea(touchEvent);
3867 ASSERT_FALSE(ret);
3868 windowInfo.windowType = 2105;
3869 windowInfo.area.x = 10;
3870 windowInfo.area.width = INT32_MAX;
3871 windowInfo.area.y = 100;
3872 windowInfo.area.height = 200;
3873 std::vector<WindowInfo> windows;
3874 windows.push_back(windowInfo);
3875 ret = handler.CheckInputMethodArea(touchEvent);
3876 ASSERT_FALSE(ret);
3877 }
3878
3879 /**
3880 * @tc.name: KeyCommandHandlerTest_CheckInputMethodArea_002
3881 * @tc.desc: Test the funcation CheckInputMethodArea
3882 * @tc.type: FUNC
3883 * @tc.require:
3884 */
3885 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckInputMethodArea_002, TestSize.Level1)
3886 {
3887 CALL_TEST_DEBUG;
3888 KeyCommandHandler handler;
3889 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3890 ASSERT_NE(touchEvent, nullptr);
3891 WindowInfo windowInfo;
3892 windowInfo.windowType = 2105;
3893 windowInfo.area.x = 10;
3894 windowInfo.area.width = 100;
3895 windowInfo.area.y = 20;
3896 windowInfo.area.height = INT32_MAX;
3897 std::vector<WindowInfo> windows;
3898 windows.push_back(windowInfo);
3899 bool ret = handler.CheckInputMethodArea(touchEvent);
3900 ASSERT_FALSE(ret);
3901 }
3902
3903 /**
3904 * @tc.name: KeyCommandHandlerTest_CheckInputMethodArea_003
3905 * @tc.desc: Test the funcation CheckInputMethodArea
3906 * @tc.type: FUNC
3907 * @tc.require:
3908 */
3909 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckInputMethodArea_003, TestSize.Level1)
3910 {
3911 CALL_TEST_DEBUG;
3912 KeyCommandHandler handler;
3913 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
3914 ASSERT_NE(touchEvent, nullptr);
3915 WindowInfo windowInfo;
3916 windowInfo.windowType = 2105;
3917 windowInfo.area.x = 30;
3918 windowInfo.area.width = 300;
3919 windowInfo.area.y = 90;
3920 windowInfo.area.height = 1000;
3921 std::vector<WindowInfo> windows;
3922 windows.push_back(windowInfo);
3923 bool ret = handler.CheckInputMethodArea(touchEvent);
3924 ASSERT_FALSE(ret);
3925 }
3926
3927 /**
3928 * @tc.name: KeyCommandHandlerTest_CheckInputMethodArea_004
3929 * @tc.desc: Test the funcation CheckInputMethodArea
3930 * @tc.type: FUNC
3931 * @tc.require:
3932 */
3933 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckInputMethodArea_004, TestSize.Level1)
3934 {
3935 CALL_TEST_DEBUG;
3936 KeyCommandHandler handler;
3937 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
3938 ASSERT_NE(pointerEvent, nullptr);
3939
3940 WindowInfo windowInfo;
3941 windowInfo.windowType = WINDOW_INPUT_METHOD_TYPE;
3942 bool ret = handler.CheckInputMethodArea(pointerEvent);
3943 EXPECT_FALSE(ret);
3944
3945 windowInfo.area.x = 10;
3946 windowInfo.area.width = INT32_MAX;
3947 windowInfo.area.y = 100;
3948 windowInfo.area.height = 200;
3949 ret = handler.CheckInputMethodArea(pointerEvent);
3950 EXPECT_FALSE(ret);
3951 }
3952
3953 /**
3954 * @tc.name: KeyCommandHandlerTest_SendKeyEvent_001
3955 * @tc.desc: Test the funcation SendKeyEvent
3956 * @tc.type: FUNC
3957 * @tc.require:
3958 */
3959 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SendKeyEvent_001, TestSize.Level1)
3960 {
3961 CALL_TEST_DEBUG;
3962 KeyCommandHandler handler;
3963 handler.isHandleSequence_ = true;
3964 handler.launchAbilityCount_ = 1;
3965 handler.count_ = 5;
3966 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent());
3967 }
3968
3969 /**
3970 * @tc.name: KeyCommandHandlerTest_SendKeyEvent_002
3971 * @tc.desc: Test the funcation SendKeyEvent
3972 * @tc.type: FUNC
3973 * @tc.require:
3974 */
3975 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SendKeyEvent_002, TestSize.Level1)
3976 {
3977 CALL_TEST_DEBUG;
3978 KeyCommandHandler handler;
3979 handler.isHandleSequence_ = false;
3980 handler.launchAbilityCount_ = 1;
3981 handler.repeatKey_.keyCode = 3;
3982 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent());
3983 }
3984
3985 /**
3986 * @tc.name: KeyCommandHandlerTest_SendKeyEvent_003
3987 * @tc.desc: Test the funcation SendKeyEvent
3988 * @tc.type: FUNC
3989 * @tc.require:
3990 */
3991 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_SendKeyEvent_003, TestSize.Level1)
3992 {
3993 CALL_TEST_DEBUG;
3994 KeyCommandHandler handler;
3995 handler.isHandleSequence_ = false;
3996 handler.launchAbilityCount_ = 0;
3997 handler.repeatKey_.keyCode = 2;
3998 ASSERT_NO_FATAL_FAILURE(handler.SendKeyEvent());
3999 }
4000
4001 /**
4002 * @tc.name: KeyCommandHandlerTest_CheckAndUpdateTappingCountAtDown_001
4003 * @tc.desc: Test the funcation CheckAndUpdateTappingCountAtDown
4004 * @tc.type: FUNC
4005 * @tc.require:
4006 */
4007 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckAndUpdateTappingCountAtDown_001, TestSize.Level1)
4008 {
4009 CALL_TEST_DEBUG;
4010 KeyCommandHandler handler;
4011 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
4012 ASSERT_NE(touchEvent, nullptr);
4013 touchEvent->SetActionTime(0);
4014 handler.lastDownTime_ = 0;
4015 ASSERT_NO_FATAL_FAILURE(handler.CheckAndUpdateTappingCountAtDown(touchEvent));
4016 ASSERT_EQ(handler.tappingCount_, 1);
4017
4018 touchEvent->SetActionTime(600000);
4019 ASSERT_NO_FATAL_FAILURE(handler.CheckAndUpdateTappingCountAtDown(touchEvent));
4020 ASSERT_EQ(handler.tappingCount_, 1);
4021 }
4022
4023 /**
4024 * @tc.name: KeyCommandHandlerTest_CheckAndUpdateTappingCountAtDown_002
4025 * @tc.desc: Test the funcation CheckAndUpdateTappingCountAtDown
4026 * @tc.type: FUNC
4027 * @tc.require:
4028 */
4029 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckAndUpdateTappingCountAtDown_002, TestSize.Level1)
4030 {
4031 CALL_TEST_DEBUG;
4032 KeyCommandHandler handler;
4033 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
4034 ASSERT_NE(touchEvent, nullptr);
4035 touchEvent->SetActionTime(10);
4036 handler.lastDownTime_ = 0;
4037 handler.previousUpTime_ = 0;
4038 handler.downToPrevUpTimeConfig_ = 20;
4039 handler.tappingCount_ = 1;
4040 ASSERT_NO_FATAL_FAILURE(handler.CheckAndUpdateTappingCountAtDown(touchEvent));
4041 ASSERT_EQ(handler.tappingCount_, 2);
4042
4043 touchEvent->SetActionTime(20);
4044 ASSERT_NO_FATAL_FAILURE(handler.CheckAndUpdateTappingCountAtDown(touchEvent));
4045 ASSERT_EQ(handler.tappingCount_, 3);
4046 }
4047
4048 /**
4049 * @tc.name: KeyCommandHandlerTest_CheckInputMethodArea_005
4050 * @tc.desc: Test the funcation CheckInputMethodArea
4051 * @tc.type: FUNC
4052 * @tc.require:
4053 */
4054 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CheckInputMethodArea_005, TestSize.Level1)
4055 {
4056 CALL_TEST_DEBUG;
4057 KeyCommandHandler handler;
4058 InputWindowsManager inputWindowsManager;
4059 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create();
4060 ASSERT_NE(touchEvent, nullptr);
4061 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
4062 EXPECT_NE(inputEvent, nullptr);
4063 inputEvent->targetDisplayId_ = 1;
4064 WindowGroupInfo windowGroupInfo;
4065 inputWindowsManager.windowsPerDisplay_.insert(std::make_pair(1, windowGroupInfo));
4066 bool ret = handler.CheckInputMethodArea(touchEvent);
4067 ASSERT_FALSE(ret);
4068 }
4069
4070 /**
4071 * @tc.name: KeyCommandHandlerTest_HandleSequences_001
4072 * @tc.desc: HandleSequences
4073 * @tc.type: FUNC
4074 * @tc.require:
4075 */
4076 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequences_001, TestSize.Level1)
4077 {
4078 CALL_TEST_DEBUG;
4079 KeyCommandHandler handler;
4080 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
4081 ASSERT_NE(keyEvent, nullptr);
4082 handler.matchedSequence_.timerId = 10;
4083 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
4084 ASSERT_FALSE(handler.HandleSequences(keyEvent));
4085 handler.matchedSequence_.timerId = -1;
4086 ASSERT_FALSE(handler.HandleSequences(keyEvent));
4087 keyEvent->SetKeyCode(2017);
4088 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
4089 keyEvent->SetActionTime(10000);
4090 SequenceKey sequenceKey;
4091 Sequence sequence;
4092 sequence.statusConfigValue = false;
4093 sequence.timerId = 1;
4094 handler.filterSequences_.push_back(sequence);
4095 sequenceKey.actionTime = 15000;
4096 handler.keys_.push_back(sequenceKey);
4097 ASSERT_FALSE(handler.HandleSequences(keyEvent));
4098 handler.keys_.clear();
4099 keyEvent->SetActionTime(1500000);
4100 sequenceKey.actionTime = 200000;
4101 sequence.statusConfigValue = false;
4102 sequence.timerId = 1;
4103 handler.filterSequences_.push_back(sequence);
4104 ASSERT_FALSE(handler.HandleSequences(keyEvent));
4105 }
4106
4107 /**
4108 * @tc.name: KeyCommandHandlerTest_HandleConsumedKeyEvent_001
4109 * @tc.desc: Test the funcation HandleConsumedKeyEvent
4110 * @tc.type: FUNC
4111 * @tc.require:
4112 */
4113 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleConsumedKeyEvent_001, TestSize.Level1)
4114 {
4115 CALL_TEST_DEBUG;
4116 KeyCommandHandler handler;
4117 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
4118 ASSERT_NE(keyEvent, nullptr);
4119 ShortcutKey testKey;
4120 testKey.finalKey = -1;
4121 handler.currentLaunchAbilityKey_ = testKey;
4122 int32_t keyCode = -1;
4123 keyEvent->SetKeyCode(keyCode);
4124 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
4125 bool ret = handler.HandleConsumedKeyEvent(keyEvent);
4126 EXPECT_FALSE(ret);
4127 }
4128
4129 /**
4130 * @tc.name: KeyCommandHandlerTest_HandleSequences_002
4131 * @tc.desc: HandleSequences
4132 * @tc.type: FUNC
4133 * @tc.require:
4134 */
4135 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequences_002, TestSize.Level1)
4136 {
4137 CALL_TEST_DEBUG;
4138 KeyCommandHandler handler;
4139 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
4140 ASSERT_NE(keyEvent, nullptr);
4141 handler.sequenceOccurred_ = true;
4142 SequenceKey sequenceKey;
4143 sequenceKey.keyCode = 1;
4144 sequenceKey.keyAction = KeyEvent::KEY_ACTION_DOWN;
4145 handler.keys_.push_back(sequenceKey);
4146 keyEvent->SetKeyCode(1);
4147 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
4148 bool ret = handler.HandleSequences(keyEvent);
4149 ASSERT_TRUE(ret);
4150 }
4151
4152 /**
4153 * @tc.name: KeyCommandHandlerTest_HandleSequences_003
4154 * @tc.desc: HandleSequences
4155 * @tc.type: FUNC
4156 * @tc.require:
4157 */
4158 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleSequences_003, TestSize.Level1)
4159 {
4160 CALL_TEST_DEBUG;
4161 KeyCommandHandler handler;
4162 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
4163 ASSERT_NE(keyEvent, nullptr);
4164 handler.sequenceOccurred_ = false;
4165 handler.matchedSequence_.timerId = 1;
4166 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
4167 bool ret = handler.HandleSequences(keyEvent);
4168 ASSERT_FALSE(ret);
4169 }
4170
4171 /**
4172 * @tc.name: KeyCommandHandlerTest_HandleScreenLocked_001
4173 * @tc.desc: HandleScreenLocked
4174 * @tc.type: FUNC
4175 * @tc.require:
4176 */
4177 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleScreenLocked_001, TestSize.Level1)
4178 {
4179 CALL_TEST_DEBUG;
4180 KeyCommandHandler handler;
4181 Sequence sequence;
4182 sequence.timerId = -1;
4183 bool isLaunchAbility = true;
4184 bool ret = handler.HandleScreenLocked(sequence, isLaunchAbility);
4185 ASSERT_TRUE(ret);
4186 sequence.timerId = 2;
4187 ret = handler.HandleScreenLocked(sequence, isLaunchAbility);
4188 ASSERT_TRUE(ret);
4189 }
4190
4191 /**
4192 * @tc.name: KeyCommandHandlerTest_OnHandleEvent_003
4193 * @tc.desc: Test the funcation OnHandleEvent
4194 * @tc.type: FUNC
4195 * @tc.require:
4196 */
4197 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_OnHandleEvent_003, TestSize.Level1)
4198 {
4199 CALL_TEST_DEBUG;
4200 KeyCommandHandler handler;
4201 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
4202 ASSERT_NE(pointerEvent, nullptr);
4203 handler.isParseConfig_ = true;
4204 bool ret = handler.OnHandleEvent(pointerEvent);
4205 EXPECT_FALSE(ret);
4206 }
4207
4208 /**
4209 * @tc.name: KeyCommandHandlerTest_UpdateSettingsXml_002
4210 * @tc.desc: Update settings xml verify
4211 * @tc.type: FUNC
4212 * @tc.require:
4213 */
4214 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_UpdateSettingsXml_002, TestSize.Level1)
4215 {
4216 KeyCommandHandler handler;
4217 handler.businessIds_ = {"businessId"};
4218 int32_t ret = handler.UpdateSettingsXml("businessId", -1);
4219 ASSERT_EQ(ret, 401);
4220 ret = handler.UpdateSettingsXml("businessId", 5000);
4221 ASSERT_EQ(ret, 401);
4222 }
4223
4224 /**
4225 * @tc.name: KeyCommandHandlerTest_PreHandleEvent_001
4226 * @tc.desc: Test the funcation PreHandleEvent
4227 * @tc.type: FUNC
4228 * @tc.require:
4229 */
4230 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_PreHandleEvent_001, TestSize.Level1)
4231 {
4232 KeyCommandHandler handler;
4233 std::shared_ptr<KeyEvent> key = KeyEvent::Create();
4234 ASSERT_NE(key, nullptr);
4235 EventLogHelper eventLogHelper;
4236 eventLogHelper.userType_ = "beta";
4237 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
4238 EXPECT_NE(inputEvent, nullptr);
4239 inputEvent->bitwise_ = 0x00000000;
4240 bool ret = handler.PreHandleEvent(key);
4241 ASSERT_TRUE(ret);
4242 inputEvent->bitwise_ = InputEvent::EVENT_FLAG_PRIVACY_MODE;
4243 ret = handler.PreHandleEvent(key);
4244 ASSERT_TRUE(ret);
4245 handler.enableCombineKey_ = false;
4246 ret = handler.PreHandleEvent(key);
4247 ASSERT_FALSE(ret);
4248 handler.enableCombineKey_ = true;
4249 handler.isParseConfig_ = false;
4250 ret = handler.PreHandleEvent(key);
4251 ASSERT_TRUE(ret);
4252 handler.isParseConfig_ = true;
4253 handler.isParseMaxCount_ = false;
4254 ret = handler.PreHandleEvent(key);
4255 ASSERT_TRUE(ret);
4256 handler.isParseMaxCount_ = true;
4257 handler.isParseStatusConfig_ = false;
4258 ret = handler.PreHandleEvent(key);
4259 ASSERT_TRUE(ret);
4260 handler.isParseStatusConfig_ = false;
4261 ret = handler.PreHandleEvent(key);
4262 ASSERT_TRUE(ret);
4263 }
4264
4265 /**
4266 * @tc.name: KeyCommandHandlerTest_HandleShortKeys_01
4267 * @tc.desc: Test the funcation HandleShortKeys
4268 * @tc.type: FUNC
4269 * @tc.require:
4270 */
4271 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_HandleShortKeys_01, TestSize.Level1)
4272 {
4273 KeyCommandHandler handler;
4274 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
4275 ASSERT_NE(keyEvent, nullptr);
4276 ShortcutKey shortcutKey;
4277 shortcutKey.preKeys = {2};
4278 shortcutKey.statusConfigValue = true;
4279 shortcutKey.finalKey = 6;
4280 shortcutKey.keyDownDuration = 7;
4281 shortcutKey.triggerType = KeyEvent::KEY_ACTION_DOWN;
4282 shortcutKey.timerId = 10;
4283 handler.shortcutKeys_.insert(std::make_pair("key", shortcutKey));
4284 handler.lastMatchedKey_.finalKey = 1;
4285 handler.lastMatchedKey_.triggerType = KeyEvent::KEY_ACTION_UP;
4286 handler.lastMatchedKey_.preKeys = {3};
4287 keyEvent->SetKeyCode(1);
4288 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP);
4289 KeyEvent::KeyItem item1;
4290 item1.SetKeyCode(3);
4291 item1.SetDownTime(5);
4292 item1.SetDeviceId(8);
4293 KeyEvent::KeyItem item2;
4294 item2.SetKeyCode(3);
4295 item2.SetDownTime(6);
4296 item2.SetDeviceId(4);
4297 keyEvent->AddKeyItem(item1);
4298 keyEvent->AddKeyItem(item2);
4299 bool ret = handler.HandleShortKeys(keyEvent);
4300 ASSERT_TRUE(ret);
4301 handler.lastMatchedKey_.preKeys = {4, 5, 6};
4302 handler.currentLaunchAbilityKey_.timerId = 5;
4303 handler.currentLaunchAbilityKey_.finalKey = 1;
4304 handler.currentLaunchAbilityKey_.triggerType = KeyEvent::KEY_ACTION_UP;
4305 handler.currentLaunchAbilityKey_.preKeys = {3};
4306 EventLogHelper eventLogHelper;
4307 eventLogHelper.userType_ = "beta";
4308 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
4309 EXPECT_NE(inputEvent, nullptr);
4310 inputEvent->bitwise_ = InputEvent::EVENT_FLAG_PRIVACY_MODE;
4311 ret = handler.HandleShortKeys(keyEvent);
4312 ASSERT_TRUE(ret);
4313 eventLogHelper.userType_ = "aaaaaaa";
4314 ret = handler.HandleShortKeys(keyEvent);
4315 ASSERT_TRUE(ret);
4316 inputEvent->bitwise_ = 0;
4317 ret = handler.HandleShortKeys(keyEvent);
4318 ASSERT_TRUE(ret);
4319 }
4320
4321 /**
4322 * @tc.name: KeyCommandHandlerTest_CalcDrawCoordinate_001
4323 * @tc.desc: Test CalcDrawCoordinate
4324 * @tc.type: Function
4325 * @tc.require:
4326 */
4327 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CalcDrawCoordinate_001, TestSize.Level1)
4328 {
4329 CALL_TEST_DEBUG;
4330 KeyCommandHandler handler;
4331 DisplayInfo displayInfo;
4332 PointerEvent::PointerItem pointerItem;
4333 int32_t physicalX = 1;
4334 int32_t physicalY = 1;
4335 pointerItem.SetRawDisplayX(physicalX);
4336 pointerItem.SetRawDisplayY(physicalY);
4337 auto retPair = handler.CalcDrawCoordinate(displayInfo, pointerItem);
4338 EXPECT_EQ(retPair.first, 1);
4339 EXPECT_EQ(retPair.second, 1);
4340 }
4341
4342 /**
4343 * @tc.name: KeyCommandHandlerTest_CalcDrawCoordinate_002
4344 * @tc.desc: Test CalcDrawCoordinate
4345 * @tc.type: Function
4346 * @tc.require:
4347 */
4348 HWTEST_F(KeyCommandHandlerTest, KeyCommandHandlerTest_CalcDrawCoordinate_002, TestSize.Level1)
4349 {
4350 CALL_TEST_DEBUG;
4351 KeyCommandHandler handler;
4352 DisplayInfo displayInfo = {
4353 .id = 0, .x = 0, .y = 0, .width = 100, .height = 200, .dpi = 240,
4354 .transform = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f}
4355 };
4356 PointerEvent::PointerItem pointerItem;
4357 int32_t physicalX = 10;
4358 int32_t physicalY = 10;
4359 pointerItem.SetRawDisplayX(physicalX);
4360 pointerItem.SetRawDisplayY(physicalY);
4361 auto retPair = handler.CalcDrawCoordinate(displayInfo, pointerItem);
4362 EXPECT_EQ(retPair.first, 21);
4363 EXPECT_EQ(retPair.second, 21);
4364 }
4365 } // namespace MMI
4366 } // namespace OHOS