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