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 EXPECT_NE(event.get(), nullptr);
171 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent001 end";
172 }
173
174 /**
175 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002
176 * @tc.name: InterceptPointerEventCallBack
177 * @tc.desc: Check the on touch event.
178 */
179 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002, TestSize.Level1)
180 {
181 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 start";
182 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
183 inputInterceptor_->SetAvailableFunctions(availableFunctions);
184
185 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
186 MMI::PointerEvent::PointerItem item = {};
187
188 item.SetPointerId(1);
189 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
190 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
191 event->AddPointerItem(item);
192
193 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
194 if (inputEventConsumer != nullptr) {
195 inputEventConsumer->OnInputEvent(event);
196 }
197 /* wait ProcessTouchEvent */
198 sleep(SLEEP_TIME_3);
199 EXPECT_NE(event.get(), nullptr);
200 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent002 end";
201 }
202
203 /**
204 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003
205 * @tc.name: InterceptPointerEventCallBack
206 * @tc.desc: Check the on touch event.
207 */
208 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003, TestSize.Level1)
209 {
210 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 start";
211 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
212 inputInterceptor_->SetAvailableFunctions(availableFunctions);
213
214 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
215 MMI::PointerEvent::PointerItem item = {};
216
217 item.SetPointerId(1);
218 item.SetDisplayX(1);
219 item.SetDisplayY(1);
220 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
221 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
222 event->AddPointerItem(item);
223
224 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
225 if (inputEventConsumer != nullptr) {
226 inputEventConsumer->OnInputEvent(event);
227 }
228 /* wait ProcessTouchEvent */
229 sleep(SLEEP_TIME_3);
230
231 EXPECT_NE(event.get(), nullptr);
232 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnTouchEvent003 end";
233 }
234
235 /**
236 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1
237 * @tc.name: OnMouseEvent
238 * @tc.desc: Check the on mouse event.
239 */
240 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1, TestSize.Level1)
241 {
242 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 start";
243
244 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
245 MMI::PointerEvent::PointerItem item = {};
246
247 item.SetPointerId(1);
248 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
249 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
250 event->AddPointerItem(item);
251
252 EXPECT_NE(event.get(), nullptr);
253 inputInterceptor_->OnPointerEvent(*event);
254 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent1 end";
255 }
256
257 /**
258 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002
259 * @tc.name: InterceptPointerEventCallBack
260 * @tc.desc: Check the on mouse event.
261 */
262 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002, TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 start";
265 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
266 inputInterceptor_->SetAvailableFunctions(availableFunctions);
267
268 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
269 MMI::PointerEvent::PointerItem item = {};
270
271 item.SetPointerId(1);
272 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
273 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
274 event->AddPointerItem(item);
275
276 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
277 if (inputEventConsumer != nullptr) {
278 inputEventConsumer->OnInputEvent(event);
279 }
280 /* wait ProcessMouseEvent */
281 sleep(SLEEP_TIME_3);
282 EXPECT_NE(event.get(), nullptr);
283 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent002 end";
284 }
285
286 /**
287 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003
288 * @tc.name: OnInputEvent
289 * @tc.desc: Check the on mouse event.
290 */
291 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 start";
294 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
295 inputInterceptor_->SetAvailableFunctions(availableFunctions);
296
297 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
298 MMI::PointerEvent::PointerItem item = {};
299
300 item.SetPointerId(1);
301 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
302 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
303 event->AddPointerItem(item);
304
305 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
306 if (inputEventConsumer != nullptr) {
307 inputEventConsumer->OnInputEvent(event);
308 }
309 /* wait ProcessMouseEvent */
310 sleep(SLEEP_TIME_3);
311 EXPECT_NE(event.get(), nullptr);
312 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMouseEvent003 end";
313 }
314
315 /**
316 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001
317 * @tc.name: OnKeyEvent
318 * @tc.desc: Check the on key event.
319 */
320 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001, TestSize.Level1)
321 {
322 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 start";
323
324 std::shared_ptr<MMI::KeyEvent> event = MMI::KeyEvent::Create();
325 inputInterceptor_->OnKeyEvent(*event);
326 EXPECT_NE(event.get(), nullptr);
327 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent001 end";
328 }
329
330 /**
331 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002
332 * @tc.name: OnInputEvent
333 * @tc.desc: Check the on key event.
334 */
335 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002, TestSize.Level1)
336 {
337 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 start";
338
339 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
340 MMI::KeyEvent::KeyItem item = {};
341
342 item.SetPressed(true);
343 keyEvent->AddKeyItem(item);
344 keyEvent->SetKeyCode(1);
345
346 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
347 if (inputEventConsumer != nullptr) {
348 inputEventConsumer->OnInputEvent(keyEvent);
349 }
350
351 /* wait ProcessKeyEvent */
352 sleep(SLEEP_TIME_3);
353 EXPECT_NE(keyEvent.get(), nullptr);
354 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent002 end";
355 }
356
357 /**
358 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003
359 * @tc.name: OnKeyEvent
360 * @tc.desc: Check the on key event.
361 */
362 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 start";
365 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_FILTER_KEY_EVENTS;
366 inputInterceptor_->SetAvailableFunctions(availableFunctions);
367
368 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
369 MMI::KeyEvent::KeyItem item = {};
370
371 item.SetPressed(true);
372 keyEvent->AddKeyItem(item);
373 keyEvent->SetKeyCode(1);
374
375 /* wait ProcessKeyEvent */
376 sleep(SLEEP_TIME_3);
377 EXPECT_NE(keyEvent.get(), nullptr);
378 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnKeyEvent003 end";
379 }
380
381 /**
382 * @tc.number: AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001
383 * @tc.name: OnMoveMouse
384 * @tc.desc: Check the OnMoveMouse.
385 */
386 HWTEST_F(AccessibilityInputInterceptorTest, AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001,
387 TestSize.Level1)
388 {
389 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 start";
390 if (!inputInterceptor_) {
391 return;
392 }
393 inputInterceptor_->OnMoveMouse(1, 1);
394
395 GTEST_LOG_(INFO) << "AccessibilityInputInterceptorTest_Unittest_OnMoveMouse001 end";
396 }
397 } // namespace Accessibility
398 } // namespace OHOS