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