1 /*
2  * Copyright (C) 2022 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 #include <map>
18 #include <memory>
19 #include "accessibility_mouse_key.h"
20 #include "accessibility_ut_helper.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace Accessibility {
27 class AccessibilityMouseKeyUnitTest : public ::testing::Test {
28 public:
AccessibilityMouseKeyUnitTest()29     AccessibilityMouseKeyUnitTest()
30     {}
~AccessibilityMouseKeyUnitTest()31     ~AccessibilityMouseKeyUnitTest()
32     {}
33 
34     static void SetUpTestCase();
35     static void TearDownTestCase();
36     void OnKeyEventPresss(MMI::KeyEvent &event, const int32_t keycode);
37     void SetUp() override;
38     void TearDown() override;
39 
40     std::shared_ptr<AccessibilityMouseKey> mouseKey_ = nullptr;
41 };
42 
SetUpTestCase()43 void AccessibilityMouseKeyUnitTest::SetUpTestCase()
44 {
45     GTEST_LOG_(INFO) << "###################### AccessibilityMouseKeyUnitTest Start ######################";
46 }
47 
TearDownTestCase()48 void AccessibilityMouseKeyUnitTest::TearDownTestCase()
49 {
50     GTEST_LOG_(INFO) << "###################### AccessibilityMouseKeyUnitTest End ######################";
51 }
52 
SetUp()53 void AccessibilityMouseKeyUnitTest::SetUp()
54 {
55     GTEST_LOG_(INFO) << "SetUp";
56     mouseKey_ = std::make_shared<AccessibilityMouseKey>();
57 }
58 
TearDown()59 void AccessibilityMouseKeyUnitTest::TearDown()
60 {
61     GTEST_LOG_(INFO) << "TearDown";
62     mouseKey_ = nullptr;
63 }
64 
OnKeyEventPresss(MMI::KeyEvent & event,const int32_t keycode)65 void AccessibilityMouseKeyUnitTest::OnKeyEventPresss(MMI::KeyEvent &event, const int32_t keycode)
66 {
67     // presss
68     event.SetKeyCode(keycode);
69     MMI::KeyEvent::KeyItem item;
70     item.SetKeyCode(keycode);
71     item.SetPressed(true);
72     event.AddKeyItem(item);
73     mouseKey_->OnKeyEvent(event);
74     event.RemoveReleasedKeyItems(item);
75 }
76 
77 /**
78  * @tc.number: AccessibilityMouseKey_Unittest_OnPointerEvent_001
79  * @tc.name: OnPointerEvent
80  * @tc.desc: Test function OnPointerEvent
81  * @tc.require: issueI5NTXA
82  */
83 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnPointerEvent_001, TestSize.Level1)
84 {
85     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_001 start";
86     if (!mouseKey_) {
87         return;
88     }
89     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
90     if (!event) {
91         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_001 event is null";
92         return;
93     }
94     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
95     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
96     MMI::PointerEvent::PointerItem item;
97     event->AddPointerItem(item);
98     mouseKey_->OnPointerEvent(*event);
99     EXPECT_NE(event.get(), nullptr);
100     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_001 end";
101 }
102 
103 /**
104  * @tc.number: AccessibilityMouseKey_Unittest_OnPointerEvent_002
105  * @tc.name: OnPointerEvent
106  * @tc.desc: Test function OnPointerEvent
107  * @tc.require: issueI5NTXA
108  */
109 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnPointerEvent_002, TestSize.Level1)
110 {
111     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_002 start";
112     if (!mouseKey_) {
113         return;
114     }
115     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
116     if (!event) {
117         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_002 event is null";
118         return;
119     }
120     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
121     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
122     MMI::PointerEvent::PointerItem item;
123     event->AddPointerItem(item);
124     mouseKey_->OnPointerEvent(*event);
125     EXPECT_NE(event.get(), nullptr);
126     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnPointerEvent_002 end";
127 }
128 
129 /**
130  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_001
131  * @tc.name: OnKeyEvent
132  * @tc.desc: Test function OnKeyEvent(1~4,6~9 key down)
133  * @tc.require: issueI5NTXA
134  */
135 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_001, TestSize.Level1)
136 {
137     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_001 start";
138     if (!mouseKey_) {
139         return;
140     }
141     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
142     if (!event) {
143         return;
144     }
145     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
146     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_1);
147     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_2);
148     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_3);
149     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_4);
150     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_6);
151     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_7);
152     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_8);
153     OnKeyEventPresss(*event, MMI::KeyEvent::KEYCODE_NUMPAD_9);
154 
155     EXPECT_NE(event.get(), nullptr);
156     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_001 end";
157 }
158 
159 /**
160  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_002
161  * @tc.name: OnKeyEvent
162  * @tc.desc: Test function OnKeyEvent(1 key up)
163  * @tc.require: issueI5NTXA
164  */
165 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_002, TestSize.Level1)
166 {
167     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_002 start";
168     if (!mouseKey_) {
169         return;
170     }
171     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
172     if (!event) {
173         return;
174     }
175     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
176     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
177     MMI::KeyEvent::KeyItem item;
178     item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
179     event->AddKeyItem(item);
180     mouseKey_->OnKeyEvent(*event);
181     EXPECT_NE(event.get(), nullptr);
182     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_002 end";
183 }
184 
185 /**
186  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_003
187  * @tc.name: OnKeyEvent
188  * @tc.desc: Test function OnKeyEvent(press '/', '5' key)
189  * @tc.require: issueI5NTXA
190  */
191 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_003, TestSize.Level1)
192 {
193     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_003 start";
194     if (!mouseKey_) {
195         return;
196     }
197     // mouse event
198     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
199     if (!event) {
200         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_003 event is null";
201         return;
202     }
203     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
204     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
205     MMI::PointerEvent::PointerItem item;
206     event->AddPointerItem(item);
207     mouseKey_->OnPointerEvent(*event);
208 
209     // press '/' key
210     std::shared_ptr<MMI::KeyEvent> event3 = MMI::KeyEvent::Create();
211     if (!event3) {
212         return;
213     }
214     event3->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
215     event3->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
216     MMI::KeyEvent::KeyItem item1;
217     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
218     item1.SetPressed(true);
219     event3->AddKeyItem(item1);
220     mouseKey_->OnKeyEvent(*event3);
221 
222     // press '5' key
223     std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
224     if (!event2) {
225         return;
226     }
227     event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
228     event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
229     MMI::KeyEvent::KeyItem item3;
230     item3.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
231     item3.SetPressed(true);
232     event2->AddKeyItem(item3);
233     AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
234     mouseKey_->OnKeyEvent(*event2);
235     int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
236     int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
237     EXPECT_EQ(touchAction, expectValue);
238     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_003 end";
239 }
240 
241 /**
242  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_004
243  * @tc.name: OnKeyEvent
244  * @tc.desc: Test function OnKeyEvent(press '-', '5' key)
245  * @tc.require: issueI5NTXA
246  */
247 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_004, TestSize.Level1)
248 {
249     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_004 start";
250     if (!mouseKey_) {
251         return;
252     }
253     // mouse event
254     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
255     if (!event) {
256         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_004 event is null";
257         return;
258     }
259     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
260     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
261     MMI::PointerEvent::PointerItem item;
262     event->AddPointerItem(item);
263     mouseKey_->OnPointerEvent(*event);
264 
265     // press '-' key
266     std::shared_ptr<MMI::KeyEvent> event4 = MMI::KeyEvent::Create();
267     if (!event4) {
268         return;
269     }
270     event4->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_SUBTRACT);
271     event4->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
272     MMI::KeyEvent::KeyItem item1;
273     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_SUBTRACT);
274     item1.SetPressed(true);
275     event4->AddKeyItem(item1);
276     mouseKey_->OnKeyEvent(*event4);
277 
278     // press '5' key
279     std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
280     if (!event2) {
281         return;
282     }
283     event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
284     event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
285     MMI::KeyEvent::KeyItem item4;
286     item4.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
287     item4.SetPressed(true);
288     event2->AddKeyItem(item4);
289     AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
290     mouseKey_->OnKeyEvent(*event2);
291     int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
292     int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
293     EXPECT_EQ(touchAction, expectValue);
294     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_004 end";
295 }
296 
297 /**
298  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_005
299  * @tc.name: OnKeyEvent
300  * @tc.desc: Test function OnKeyEvent(press '*', '5' key)
301  * @tc.require: issueI5NTXA
302  */
303 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_005, TestSize.Level1)
304 {
305     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_005 start";
306     if (!mouseKey_) {
307         return;
308     }
309     // mouse event
310     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
311     if (!event) {
312         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_005 event is null";
313         return;
314     }
315     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
316     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
317     MMI::PointerEvent::PointerItem item;
318     event->AddPointerItem(item);
319     mouseKey_->OnPointerEvent(*event);
320 
321     // press '*' key
322     std::shared_ptr<MMI::KeyEvent> event5 = MMI::KeyEvent::Create();
323     if (!event5) {
324         return;
325     }
326     event5->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_MULTIPLY);
327     event5->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
328     MMI::KeyEvent::KeyItem item1;
329     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_MULTIPLY);
330     item1.SetPressed(true);
331     event5->AddKeyItem(item1);
332     mouseKey_->OnKeyEvent(*event5);
333 
334     // press '5' key
335     std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
336     if (!event2) {
337         return;
338     }
339     event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
340     event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
341     MMI::KeyEvent::KeyItem item5;
342     item5.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_5);
343     item5.SetPressed(true);
344     event2->AddKeyItem(item5);
345     AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
346     mouseKey_->OnKeyEvent(*event2);
347     int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
348     int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
349     EXPECT_EQ(touchAction, expectValue);
350     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_005 end";
351 }
352 
353 /**
354  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_006
355  * @tc.name: OnKeyEvent
356  * @tc.desc: Test function OnKeyEvent(press '/', '+' key)
357  * @tc.require: issueI5NTXA
358  */
359 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_006, TestSize.Level1)
360 {
361     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_006 start";
362     if (!mouseKey_) {
363         return;
364     }
365     // mouse event
366     std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
367     if (!event) {
368         GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_006 event is null";
369         return;
370     }
371     event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
372     event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
373     MMI::PointerEvent::PointerItem item;
374     event->AddPointerItem(item);
375     mouseKey_->OnPointerEvent(*event);
376 
377     // press '/' key
378     std::shared_ptr<MMI::KeyEvent> event6 = MMI::KeyEvent::Create();
379     if (!event6) {
380         return;
381     }
382     event6->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
383     event6->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
384     MMI::KeyEvent::KeyItem item1;
385     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_DIVIDE);
386     item1.SetPressed(true);
387     event6->AddKeyItem(item1);
388     mouseKey_->OnKeyEvent(*event6);
389 
390     // press '+' key
391     std::shared_ptr<MMI::KeyEvent> event2 = MMI::KeyEvent::Create();
392     if (!event2) {
393         return;
394     }
395     event2->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_ADD);
396     event2->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
397     MMI::KeyEvent::KeyItem item2;
398     item2.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_ADD);
399     item2.SetPressed(true);
400     event2->AddKeyItem(item2);
401     AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
402     mouseKey_->OnKeyEvent(*event2);
403     int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
404     int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN;
405     EXPECT_EQ(touchAction, expectValue);
406     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_006 end";
407 }
408 
409 /**
410  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_007
411  * @tc.name: OnKeyEvent
412  * @tc.desc: Test function OnKeyEvent(press 1->left shift in same time)
413  * @tc.require: issueI5NTXA
414  */
415 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_007, TestSize.Level1)
416 {
417     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_007 start";
418     if (!mouseKey_) {
419         return;
420     }
421     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
422     if (!event) {
423         return;
424     }
425     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
426     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
427     // presss 1
428     MMI::KeyEvent::KeyItem item;
429     item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
430     item.SetPressed(true);
431     event->AddKeyItem(item);
432     // presss left shift
433     MMI::KeyEvent::KeyItem item1;
434     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
435     item1.SetPressed(true);
436     event->AddKeyItem(item1);
437     mouseKey_->OnKeyEvent(*event);
438     EXPECT_NE(event.get(), nullptr);
439     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_007 end";
440 }
441 
442 /**
443  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_008
444  * @tc.name: OnKeyEvent
445  * @tc.desc: Test function OnKeyEvent(press left crtl->2 in same time)
446  * @tc.require: issueI5NTXA
447  */
448 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_008, TestSize.Level1)
449 {
450     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_008 start";
451     if (!mouseKey_) {
452         return;
453     }
454     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
455     if (!event) {
456         return;
457     }
458     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
459     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
460     // presss left ctrl
461     MMI::KeyEvent::KeyItem item;
462     item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
463     item.SetPressed(true);
464     event->AddKeyItem(item);
465     // presss 2
466     MMI::KeyEvent::KeyItem item1;
467     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_2);
468     item1.SetPressed(true);
469     event->AddKeyItem(item1);
470     mouseKey_->OnKeyEvent(*event);
471     EXPECT_NE(event.get(), nullptr);
472     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_008 end";
473 }
474 
475 /**
476  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_009
477  * @tc.name: OnKeyEvent
478  * @tc.desc: Test function OnKeyEvent(press 3->left shift->right shift in same time)
479  * @tc.require: issueI5NTXA
480  */
481 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_009, TestSize.Level1)
482 {
483     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_009 start";
484     if (!mouseKey_) {
485         return;
486     }
487     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
488     if (!event) {
489         return;
490     }
491     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
492     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
493     // presss 1
494     MMI::KeyEvent::KeyItem item;
495     item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_3);
496     item.SetPressed(true);
497     event->AddKeyItem(item);
498     // presss left shift
499     MMI::KeyEvent::KeyItem item1;
500     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_LEFT);
501     item1.SetPressed(true);
502     event->AddKeyItem(item1);
503     // presss right shift
504     MMI::KeyEvent::KeyItem item2;
505     item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
506     item2.SetPressed(true);
507     event->AddKeyItem(item2);
508     mouseKey_->OnKeyEvent(*event);
509     EXPECT_NE(event.get(), nullptr);
510     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_009 end";
511 }
512 
513 /**
514  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_010
515  * @tc.name: OnKeyEvent
516  * @tc.desc: Test function OnKeyEvent(press left ctrl->4->right ctrl in same time)
517  * @tc.require: issueI5NTXA
518  */
519 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_010, TestSize.Level1)
520 {
521     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_010 start";
522     if (!mouseKey_) {
523         return;
524     }
525     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
526     if (!event) {
527         return;
528     }
529     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
530     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
531     // presss left ctrl
532     MMI::KeyEvent::KeyItem item;
533     item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
534     item.SetPressed(true);
535     event->AddKeyItem(item);
536     // presss 4
537     MMI::KeyEvent::KeyItem item1;
538     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_4);
539     item1.SetPressed(true);
540     event->AddKeyItem(item1);
541     // presss right ctrl
542     MMI::KeyEvent::KeyItem item2;
543     item2.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_RIGHT);
544     item2.SetPressed(true);
545     event->AddKeyItem(item2);
546     mouseKey_->OnKeyEvent(*event);
547     EXPECT_NE(event.get(), nullptr);
548     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_010 end";
549 }
550 
551 /**
552  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_011
553  * @tc.name: OnKeyEvent
554  * @tc.desc: Test function OnKeyEvent(press left ctrl->6->right shift in same time)
555  * @tc.require: issueI5NTXA
556  */
557 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_011, TestSize.Level1)
558 {
559     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_011 start";
560     if (!mouseKey_) {
561         return;
562     }
563     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
564     if (!event) {
565         return;
566     }
567     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
568     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
569     // presss left ctrl
570     MMI::KeyEvent::KeyItem item;
571     item.SetKeyCode(MMI::KeyEvent::KEYCODE_CTRL_LEFT);
572     item.SetPressed(true);
573     event->AddKeyItem(item);
574     // presss 4
575     MMI::KeyEvent::KeyItem item1;
576     item1.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_6);
577     item1.SetPressed(true);
578     event->AddKeyItem(item1);
579     // presss right shift
580     MMI::KeyEvent::KeyItem item2;
581     item2.SetKeyCode(MMI::KeyEvent::KEYCODE_SHIFT_RIGHT);
582     item2.SetPressed(true);
583     event->AddKeyItem(item2);
584     mouseKey_->OnKeyEvent(*event);
585     EXPECT_NE(event.get(), nullptr);
586     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_011 end";
587 }
588 
589 /**
590  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_012
591  * @tc.name: OnKeyEvent
592  * @tc.desc: Test function OnKeyEvent(ParseMataKey return false)
593  * @tc.require: issueI5NTXA
594  */
595 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_012, TestSize.Level1)
596 {
597     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_012 start";
598     if (!mouseKey_) {
599         return;
600     }
601     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
602     if (!event) {
603         return;
604     }
605     event->SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
606     event->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
607     MMI::KeyEvent::KeyItem item;
608     item.SetKeyCode(MMI::KeyEvent::KEYCODE_NUMPAD_1);
609     event->AddKeyItem(item);
610     EXPECT_EQ(false, mouseKey_->OnKeyEvent(*event));
611     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_012 end";
612 }
613 
614 /**
615  * @tc.number: AccessibilityMouseKey_Unittest_OnKeyEvent_013
616  * @tc.name: OnKeyEvent
617  * @tc.desc: Test function OnKeyEvent(No mouse event to be sent)
618  * @tc.require: issueI5NTXA
619  */
620 HWTEST_F(AccessibilityMouseKeyUnitTest, AccessibilityMouseKey_Unittest_OnKeyEvent_013, TestSize.Level1)
621 {
622     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_013 start";
623     if (!mouseKey_) {
624         return;
625     }
626     std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
627     if (!event) {
628         return;
629     }
630     MMI::KeyEvent::KeyItem item;
631     event->AddKeyItem(item);
632     AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
633     mouseKey_->OnKeyEvent(*event);
634     GTEST_LOG_(INFO) << "AccessibilityMouseKey_Unittest_OnKeyEvent_013 end";
635 }
636 } // namespace Accessibility
637 } // namespace OHOS