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