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