1 /*
2 * Copyright (c) 2025 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 "ipc_skeleton.h"
18
19 #include "pull_throw_subscriber_handler.h"
20
21 #undef MMI_LOG_TAG
22 #define MMI_LOG_TAG "PullThrowSubscriberHandlerTest"
23
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 const int64_t WINDOW_TIME_INTERVAL = 0.5e6 + 1;
28 } // namespace
29
30 class PullThrowSubscriberHandlerTest : public testing::Test {
31 public:
32 std::shared_ptr<PointerEvent> SetupSingleFingerDownEvent();
33 std::shared_ptr<PointerEvent> SetupDoubleFingerDownEvent();
34 std::shared_ptr<PointerEvent> SetupFingerPoisitionEvent();
35 };
36
SetupSingleFingerDownEvent()37 std::shared_ptr<PointerEvent> PullThrowSubscriberHandlerTest::SetupSingleFingerDownEvent()
38 {
39 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
40 CHKPP(pointerEvent);
41 PointerEvent::PointerItem item;
42 item.SetPointerId(0);
43 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
44 int32_t downX = 100;
45 int32_t downY = 200;
46 item.SetDisplayX(downX);
47 item.SetDisplayY(downY);
48 item.SetPressed(true);
49 pointerEvent->SetPointerId(0);
50 pointerEvent->AddPointerItem(item);
51 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
52 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
53 return pointerEvent;
54 }
55
SetupFingerPoisitionEvent()56 std::shared_ptr<PointerEvent> PullThrowSubscriberHandlerTest::SetupFingerPoisitionEvent()
57 {
58 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
59 CHKPP(pointerEvent);
60 PointerEvent::PointerItem item;
61 item.SetPointerId(0);
62 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
63 int32_t downX = 10;
64 int32_t downY = 20;
65 item.SetDisplayX(downX);
66 item.SetDisplayY(downY);
67 return pointerEvent;
68 }
69
SetupDoubleFingerDownEvent()70 std::shared_ptr<PointerEvent> PullThrowSubscriberHandlerTest::SetupDoubleFingerDownEvent()
71 {
72 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
73 CHKPP(pointerEvent);
74 PointerEvent::PointerItem item;
75 PointerEvent::PointerItem item2;
76 item.SetPointerId(0);
77 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
78 int32_t downX = 100;
79 int32_t downY = 200;
80 item.SetDisplayX(downX);
81 item.SetDisplayY(downY);
82 item.SetPressed(true);
83 item.SetDownTime(0);
84 pointerEvent->SetPointerId(0);
85 pointerEvent->AddPointerItem(item);
86
87 item2.SetPointerId(1);
88 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
89 int32_t secondDownX = 120;
90 int32_t secondDownY = 220;
91 item2.SetDisplayX(secondDownX);
92 item2.SetDisplayY(secondDownY);
93 item2.SetPressed(true);
94 int64_t downTime = 100000;
95 item2.SetDownTime(downTime);
96 pointerEvent->SetPointerId(1);
97 pointerEvent->AddPointerItem(item2);
98 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
99 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
100 return pointerEvent;
101 }
102
103 /**
104 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGestureDownEvent_001
105 * @tc.desc: Test HandleFingerGestureDownEvent
106 * @tc.type: Function
107 * @tc.require:
108 */
109 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGestureDownEvent_001,
110 testing::ext::TestSize.Level1)
111 {
112 CALL_TEST_DEBUG;
113 auto touchEvent = SetupDoubleFingerDownEvent();
114 ASSERT_TRUE(touchEvent != nullptr);
115 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGestureDownEvent(touchEvent));
116 }
117
118 /**
119 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGestureDownEvent_002
120 * @tc.desc: Test HandleFingerGestureDownEvent
121 * @tc.type: Function
122 * @tc.require:
123 */
124 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGestureDownEvent_002,
125 testing::ext::TestSize.Level1)
126 {
127 CALL_TEST_DEBUG;
128 auto touchEvent = SetupFingerPoisitionEvent();
129 ASSERT_TRUE(touchEvent != nullptr);
130 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGestureDownEvent(touchEvent));
131 }
132
133 /**
134 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGestureMoveEvent_001
135 * @tc.desc: Test HandleFingerGestureMoveEvent
136 * @tc.type: Function
137 * @tc.require:
138 */
139 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGestureMoveEvent_001,
140 testing::ext::TestSize.Level1)
141 {
142 CALL_TEST_DEBUG;
143 auto touchEvent = SetupSingleFingerDownEvent();
144 ASSERT_TRUE(touchEvent != nullptr);
145 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGestureMoveEvent(touchEvent));
146 }
147
148 /**
149 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGestureMoveEvent_002
150 * @tc.desc: Test HandleFingerGestureMoveEvent
151 * @tc.type: Function
152 * @tc.require:
153 */
154 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGestureMoveEvent_002,
155 testing::ext::TestSize.Level1)
156 {
157 CALL_TEST_DEBUG;
158 auto touchEvent = SetupDoubleFingerDownEvent();
159 ASSERT_TRUE(touchEvent != nullptr);
160 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
161 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGestureMoveEvent(touchEvent));
162 }
163
164 /**
165 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_001
166 * @tc.desc: Test HandleFingerGesturePullMoveEvent
167 * @tc.type: Function
168 * @tc.require:
169 */
170 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_001,
171 testing::ext::TestSize.Level1)
172 {
173 CALL_TEST_DEBUG;
174 auto touchEvent = SetupSingleFingerDownEvent();
175 ASSERT_TRUE(touchEvent != nullptr);
176 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
177 }
178
179 /**
180 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_002
181 * @tc.desc: Test HandleFingerGesturePullMoveEvent
182 * @tc.type: Function
183 * @tc.require:
184 */
185 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_002,
186 testing::ext::TestSize.Level1)
187 {
188 CALL_TEST_DEBUG;
189 auto touchEvent = SetupDoubleFingerDownEvent();
190 ASSERT_TRUE(touchEvent != nullptr);
191 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGestureDownEvent(touchEvent));
192 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
193 }
194
195 /**
196 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_003
197 * @tc.desc: Test HandleFingerGesturePullMoveEvent
198 * @tc.type: Function
199 * @tc.require:
200 */
201 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_003,
202 testing::ext::TestSize.Level1)
203 {
204 CALL_TEST_DEBUG;
205 auto touchEvent = SetupDoubleFingerDownEvent();
206 ASSERT_TRUE(touchEvent != nullptr);
207 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
208
209 PULL_THROW_EVENT_HANDLER->StopFingerGesture(touchEvent);
210 double actionTime = touchEvent->GetActionTime();
211 touchEvent->SetActionTime(actionTime + WINDOW_TIME_INTERVAL);
212 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
213 }
214
215 /**
216 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_001
217 * @tc.desc: Test HandleFingerGesturePullUpEvent
218 * @tc.type: Function
219 * @tc.require:
220 */
221 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_001,
222 testing::ext::TestSize.Level1)
223 {
224 CALL_TEST_DEBUG;
225 auto touchEvent = SetupSingleFingerDownEvent();
226 ASSERT_TRUE(touchEvent != nullptr);
227 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent));
228 }
229
230 /**
231 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_002
232 * @tc.desc: Test HandleFingerGesturePullUpEvent
233 * @tc.type: Function
234 * @tc.require:
235 */
236 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_002,
237 testing::ext::TestSize.Level1)
238 {
239 CALL_TEST_DEBUG;
240 auto touchEvent = SetupDoubleFingerDownEvent();
241 ASSERT_TRUE(touchEvent != nullptr);
242 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
243 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent));
244 }
245 /**
246 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_003
247 * @tc.desc: Test HandleFingerGesturePullUpEvent
248 * @tc.type: Function
249 * @tc.require:
250 */
251 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_003,
252 testing::ext::TestSize.Level1)
253 {
254 CALL_TEST_DEBUG;
255 auto touchEvent = SetupDoubleFingerDownEvent();
256 ASSERT_TRUE(touchEvent != nullptr);
257 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
258 auto touchEvent1 = SetupFingerPoisitionEvent();
259 PULL_THROW_EVENT_HANDLER->UpdateFingerPoisition(touchEvent1);
260 touchEvent->SetActionTime(0);
261 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent));
262 }
263
264 /**
265 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_004
266 * @tc.desc: Test HandleFingerGesturePullUpEvent
267 * @tc.type: Function
268 * @tc.require:
269 */
270 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_004,
271 testing::ext::TestSize.Level1)
272 {
273 CALL_TEST_DEBUG;
274 auto touchEvent = SetupDoubleFingerDownEvent();
275 ASSERT_TRUE(touchEvent != nullptr);
276 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
277 PULL_THROW_EVENT_HANDLER->UpdateFingerPoisition(touchEvent);
278 touchEvent->SetActionTime(0);
279 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent));
280 }
281
282 /**
283 * @tc.name: PullThrowSubscriberHandlerTest_UpdateFingerPoisition_001
284 * @tc.desc: Test UpdateFingerPoisition
285 * @tc.type: Function
286 * @tc.require:
287 */
288 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_UpdateFingerPoisition_001,
289 testing::ext::TestSize.Level1)
290 {
291 CALL_TEST_DEBUG;
292 auto touchEvent = SetupDoubleFingerDownEvent();
293 ASSERT_TRUE(touchEvent != nullptr);
294 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->UpdateFingerPoisition(touchEvent));
295 }
296
297 /**
298 * @tc.name: PullThrowSubscriberHandlerTest_StartFingerGesture_001
299 * @tc.desc: Test StartFingerGesture
300 * @tc.type: Function
301 * @tc.require:
302 */
303 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_StartFingerGesture_001,
304 testing::ext::TestSize.Level1)
305 {
306 CALL_TEST_DEBUG;
307 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->StartFingerGesture());
308 }
309
310 /**
311 * @tc.name: CheckThrowAngleValidTest_001
312 * @tc.desc: Test StartFingerGesture
313 * @tc.type: Function
314 * @tc.require:
315 */
316 HWTEST_F(PullThrowSubscriberHandlerTest, CheckThrowAngleValidTest_001, testing::ext::TestSize.Level1)
317 {
318 CALL_TEST_DEBUG;
319 double angle = 100;
320 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
321 angle = 300;
322 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
323 angle = 500;
324 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
325 }
326
327 /**
328 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0011
329 * @tc.desc: Test HandleFingerGesturePullMoveEvent
330 * @tc.type: Function
331 * @tc.require:
332 */
333 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0011,
334 testing::ext::TestSize.Level1)
335 {
336 CALL_TEST_DEBUG;
337 auto touchEvent = SetupSingleFingerDownEvent();
338 ASSERT_TRUE(touchEvent != nullptr);
339 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = false;
340 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
341 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
342 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
343 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = false;
344 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
345 touchEvent = SetupDoubleFingerDownEvent();
346 ASSERT_TRUE(touchEvent != nullptr);
347 PULL_THROW_EVENT_HANDLER->StartFingerGesture();
348 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = false;
349 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
350 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
351 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
352 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = false;
353 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent));
354 }
355
356 /**
357 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0012
358 * @tc.desc: Test HandleFingerGesturePullUpEvent
359 * @tc.type: Function
360 * @tc.require:
361 */
362 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0012,
363 testing::ext::TestSize.Level1)
364 {
365 CALL_TEST_DEBUG;
366 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
367 ASSERT_NE(pointerEvent, nullptr);
368 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
369 PointerEvent::PointerItem item;
370 PointerEvent::PointerItem item1;
371 pointerEvent->pointers_.push_back(item);
372 pointerEvent->pointers_.push_back(item1);
373 pointerEvent->SetActionTime(1000);
374 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
375 pointerEvent->SetActionTime(0);
376 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
377 }
378
379 /**
380 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0013
381 * @tc.desc: Test HandleFingerGesturePullUpEvent
382 * @tc.type: Function
383 * @tc.require:
384 */
385 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0013,
386 testing::ext::TestSize.Level1)
387 {
388 CALL_TEST_DEBUG;
389 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
390 ASSERT_NE(pointerEvent, nullptr);
391 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
392 PointerEvent::PointerItem item;
393 PointerEvent::PointerItem item1;
394 pointerEvent->pointers_.push_back(item);
395 pointerEvent->pointers_.push_back(item1);
396 pointerEvent->SetActionTime(1000);
397 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
398 pointerEvent->SetActionTime(0);
399 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
400 }
401
402 /**
403 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0012
404 * @tc.desc: Test HandleFingerGesturePullUpEvent
405 * @tc.type: Function
406 * @tc.require:
407 */
408 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0012,
409 testing::ext::TestSize.Level1)
410 {
411 CALL_TEST_DEBUG;
412 auto touchEvent = SetupSingleFingerDownEvent();
413 ASSERT_TRUE(touchEvent != nullptr);
414 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
415 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
416 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
417 EXPECT_EQ(PULL_THROW_EVENT_HANDLER->alreadyTouchDown_, false);
418 }
419
420 /**
421 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0013
422 * @tc.desc: Test HandleFingerGesturePullUpEvent
423 * @tc.type: Function
424 * @tc.require:
425 */
426 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0013,
427 testing::ext::TestSize.Level1)
428 {
429 CALL_TEST_DEBUG;
430 auto touchEvent = SetupSingleFingerDownEvent();
431 ASSERT_TRUE(touchEvent != nullptr);
432 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
433 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
434 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
435 EXPECT_EQ(PULL_THROW_EVENT_HANDLER->alreadyTouchDown_, false);
436 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
437 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = false;
438 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
439 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
440 EXPECT_EQ(PULL_THROW_EVENT_HANDLER->alreadyTouchDown_, true);
441 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
442 }
443
444 /**
445 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0014
446 * @tc.desc: Test HandleFingerGesturePullUpEvent
447 * @tc.type: Function
448 * @tc.require:
449 */
450 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0014,
451 testing::ext::TestSize.Level1)
452 {
453 CALL_TEST_DEBUG;
454 auto touchEvent = SetupSingleFingerDownEvent();
455 ASSERT_TRUE(touchEvent != nullptr);
456 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
457 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
458 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
459 EXPECT_EQ(PULL_THROW_EVENT_HANDLER->alreadyTouchDown_, false);
460
461 std::this_thread::sleep_for(std::chrono::seconds(1));
462 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
463 }
464
465 /**
466 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0015
467 * @tc.desc: Test HandleFingerGesturePullUpEvent
468 * @tc.type: Function
469 * @tc.require:
470 */
471 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0015,
472 testing::ext::TestSize.Level1)
473 {
474 CALL_TEST_DEBUG;
475 auto touchEvent = SetupSingleFingerDownEvent();
476 ASSERT_TRUE(touchEvent != nullptr);
477 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
478 PULL_THROW_EVENT_HANDLER->alreadyTouchDown_ = true;
479 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
480 EXPECT_EQ(PULL_THROW_EVENT_HANDLER->alreadyTouchDown_, false);
481
482 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = false;
483 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
484
485 std::this_thread::sleep_for(std::chrono::seconds(1));
486 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullMoveEvent(touchEvent);
487 }
488
489 /**
490 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0016
491 * @tc.desc: Test HandleFingerGesturePullUpEvent
492 * @tc.type: Function
493 * @tc.require:
494 */
495 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0016,
496 testing::ext::TestSize.Level1)
497 {
498 CALL_TEST_DEBUG;
499 auto touchEvent = SetupSingleFingerDownEvent();
500 ASSERT_TRUE(touchEvent != nullptr);
501 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
502 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent);
503 }
504
505 /**
506 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0017
507 * @tc.desc: Test HandleFingerGesturePullUpEvent
508 * @tc.type: Function
509 * @tc.require:
510 */
511 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0017,
512 testing::ext::TestSize.Level1)
513 {
514 CALL_TEST_DEBUG;
515 auto touchEvent = SetupSingleFingerDownEvent();
516 ASSERT_TRUE(touchEvent != nullptr);
517 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
518 PULL_THROW_EVENT_HANDLER->triggerTime_ = WINDOW_TIME_INTERVAL;
519 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent);
520 }
521
522 /**
523 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0018
524 * @tc.desc: Test HandleFingerGesturePullUpEvent
525 * @tc.type: Function
526 * @tc.require:
527 */
528 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullMoveEvent_0018,
529 testing::ext::TestSize.Level1)
530 {
531 CALL_TEST_DEBUG;
532 auto touchEvent = SetupSingleFingerDownEvent();
533 ASSERT_TRUE(touchEvent != nullptr);
534 int32_t pointId = touchEvent->GetPointerId();
535 PointerEvent::PointerItem item;
536 bool ret = touchEvent->GetPointerItem(pointId, item);
537 EXPECT_EQ(ret, true);
538 int32_t downY = PullThrowSubscriberHandler::SPIN_UP_AREA_Y + 100;
539 item.SetDisplayY(downY);
540 touchEvent->AddPointerItem(item);
541 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
542 PULL_THROW_EVENT_HANDLER->triggerTime_ = WINDOW_TIME_INTERVAL;
543 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent);
544
545 ret = touchEvent->GetPointerItem(pointId, item);
546 EXPECT_EQ(ret, true);
547 downY = PullThrowSubscriberHandler::SPIN_DOWN_AREA_Y + 100;
548 item.SetDisplayY(downY);
549 touchEvent->AddPointerItem(item);
550 PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(touchEvent);
551 }
552
553 /**
554 * @tc.name: PullThrowSubscriberHandlerTest_CheckThrowAngleValid_002
555 * @tc.desc: Test HandleFingerGesturePullUpEvent
556 * @tc.type: Function
557 * @tc.require:
558 */
559 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_CheckThrowAngleValid_002,
560 testing::ext::TestSize.Level1)
561 {
562 CALL_TEST_DEBUG;
563 double angle = 0;
564 bool ret = PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle);
565 EXPECT_EQ(ret, false);
566
567 angle = PullThrowSubscriberHandler::ANGLE_DOWN_MIN;
568 ret = PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle);
569 EXPECT_EQ(ret, true);
570
571 angle = PullThrowSubscriberHandler::ANGLE_DOWN_MAX + 10;
572 ret = PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle);
573 EXPECT_EQ(ret, false);
574
575 angle = PullThrowSubscriberHandler::ANGLE_UP_MIN;
576 ret = PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle);
577 EXPECT_EQ(ret, true);
578
579 angle = PullThrowSubscriberHandler::ANGLE_UP_MAX + 10;
580 ret = PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle);
581 EXPECT_EQ(ret, false);
582 }
583
584 /**
585 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0014
586 * @tc.desc: Test HandleFingerGesturePullUpEvent
587 * @tc.type: Function
588 * @tc.require:
589 */
590 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0014,
591 testing::ext::TestSize.Level1)
592 {
593 CALL_TEST_DEBUG;
594 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
595 ASSERT_NE(pointerEvent, nullptr);
596 PULL_THROW_EVENT_HANDLER->gestureInProgress_ = true;
597 PointerEvent::PointerItem item;
598 PointerEvent::PointerItem item1;
599 pointerEvent->pointers_.push_back(item);
600 pointerEvent->pointers_.push_back(item1);
601 pointerEvent->SetActionTime(1000);
602 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
603 pointerEvent->SetActionTime(0);
604 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->HandleFingerGesturePullUpEvent(pointerEvent));
605 }
606
607 /**
608 * @tc.name: PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0015
609 * @tc.desc: Test CheckThrowAngleValid
610 * @tc.type: Function
611 * @tc.require:
612 */
613 HWTEST_F(PullThrowSubscriberHandlerTest, PullThrowSubscriberHandlerTest_HandleFingerGesturePullUpEvent_0015,
614 testing::ext::TestSize.Level1)
615 {
616 CALL_TEST_DEBUG;
617 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
618 ASSERT_NE(pointerEvent, nullptr);
619 double angle = -300.0;
620 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
621 angle = -200.0;
622 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
623 angle = -50.0;
624 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
625 angle = 0;
626 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle));
627 double angle2{1e-1};
628 ASSERT_NO_FATAL_FAILURE(PULL_THROW_EVENT_HANDLER->CheckThrowAngleValid(angle2));
629 }
630 } // namespace MMI
631 } // namespace OHOS