1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <fstream>
17 #include <gtest/gtest.h>
18 
19 #include "key_gesture_manager.h"
20 
21 #include "event_log_helper.h"
22 #include "mmi_log.h"
23 
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "KeyGestureManagerEXTest"
26 
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing;
31 using namespace testing::ext;
32 } // namespace
33 
34 class KeyGestureManagerEXTest : public testing::Test {
35 public:
SetUpTestCase(void)36     static void SetUpTestCase(void) {}
TearDownTestCase(void)37     static void TearDownTestCase(void) {}
38 };
39 
40 class MyKeyGesture : public KeyGestureManager::KeyGesture {
41 public:
42     MyKeyGesture() = default;
43     ~MyKeyGesture() override = default;
44 
45     bool IsWorking() override
46     {
47         return true;
48     }
49 
50     bool ShouldIntercept(std::shared_ptr<KeyOption> keyOption) const override
51     {
52         return true;
53     }
54 
55     bool Intercept(std::shared_ptr<KeyEvent> keyEvent) override
56     {
57         return true;
58     }
59 
60     void Dump(std::ostringstream &output) const override
61     {
62         output << "MyKeyGesture";
63     }
64 };
65 
66 
Function(std::shared_ptr<KeyEvent>)67 void Function(std::shared_ptr<KeyEvent>) {}
68 
69 /**
70  * @tc.name: KeyGestureManagerEXTest_ResetTimer
71  * @tc.desc: Test the funcation ResetTimer
72  * @tc.type: FUNC
73  * @tc.require:
74  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_ResetTimer, TestSize.Level1)75 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_ResetTimer, TestSize.Level1)
76 {
77     CALL_TEST_DEBUG;
78     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
79     KeyGestureManager::Handler keyGestureMgr(1, 10, 500, myCallback);
80     keyGestureMgr.timerId_ = 10;
81     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.ResetTimer());
82     keyGestureMgr.timerId_ = -1;
83     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.ResetTimer());
84 }
85 
86 /**
87  * @tc.name: KeyGestureManagerEXTest_Run
88  * @tc.desc: Test the funcation Run
89  * @tc.type: FUNC
90  * @tc.require:
91  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_Run, TestSize.Level1)92 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_Run, TestSize.Level1)
93 {
94     CALL_TEST_DEBUG;
95     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
96     KeyGestureManager::Handler keyGestureMgr(1, 10, 500, myCallback);
97     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
98     ASSERT_NE(keyEvent, nullptr);
99     keyGestureMgr.callback_ = Function;
100     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.Run(keyEvent));
101     keyGestureMgr.callback_ = nullptr;
102     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.Run(keyEvent));
103 }
104 
105 /**
106  * @tc.name: KeyGestureManagerEXTest_RunPending
107  * @tc.desc: Test the funcation RunPending
108  * @tc.type: FUNC
109  * @tc.require:
110  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RunPending, TestSize.Level1)111 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RunPending, TestSize.Level1)
112 {
113     CALL_TEST_DEBUG;
114     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
115     KeyGestureManager::Handler keyGestureMgr(1, 10, 500, myCallback);
116     keyGestureMgr.keyEvent_ = KeyEvent::Create();
117     ASSERT_NE(keyGestureMgr.keyEvent_, nullptr);
118     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.RunPending());
119     keyGestureMgr.keyEvent_ = nullptr;
120     EXPECT_NO_FATAL_FAILURE(keyGestureMgr.RunPending());
121 }
122 
123 /**
124  * @tc.name: KeyGestureManagerEXTest_RemoveHandler
125  * @tc.desc: Test the funcation RemoveHandler
126  * @tc.type: FUNC
127  * @tc.require:
128  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RemoveHandler, TestSize.Level1)129 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RemoveHandler, TestSize.Level1)
130 {
131     CALL_TEST_DEBUG;
132     std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>();
133     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
134     KeyGestureManager::Handler handler(100, 200, 500, myCallback);
135     myKeyGesture->handlers_.push_back(handler);
136     int32_t id = 1000;
137     EXPECT_FALSE(myKeyGesture->RemoveHandler(id));
138     id = 100;
139     EXPECT_TRUE(myKeyGesture->RemoveHandler(id));
140 }
141 
142 /**
143  * @tc.name: KeyGestureManagerEXTest_RunHandler
144  * @tc.desc: Test the funcation RunHandler
145  * @tc.type: FUNC
146  * @tc.require:
147  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RunHandler, TestSize.Level1)148 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_RunHandler, TestSize.Level1)
149 {
150     CALL_TEST_DEBUG;
151     std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>();
152     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
153     KeyGestureManager::Handler handler(100, 200, 500, myCallback);
154     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
155     ASSERT_NE(keyEvent, nullptr);
156     int32_t handlerId = 1000;
157     myKeyGesture->handlers_.push_back(handler);
158     EXPECT_NO_FATAL_FAILURE(myKeyGesture->RunHandler(handlerId, keyEvent));
159     handlerId = 100;
160     EXPECT_NO_FATAL_FAILURE(myKeyGesture->RunHandler(handlerId, keyEvent));
161 }
162 
163 /**
164  * @tc.name: KeyGestureManagerEXTest_ShowHandlers
165  * @tc.desc: Test the funcation ShowHandlers
166  * @tc.type: FUNC
167  * @tc.require:
168  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_ShowHandlers, TestSize.Level1)169 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_ShowHandlers, TestSize.Level1)
170 {
171     CALL_TEST_DEBUG;
172     std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>();
173     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
174     KeyGestureManager::Handler handler1(100, 1000, 500, myCallback);
175     KeyGestureManager::Handler handler2(200, 2000, 500, myCallback);
176     KeyGestureManager::Handler handler3(300, 3000, 500, myCallback);
177     KeyGestureManager::Handler handler4(400, 4000, 500, myCallback);
178     KeyGestureManager::Handler handler5(500, 5000, 500, myCallback);
179     KeyGestureManager::Handler handler6(600, 6000, 500, myCallback);
180     myKeyGesture->handlers_.push_back(handler1);
181     myKeyGesture->handlers_.push_back(handler2);
182     myKeyGesture->handlers_.push_back(handler3);
183     myKeyGesture->handlers_.push_back(handler4);
184     myKeyGesture->handlers_.push_back(handler5);
185     myKeyGesture->handlers_.push_back(handler6);
186 
187     std::string prefix = "prefix";
188     std::set<int32_t> foregroundPids = { 100, 200 };
189     EXPECT_NO_FATAL_FAILURE(myKeyGesture->ShowHandlers(prefix, foregroundPids));
190 }
191 
192 /**
193  * @tc.name: KeyGestureManagerEXTest_LongPressSingleKey_Intercept
194  * @tc.desc: Test the funcation Intercept
195  * @tc.type: FUNC
196  * @tc.require:
197  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Intercept, TestSize.Level1)198 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Intercept, TestSize.Level1)
199 {
200     CALL_TEST_DEBUG;
201     int32_t keyCode = KeyEvent::KEYCODE_A;
202     KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode);
203     longPressSingleKey.active_ = true;
204     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
205     ASSERT_NE(keyEvent, nullptr);
206     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
207     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
208     EXPECT_TRUE(longPressSingleKey.Intercept(keyEvent));
209     longPressSingleKey.active_ = false;
210     EXPECT_TRUE(longPressSingleKey.Intercept(keyEvent));
211 }
212 
213 /**
214  * @tc.name: KeyGestureManagerEXTest_LongPressSingleKey_Intercept_001
215  * @tc.desc: Test the funcation Intercept
216  * @tc.type: FUNC
217  * @tc.require:
218  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Intercept_001, TestSize.Level1)219 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Intercept_001, TestSize.Level1)
220 {
221     CALL_TEST_DEBUG;
222     int32_t keyCode = KeyEvent::KEYCODE_A;
223     KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode);
224     longPressSingleKey.active_ = true;
225     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
226     ASSERT_NE(keyEvent, nullptr);
227     keyEvent->SetKeyCode(KeyEvent::KEYCODE_B);
228     EXPECT_FALSE(longPressSingleKey.Intercept(keyEvent));
229     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
230     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
231     longPressSingleKey.active_ = false;
232     EXPECT_FALSE(longPressSingleKey.Intercept(keyEvent));
233 }
234 
235 /**
236  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Intercept
237  * @tc.desc: Test the funcation Intercept
238  * @tc.type: FUNC
239  * @tc.require:
240  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept, TestSize.Level1)241 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept, TestSize.Level1)
242 {
243     CALL_TEST_DEBUG;
244     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
245     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
246 
247     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
248     ASSERT_NE(keyEvent, nullptr);
249     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
250     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
251     keyEvent->bitwise_ = 0x00000000;
252     longPressCombinationKey.active_ = true;
253     EXPECT_TRUE(longPressCombinationKey.Intercept(keyEvent));
254 }
255 
256 /**
257  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_001
258  * @tc.desc: Test the funcation Intercept
259  * @tc.type: FUNC
260  * @tc.require:
261  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_001, TestSize.Level1)262 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_001, TestSize.Level1)
263 {
264     CALL_TEST_DEBUG;
265     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
266     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
267 
268     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
269     ASSERT_NE(keyEvent, nullptr);
270     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
271     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
272     keyEvent->bitwise_ = 0x00000000;
273     longPressCombinationKey.active_ = false;
274     EXPECT_FALSE(longPressCombinationKey.Intercept(keyEvent));
275 }
276 
277 /**
278  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_002
279  * @tc.desc: Test the funcation Intercept
280  * @tc.type: FUNC
281  * @tc.require:
282  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_002, TestSize.Level1)283 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_002, TestSize.Level1)
284 {
285     CALL_TEST_DEBUG;
286     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
287     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
288     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
289     KeyGestureManager::Handler handler1(1, 10, 500, myCallback);
290 
291     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
292     ASSERT_NE(keyEvent, nullptr);
293     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
294     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
295     longPressCombinationKey.handlers_.push_back(handler1);
296     longPressCombinationKey.active_ = false;
297     EXPECT_FALSE(longPressCombinationKey.Intercept(keyEvent));
298 }
299 
300 /**
301  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_003
302  * @tc.desc: Test the funcation Intercept
303  * @tc.type: FUNC
304  * @tc.require:
305  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_003, TestSize.Level1)306 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_003, TestSize.Level1)
307 {
308     CALL_TEST_DEBUG;
309     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
310     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
311 
312     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
313     ASSERT_NE(keyEvent, nullptr);
314     keyEvent->SetKeyCode(KeyEvent::KEYCODE_D);
315     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
316     longPressCombinationKey.active_ = true;
317     EXPECT_FALSE(longPressCombinationKey.Intercept(keyEvent));
318 }
319 
320 /**
321  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_004
322  * @tc.desc: Test the funcation Intercept
323  * @tc.type: FUNC
324  * @tc.require:
325  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_004, TestSize.Level1)326 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Intercept_004, TestSize.Level1)
327 {
328     CALL_TEST_DEBUG;
329     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
330     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
331 
332     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
333     ASSERT_NE(keyEvent, nullptr);
334     keyEvent->SetKeyCode(KeyEvent::KEYCODE_A);
335     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
336     longPressCombinationKey.active_ = false;
337     EXPECT_FALSE(longPressCombinationKey.Intercept(keyEvent));
338 }
339 
340 /**
341  * @tc.name: KeyGestureManagerEXTest_LongPressSingleKey_Dump
342  * @tc.desc: Test the funcation LongPressSingleKey_Dump
343  * @tc.type: FUNC
344  * @tc.require:
345  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Dump, TestSize.Level1)346 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Dump, TestSize.Level1)
347 {
348     CALL_TEST_DEBUG;
349     int32_t keyCode = KeyEvent::KEYCODE_A;
350     KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode);
351     std::ostringstream output;
352     EXPECT_NO_FATAL_FAILURE(longPressSingleKey.Dump(output));
353 }
354 
355 /**
356  * @tc.name: KeyGestureManagerEXTest_LongPressSingleKey_Dump_001
357  * @tc.desc: Test the funcation LongPressSingleKey_Dump
358  * @tc.type: FUNC
359  * @tc.require:
360  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Dump_001, TestSize.Level1)361 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressSingleKey_Dump_001, TestSize.Level1)
362 {
363     CALL_TEST_DEBUG;
364     int32_t keyCode = KeyEvent::KEYCODE_A;
365     KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode);
366     std::ostringstream output;
367     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
368     KeyGestureManager::Handler handler1(1, 10, 500, myCallback);
369     KeyGestureManager::Handler handler2(2, 20, 1000, myCallback);
370     longPressSingleKey.handlers_.push_back(handler1);
371     longPressSingleKey.handlers_.push_back(handler2);
372     EXPECT_NO_FATAL_FAILURE(longPressSingleKey.Dump(output));
373 }
374 
375 /**
376  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Dump
377  * @tc.desc: Test the funcation LongPressCombinationKey_Dump
378  * @tc.type: FUNC
379  * @tc.require:
380  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Dump, TestSize.Level1)381 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Dump, TestSize.Level1)
382 {
383     CALL_TEST_DEBUG;
384     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
385     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
386 
387     std::function<void(std::shared_ptr<KeyEvent>)> myCallback;
388     KeyGestureManager::Handler handler1(1, 10, 500, myCallback);
389     KeyGestureManager::Handler handler2(2, 20, 1000, myCallback);
390     longPressCombinationKey.handlers_.push_back(handler1);
391     longPressCombinationKey.handlers_.push_back(handler2);
392     std::ostringstream output;
393     EXPECT_NO_FATAL_FAILURE(longPressCombinationKey.Dump(output));
394 }
395 
396 /**
397  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_Dump_001
398  * @tc.desc: Test the funcation LongPressCombinationKey_Dump
399  * @tc.type: FUNC
400  * @tc.require:
401  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Dump_001, TestSize.Level1)402 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_Dump_001, TestSize.Level1)
403 {
404     CALL_TEST_DEBUG;
405     std::set<int32_t> keys = {};
406     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
407     std::ostringstream output;
408     EXPECT_NO_FATAL_FAILURE(longPressCombinationKey.Dump(output));
409 }
410 
411 /**
412  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture
413  * @tc.desc: Test the funcation LongPressCombinationKey_RecognizeGesture
414  * @tc.type: FUNC
415  * @tc.require:
416  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture, TestSize.Level1)417 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture, TestSize.Level1)
418 {
419     CALL_TEST_DEBUG;
420     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
421     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
422     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
423     ASSERT_NE(keyEvent, nullptr);
424     KeyEvent::KeyItem item;
425     item.SetPressed(true);
426     item.SetKeyCode(KeyEvent::KEYCODE_A);
427     keyEvent->AddKeyItem(item);
428     EXPECT_NO_FATAL_FAILURE(longPressCombinationKey.RecognizeGesture(keyEvent));
429 }
430 
431 /**
432  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture_01
433  * @tc.desc: Test the funcation LongPressCombinationKey_RecognizeGesture
434  * @tc.type: FUNC
435  * @tc.require:
436  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture_01, TestSize.Level1)437 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_RecognizeGesture_01, TestSize.Level1)
438 {
439     CALL_TEST_DEBUG;
440     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
441     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
442     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
443     ASSERT_NE(keyEvent, nullptr);
444     KeyEvent::KeyItem item;
445     item.SetPressed(true);
446     item.SetKeyCode(KeyEvent::KEYCODE_A);
447     keyEvent->AddKeyItem(item);
448     item.SetPressed(true);
449     item.SetKeyCode(KeyEvent::KEYCODE_B);
450     keyEvent->AddKeyItem(item);
451     EXPECT_NO_FATAL_FAILURE(longPressCombinationKey.RecognizeGesture(keyEvent));
452 }
453 
454 /**
455  * @tc.name: KeyGestureManagerEXTest_LongPressCombinationKey_TriggerAll
456  * @tc.desc: Test the funcation LongPressCombinationKey_TriggerAll
457  * @tc.type: FUNC
458  * @tc.require:
459  */
HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_TriggerAll, TestSize.Level1)460 HWTEST_F(KeyGestureManagerEXTest, KeyGestureManagerEXTest_LongPressCombinationKey_TriggerAll, TestSize.Level1)
461 {
462     CALL_TEST_DEBUG;
463     std::set<int32_t> keys = { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B, KeyEvent::KEYCODE_C };
464     KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys);
465     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
466     ASSERT_NE(keyEvent, nullptr);
467     keyEvent->bitwise_ = 0x00000000;
468     EXPECT_NO_FATAL_FAILURE(longPressCombinationKey.TriggerAll(keyEvent));
469 }
470 } // namespace MMI
471 } // namespace OHOS
472