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_ut_helper.h"
20 #include "accessibility_zoom_gesture.h"
21 #include "accessible_ability_manager_service.h"
22 #include "full_screen_magnification_manager.h"
23 #include "magnification_menu_manager.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Accessibility {
30 namespace {
31 constexpr uint32_t TRIPLE_TAP_COUNT = 3;
32 } // namespace
33 class AccessibilityZoomGestureUnitTest : public ::testing::Test {
34 public:
AccessibilityZoomGestureUnitTest()35 AccessibilityZoomGestureUnitTest()
36 {}
~AccessibilityZoomGestureUnitTest()37 ~AccessibilityZoomGestureUnitTest()
38 {}
39
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 std::shared_ptr<MMI::PointerEvent> CreatePointerEvent(int32_t sourceType, int32_t pointerAction);
45 void TripleTaps();
46
47 std::shared_ptr<AccessibilityZoomGesture> zoomGesture_ = nullptr;
48 };
49
SetUpTestCase()50 void AccessibilityZoomGestureUnitTest::SetUpTestCase()
51 {
52 GTEST_LOG_(INFO) << "###################### AccessibilityZoomGestureUnitTest Start ######################";
53 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
54 }
55
TearDownTestCase()56 void AccessibilityZoomGestureUnitTest::TearDownTestCase()
57 {
58 GTEST_LOG_(INFO) << "###################### AccessibilityZoomGestureUnitTest End ######################";
59 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
60 }
61
SetUp()62 void AccessibilityZoomGestureUnitTest::SetUp()
63 {
64 GTEST_LOG_(INFO) << "SetUp";
65 std::shared_ptr<FullScreenMagnificationManager> manager = std::make_shared<FullScreenMagnificationManager>();
66 std::shared_ptr<MagnificationMenuManager> menuManager = std::make_shared<MagnificationMenuManager>();
67 zoomGesture_ = std::make_shared<AccessibilityZoomGesture>(manager, menuManager);
68 }
69
TearDown()70 void AccessibilityZoomGestureUnitTest::TearDown()
71 {
72 GTEST_LOG_(INFO) << "TearDown";
73 zoomGesture_ = nullptr;
74 }
75
CreatePointerEvent(int32_t sourceType,int32_t pointerAction)76 std::shared_ptr<MMI::PointerEvent> AccessibilityZoomGestureUnitTest::CreatePointerEvent(int32_t sourceType,
77 int32_t pointerAction)
78 {
79 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
80 if (!event) {
81 return nullptr;
82 }
83 event->SetSourceType(sourceType);
84 event->SetPointerAction(pointerAction);
85 return event;
86 }
87
TripleTaps()88 void AccessibilityZoomGestureUnitTest::TripleTaps()
89 {
90 EXPECT_TRUE(zoomGesture_ != nullptr);
91 for (uint32_t count = 0; count < TRIPLE_TAP_COUNT; count++) {
92 // Pointer down
93 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
94 MMI::PointerEvent::POINTER_ACTION_DOWN);
95 EXPECT_TRUE(eventDown != nullptr);
96 MMI::PointerEvent::PointerItem item;
97 eventDown->AddPointerItem(item);
98 zoomGesture_->OnPointerEvent(*eventDown);
99 // Pointer up
100 std::shared_ptr<MMI::PointerEvent> eventUp = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
101 MMI::PointerEvent::POINTER_ACTION_UP);
102 EXPECT_TRUE(eventUp != nullptr);
103 MMI::PointerEvent::PointerItem item1;
104 eventUp->AddPointerItem(item1);
105 zoomGesture_->OnPointerEvent(*eventUp);
106 }
107 }
108
109 /**
110 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_001
111 * @tc.name: OnPointerEvent
112 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_DOWN timeout)
113 */
114 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_001, TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_001 start";
117 EXPECT_TRUE(zoomGesture_ != nullptr);
118 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
119 MMI::PointerEvent::POINTER_ACTION_DOWN);
120 EXPECT_TRUE(event != nullptr);
121 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
122 zoomGesture_->OnPointerEvent(*event);
123 sleep(2);
124 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
125 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_DOWN);
126
127 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_001 end";
128 }
129
130 /**
131 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_002
132 * @tc.name: OnPointerEvent
133 * @tc.desc: Test function OnPointerEvent(Tap once on the screen)
134 */
135 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_002, TestSize.Level1)
136 {
137 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_002 start";
138 EXPECT_TRUE(zoomGesture_ != nullptr);
139 // Pointer down
140 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
141 MMI::PointerEvent::POINTER_ACTION_DOWN);
142 EXPECT_TRUE(eventDown != nullptr);
143 MMI::PointerEvent::PointerItem item;
144 eventDown->AddPointerItem(item);
145 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
146 zoomGesture_->OnPointerEvent(*eventDown);
147 // Pointer up
148 std::shared_ptr<MMI::PointerEvent> eventUp = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
149 MMI::PointerEvent::POINTER_ACTION_UP);
150 EXPECT_TRUE(eventUp != nullptr);
151 zoomGesture_->OnPointerEvent(*eventUp);
152 sleep(2);
153
154 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
155 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_DOWN);
156 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
157 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_UP);
158
159 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_002 end";
160 }
161
162 /**
163 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_003
164 * @tc.name: OnPointerEvent
165 * @tc.desc: Test function OnPointerEvent(3 Taps on the screen)
166 */
167 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_003, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_003 start";
170
171 // start zoom
172 TripleTaps();
173 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
174 EXPECT_TRUE(zoomState);
175 // stop zoom
176 TripleTaps();
177 zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
178 EXPECT_TRUE(!zoomState);
179
180 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_003 end";
181 }
182
183 /**
184 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_004
185 * @tc.name: OnPointerEvent
186 * @tc.desc: Test function OnPointerEvent(transfer to sliding state)
187 */
188 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_004, TestSize.Level1)
189 {
190 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_004 start";
191
192 // start zoom
193 TripleTaps();
194 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
195 EXPECT_TRUE(zoomState);
196 // Pointer down
197 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
198 MMI::PointerEvent::POINTER_ACTION_DOWN);
199 EXPECT_TRUE(eventDown != nullptr);
200 MMI::PointerEvent::PointerItem item1;
201 item1.SetDisplayX(10);
202 item1.SetDisplayY(20);
203 eventDown->AddPointerItem(item1);
204
205 MMI::PointerEvent::PointerItem item2;
206 item2.SetDisplayX(40);
207 item2.SetDisplayY(20);
208 eventDown->AddPointerItem(item2);
209 zoomGesture_->OnPointerEvent(*eventDown);
210
211 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_004 end";
212 }
213
214 /**
215 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_005
216 * @tc.name: OnPointerEvent
217 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_MOVE in sliding state)
218 */
219 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_005, TestSize.Level1)
220 {
221 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_005 start";
222
223 // start zoom
224 TripleTaps();
225 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
226 EXPECT_TRUE(zoomState);
227
228 // Pointer down
229 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
230 MMI::PointerEvent::POINTER_ACTION_DOWN);
231 EXPECT_TRUE(eventDown != nullptr);
232 MMI::PointerEvent::PointerItem item1;
233 item1.SetDisplayX(10);
234 item1.SetDisplayY(20);
235 eventDown->AddPointerItem(item1);
236
237 MMI::PointerEvent::PointerItem item2;
238 item2.SetDisplayX(40);
239 item2.SetDisplayY(20);
240 eventDown->AddPointerItem(item2);
241 zoomGesture_->OnPointerEvent(*eventDown);
242
243 // Pointer move
244 std::shared_ptr<MMI::PointerEvent> eventMove = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
245 MMI::PointerEvent::POINTER_ACTION_MOVE);
246 EXPECT_TRUE(eventMove != nullptr);
247 MMI::PointerEvent::PointerItem item3;
248 item3.SetDisplayX(0);
249 item3.SetDisplayY(50);
250 eventMove->AddPointerItem(item3);
251
252 MMI::PointerEvent::PointerItem item4;
253 item4.SetDisplayX(70);
254 item4.SetDisplayY(50);
255 eventMove->AddPointerItem(item4);
256 zoomGesture_->OnPointerEvent(*eventMove);
257 zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
258 EXPECT_TRUE(zoomState);
259
260 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_005 end";
261 }
262
263 /**
264 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_006
265 * @tc.name: OnPointerEvent
266 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_DOWN in sliding state)
267 */
268 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_006, TestSize.Level1)
269 {
270 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_006 start";
271
272 // start zoom
273 TripleTaps();
274 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
275 EXPECT_TRUE(zoomState);
276
277 // Pointer down
278 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
279 MMI::PointerEvent::POINTER_ACTION_DOWN);
280 EXPECT_TRUE(eventDown != nullptr);
281 MMI::PointerEvent::PointerItem item1;
282 item1.SetDisplayX(10);
283 item1.SetDisplayY(20);
284 eventDown->AddPointerItem(item1);
285
286 MMI::PointerEvent::PointerItem item2;
287 item2.SetDisplayX(40);
288 item2.SetDisplayY(20);
289 eventDown->AddPointerItem(item2);
290 zoomGesture_->OnPointerEvent(*eventDown);
291
292 MMI::PointerEvent::PointerItem item3;
293 item3.SetDisplayX(50);
294 item3.SetDisplayY(25);
295 eventDown->AddPointerItem(item3);
296 zoomGesture_->OnPointerEvent(*eventDown);
297
298 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_006 end";
299 }
300
301 /**
302 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_007
303 * @tc.name: OnPointerEvent
304 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_UP in sliding state)
305 */
306 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_007, TestSize.Level1)
307 {
308 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_007 start";
309
310 // start zoom
311 TripleTaps();
312 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
313 EXPECT_TRUE(zoomState);
314
315 // Pointer down
316 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
317 MMI::PointerEvent::POINTER_ACTION_DOWN);
318 EXPECT_TRUE(event != nullptr);
319 event->SetPointerId(1);
320 MMI::PointerEvent::PointerItem item1;
321 item1.SetPointerId(1);
322 item1.SetDisplayX(10);
323 item1.SetDisplayY(20);
324 event->AddPointerItem(item1);
325
326 MMI::PointerEvent::PointerItem item2;
327 item2.SetPointerId(2);
328 item2.SetDisplayX(40);
329 item2.SetDisplayY(20);
330 event->AddPointerItem(item2);
331
332 MMI::PointerEvent::PointerItem item3;
333 item3.SetPointerId(3);
334 item3.SetDisplayX(50);
335 item3.SetDisplayY(25);
336 event->AddPointerItem(item3);
337 zoomGesture_->OnPointerEvent(*event);
338
339 // Pointer up
340 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
341 zoomGesture_->OnPointerEvent(*event);
342
343 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_007 end";
344 }
345
346 /**
347 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_008
348 * @tc.name: OnPointerEvent
349 * @tc.desc: Test function OnPointerEvent(sliding state->zoom state)
350 */
351 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_008, TestSize.Level1)
352 {
353 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_008 start";
354
355 // start zoom
356 TripleTaps();
357 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
358 EXPECT_TRUE(zoomState);
359
360 // Pointer down
361 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
362 MMI::PointerEvent::POINTER_ACTION_DOWN);
363 EXPECT_TRUE(event != nullptr);
364 event->SetPointerId(1);
365 MMI::PointerEvent::PointerItem item1;
366 item1.SetPointerId(1);
367 item1.SetDisplayX(10);
368 item1.SetDisplayY(20);
369 event->AddPointerItem(item1);
370
371 MMI::PointerEvent::PointerItem item2;
372 item2.SetPointerId(2);
373 item2.SetDisplayX(40);
374 item2.SetDisplayY(20);
375 event->AddPointerItem(item2);
376 zoomGesture_->OnPointerEvent(*event);
377
378 // Pointer up
379 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
380 zoomGesture_->OnPointerEvent(*event);
381 // Pointer up
382 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
383 event->SetPointerId(2);
384 event->RemovePointerItem(1);
385 zoomGesture_->OnPointerEvent(*event);
386
387 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_008 end";
388 }
389
390 /**
391 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_009
392 * @tc.name: OnPointerEvent
393 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in ready state)
394 */
395 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_009, TestSize.Level1)
396 {
397 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_009 start";
398 EXPECT_TRUE(zoomGesture_ != nullptr);
399 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
400 MMI::PointerEvent::POINTER_ACTION_CANCEL);
401 EXPECT_TRUE(event != nullptr);
402 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
403 zoomGesture_->OnPointerEvent(*event);
404 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
405 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_CANCEL);
406
407 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_009 end";
408 }
409
410 /**
411 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_010
412 * @tc.name: OnPointerEvent
413 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in zoom state)
414 */
415 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_010, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_010 start";
418 EXPECT_TRUE(zoomGesture_ != nullptr);
419 // start zoom
420 TripleTaps();
421 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
422 EXPECT_TRUE(zoomState);
423 // send cancel event
424 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
425 MMI::PointerEvent::POINTER_ACTION_CANCEL);
426 EXPECT_TRUE(event != nullptr);
427 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
428 zoomGesture_->OnPointerEvent(*event);
429 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
430 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_CANCEL);
431
432 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_010 end";
433 }
434
435 /**
436 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_011
437 * @tc.name: OnPointerEvent
438 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in sliding state)
439 */
440 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_011, TestSize.Level1)
441 {
442 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_011 start";
443
444 // start zoom
445 TripleTaps();
446 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
447 EXPECT_TRUE(zoomState);
448
449 // Pointer down
450 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
451 MMI::PointerEvent::POINTER_ACTION_DOWN);
452 EXPECT_TRUE(event != nullptr);
453 event->SetPointerId(1);
454 MMI::PointerEvent::PointerItem item1;
455 item1.SetPointerId(1);
456 item1.SetDisplayX(10);
457 item1.SetDisplayY(20);
458 event->AddPointerItem(item1);
459
460 MMI::PointerEvent::PointerItem item2;
461 item2.SetPointerId(2);
462 item2.SetDisplayX(40);
463 item2.SetDisplayY(20);
464 event->AddPointerItem(item2);
465 zoomGesture_->OnPointerEvent(*event);
466
467 // Pointer cancel
468 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
469 zoomGesture_->OnPointerEvent(*event);
470
471 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_011 end";
472 }
473 } // namespace Accessibility
474 } // namespace OHOS