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 "accessibility_common_helper.h"
18 #include "accessibility_input_interceptor.h"
19 #include "accessibility_ut_helper.h"
20 #include "accessible_ability_manager_service.h"
21 #include "iservice_registry.h"
22 #include "mock_accessible_ability_manager_service.h"
23 #include "mock_bundle_manager.h"
24 #include "mock_input_manager.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Accessibility {
31 namespace {
32 constexpr uint32_t SLEEP_TIME_3 = 3;
33 } // namespace
34
35 class AccessibilityInputInterceptorTest : public testing::Test {
36 public:
AccessibilityInputInterceptorTest()37 AccessibilityInputInterceptorTest()
38 {}
~AccessibilityInputInterceptorTest()39 ~AccessibilityInputInterceptorTest()
40 {}
41
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46
47 sptr<AccessibilityInputInterceptor> inputInterceptor_ = nullptr;
48 };
49
SetUpTestCase()50 void AccessibilityInputInterceptorTest::SetUpTestCase()
51 {
52 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest SetUpTestCase";
53 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
54 }
55
TearDownTestCase()56 void AccessibilityInputInterceptorTest::TearDownTestCase()
57 {
58 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest TearDownTestCase";
59 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
60 }
61
SetUp()62 void AccessibilityInputInterceptorTest::SetUp()
63 {
64 MMI::MockInputManager::ClearInputEventConsumer();
65 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest SetUp";
66 inputInterceptor_ = AccessibilityInputInterceptor::GetInstance();
67 }
68
TearDown()69 void AccessibilityInputInterceptorTest::TearDown()
70 {
71 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest TearDown";
72 inputInterceptor_ = nullptr;
73 }
74
75 /**
76 * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001
77 * @tc.name: SetAvailableFunctions
78 * @tc.desc: Check the set available Functions.
79 */
80 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001,
81 TestSize.Level1)
82 {
83 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 start";
84
85 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_FILTER_KEY_EVENTS;
86 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 94";
87 inputInterceptor_->SetAvailableFunctions(availableFunctions);
88
89 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions001 end";
90 }
91
92 /**
93 * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002
94 * @tc.name: SetAvailableFunctions
95 * @tc.desc: Check the set available Functions.
96 */
97 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002,
98 TestSize.Level1)
99 {
100 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002 start";
101
102 uint32_t availableFunctions2 = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
103 inputInterceptor_->SetAvailableFunctions(availableFunctions2);
104
105 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions002 end";
106 }
107
108 /**
109 * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003
110 * @tc.name: SetAvailableFunctions
111 * @tc.desc: Check the set available Functions.
112 */
113 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003,
114 TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003 start";
117
118 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
119
120 inputInterceptor_->SetAvailableFunctions(availableFunctions);
121
122 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions003 end";
123 }
124
125 /**
126 * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004
127 * @tc.name: SetAvailableFunctions
128 * @tc.desc: Check the set available Functions.
129 */
130 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004,
131 TestSize.Level1)
132 {
133 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004 start";
134 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION;
135 inputInterceptor_->SetAvailableFunctions(availableFunctions);
136
137 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions004 end";
138 }
139
140 /**
141 * @tc.number: AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005
142 * @tc.name: SetAvailableFunctions
143 * @tc.desc: Check the set available Functions.
144 */
145 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005,
146 TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005 start";
149 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION |
150 AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK |
151 AccessibilityInputInterceptor::FEATURE_SHORT_KEY |
152 AccessibilityInputInterceptor::FEATURE_MOUSE_KEY;
153 inputInterceptor_->SetAvailableFunctions(availableFunctions);
154
155 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_SetAvailableFunctions005 end";
156 }
157
158 /**
159 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001
160 * @tc.name: OnTouchEvent
161 * @tc.desc: Check the on touch event.
162 */
163 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001 start";
166
167 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
168 inputInterceptor_->OnPointerEvent(*event);
169
170 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001 end";
171 }
172
173 /**
174 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002
175 * @tc.name: InterceptPointerEventCallBack
176 * @tc.desc: Check the on touch event.
177 */
178 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002, TestSize.Level1)
179 {
180 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 start";
181 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
182 inputInterceptor_->SetAvailableFunctions(availableFunctions);
183
184 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
185 MMI::PointerEvent::PointerItem item = {};
186
187 item.SetPointerId(1);
188 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
189 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
190 event->AddPointerItem(item);
191
192 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
193 if (inputEventConsumer != nullptr) {
194 inputEventConsumer->OnInputEvent(event);
195 }
196 /* wait ProcessTouchEvent */
197 sleep(SLEEP_TIME_3);
198
199 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 end";
200 }
201
202 /**
203 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003
204 * @tc.name: InterceptPointerEventCallBack
205 * @tc.desc: Check the on touch event.
206 */
207 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 start";
210 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
211 inputInterceptor_->SetAvailableFunctions(availableFunctions);
212
213 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
214 MMI::PointerEvent::PointerItem item = {};
215
216 item.SetPointerId(1);
217 item.SetDisplayX(1);
218 item.SetDisplayY(1);
219 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
220 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
221 event->AddPointerItem(item);
222
223 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
224 if (inputEventConsumer != nullptr) {
225 inputEventConsumer->OnInputEvent(event);
226 }
227 /* wait ProcessTouchEvent */
228 sleep(SLEEP_TIME_3);
229
230 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 end";
231 }
232
233 /**
234 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1
235 * @tc.name: OnMouseEvent
236 * @tc.desc: Check the on mouse event.
237 */
238 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1, TestSize.Level1)
239 {
240 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 start";
241
242 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
243 MMI::PointerEvent::PointerItem item = {};
244
245 item.SetPointerId(1);
246 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
247 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
248 event->AddPointerItem(item);
249
250 inputInterceptor_->OnPointerEvent(*event);
251 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 end";
252 }
253
254 /**
255 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002
256 * @tc.name: InterceptPointerEventCallBack
257 * @tc.desc: Check the on mouse event.
258 */
259 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002, TestSize.Level1)
260 {
261 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 start";
262 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
263 inputInterceptor_->SetAvailableFunctions(availableFunctions);
264
265 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
266 MMI::PointerEvent::PointerItem item = {};
267
268 item.SetPointerId(1);
269 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
270 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
271 event->AddPointerItem(item);
272
273 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
274 if (inputEventConsumer != nullptr) {
275 inputEventConsumer->OnInputEvent(event);
276 }
277 /* wait ProcessMouseEvent */
278 sleep(SLEEP_TIME_3);
279
280 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 end";
281 }
282
283 /**
284 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003
285 * @tc.name: OnInputEvent
286 * @tc.desc: Check the on mouse event.
287 */
288 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003, TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 start";
291 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
292 inputInterceptor_->SetAvailableFunctions(availableFunctions);
293
294 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
295 MMI::PointerEvent::PointerItem item = {};
296
297 item.SetPointerId(1);
298 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
299 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
300 event->AddPointerItem(item);
301
302 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
303 if (inputEventConsumer != nullptr) {
304 inputEventConsumer->OnInputEvent(event);
305 }
306 /* wait ProcessMouseEvent */
307 sleep(SLEEP_TIME_3);
308
309 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 end";
310 }
311
312 /**
313 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001
314 * @tc.name: OnKeyEvent
315 * @tc.desc: Check the on key event.
316 */
317 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 start";
320
321 std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
322 inputInterceptor_->OnKeyEvent(*event);
323
324 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 end";
325 }
326
327 /**
328 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002
329 * @tc.name: OnInputEvent
330 * @tc.desc: Check the on key event.
331 */
332 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002, TestSize.Level1)
333 {
334 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 start";
335
336 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
337 MMI::KeyEvent::KeyItem item = {};
338
339 item.SetPressed(true);
340 keyEvent->AddKeyItem(item);
341 keyEvent->SetKeyCode(1);
342
343 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
344 if (inputEventConsumer != nullptr) {
345 inputEventConsumer->OnInputEvent(keyEvent);
346 }
347
348 /* wait ProcessKeyEvent */
349 sleep(SLEEP_TIME_3);
350
351 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 end";
352 }
353
354 /**
355 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003
356 * @tc.name: OnKeyEvent
357 * @tc.desc: Check the on key event.
358 */
359 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 start";
362 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_FILTER_KEY_EVENTS;
363 inputInterceptor_->SetAvailableFunctions(availableFunctions);
364
365 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
366 MMI::KeyEvent::KeyItem item = {};
367
368 item.SetPressed(true);
369 keyEvent->AddKeyItem(item);
370 keyEvent->SetKeyCode(1);
371
372 /* wait ProcessKeyEvent */
373 sleep(SLEEP_TIME_3);
374
375 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 end";
376 }
377
378 /**
379 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001
380 * @tc.name: OnMoveMouse
381 * @tc.desc: Check the OnMoveMouse.
382 */
383 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001,
384 TestSize.Level1)
385 {
386 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 start";
387 if (!inputInterceptor_) {
388 return;
389 }
390 inputInterceptor_->OnMoveMouse(1, 1);
391
392 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 end";
393 }
394 } // namespace Accessibility
395 } // namespace OHOS