1 /*
2 * Copyright (c) 2024 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 "input_event_handler.h"
20 #include "input_windows_manager.h"
21 #include "long_press_subscriber_handler.h"
22 #include "uds_session.h"
23
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "LongPressSubscribeHandlerTest"
26
27 namespace OHOS {
28 namespace MMI {
29 namespace {
30 using namespace testing::ext;
31 const std::string PROGRAM_NAME = "LongPressSubscribeHandlerTest";
32 constexpr int32_t MODULE_TYPE = 1;
33 constexpr int32_t UDS_FD = -1;
34 constexpr int32_t UDS_UID = 100;
35 constexpr int32_t UDS_PID = 100;
36 } // namespace
37
38 class LongPressSubscribeHandlerTest : public testing::Test {
39 public:
SetUpTestCase(void)40 static void SetUpTestCase(void) {}
TearDownTestCase(void)41 static void TearDownTestCase(void) {}
42 std::shared_ptr<PointerEvent> SetupZeroFingerDownEvent();
43 std::shared_ptr<PointerEvent> SetupSingleFingerDownEvent();
44 std::shared_ptr<PointerEvent> SetupDoubleFingerDownEvent();
45 std::shared_ptr<PointerEvent> SetupThreeFingerDownEvent();
46 };
47
SetupZeroFingerDownEvent()48 std::shared_ptr<PointerEvent> LongPressSubscribeHandlerTest::SetupZeroFingerDownEvent()
49 {
50 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
51 CHKPP(pointerEvent);
52 pointerEvent->SetPointerId(0);
53 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
54 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
55 return pointerEvent;
56 }
57
SetupSingleFingerDownEvent()58 std::shared_ptr<PointerEvent> LongPressSubscribeHandlerTest::SetupSingleFingerDownEvent()
59 {
60 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
61 CHKPP(pointerEvent);
62 PointerEvent::PointerItem item;
63 item.SetPointerId(0);
64 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
65 int32_t downX = 100;
66 int32_t downY = 200;
67 item.SetDisplayX(downX);
68 item.SetDisplayY(downY);
69 item.SetPressed(true);
70 pointerEvent->SetPointerId(0);
71 pointerEvent->AddPointerItem(item);
72 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
73 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
74 return pointerEvent;
75 }
76
SetupDoubleFingerDownEvent()77 std::shared_ptr<PointerEvent> LongPressSubscribeHandlerTest::SetupDoubleFingerDownEvent()
78 {
79 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
80 CHKPP(pointerEvent);
81 PointerEvent::PointerItem item;
82 PointerEvent::PointerItem item2;
83 item.SetPointerId(0);
84 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
85 int32_t downX = 100;
86 int32_t downY = 200;
87 item.SetDisplayX(downX);
88 item.SetDisplayY(downY);
89 item.SetPressed(true);
90 item.SetDownTime(0);
91 pointerEvent->SetPointerId(0);
92 pointerEvent->AddPointerItem(item);
93
94 item2.SetPointerId(1);
95 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
96 int32_t secondDownX = 120;
97 int32_t secondDownY = 220;
98 item2.SetDisplayX(secondDownX);
99 item2.SetDisplayY(secondDownY);
100 item2.SetPressed(true);
101 int64_t downTime = 100000;
102 item2.SetDownTime(downTime);
103 pointerEvent->SetPointerId(1);
104 pointerEvent->AddPointerItem(item2);
105 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
106 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
107 return pointerEvent;
108 }
109
SetupThreeFingerDownEvent()110 std::shared_ptr<PointerEvent> LongPressSubscribeHandlerTest::SetupThreeFingerDownEvent()
111 {
112 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
113 CHKPP(pointerEvent);
114 PointerEvent::PointerItem item;
115 PointerEvent::PointerItem item2;
116 PointerEvent::PointerItem item3;
117 item.SetPointerId(0);
118 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
119 int32_t downX = 100;
120 int32_t downY = 200;
121 item.SetDisplayX(downX);
122 item.SetDisplayY(downY);
123 item.SetPressed(true);
124 pointerEvent->SetPointerId(0);
125 pointerEvent->AddPointerItem(item);
126
127 item2.SetPointerId(1);
128 item2.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
129 int32_t secondDownX = 120;
130 int32_t secondDownY = 220;
131 item2.SetDisplayX(secondDownX);
132 item2.SetDisplayY(secondDownY);
133 item2.SetPressed(true);
134 pointerEvent->SetPointerId(1);
135 pointerEvent->AddPointerItem(item2);
136
137 int32_t pointerId2 = 2;
138 item3.SetPointerId(pointerId2);
139 item3.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
140 int32_t thirdDownX = 140;
141 int32_t thirdDownY = 240;
142 item3.SetDisplayX(thirdDownX);
143 item3.SetDisplayY(thirdDownY);
144 item3.SetPressed(true);
145 pointerEvent->SetPointerId(pointerId2);
146 pointerEvent->AddPointerItem(item3);
147
148 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
149 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
150 return pointerEvent;
151 }
152
153 /**
154 * @tc.name: LongPressSubscribeHandlerTest_SubscribeLongPressEvent_001
155 * @tc.desc: Verify invalid subscribeId when subscribe long press event
156 * @tc.type: Function
157 * @tc.require:
158 */
159 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_SubscribeLongPressEvent_001, TestSize.Level1)
160 {
161 CALL_TEST_DEBUG;
162 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
163 UDS_PID);
164 int32_t subscribeId = -1;
165 LongPressRequest longPressRequest {
166 .fingerCount = 1,
167 .duration = 300,
168 };
169 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
170 EXPECT_TRUE(ret < 0);
171 }
172
173 /**
174 * @tc.name: LongPressSubscribeHandlerTest_SubscribeLongPressEvent_002
175 * @tc.desc: Verify valid subscribeId when subscribe long press event
176 * @tc.type: Function
177 * @tc.require:
178 */
179 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_SubscribeLongPressEvent_002, TestSize.Level1)
180 {
181 CALL_TEST_DEBUG;
182 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
183 UDS_PID);
184 int32_t subscribeId = 0;
185 LongPressRequest longPressRequest {
186 .fingerCount = 1,
187 .duration = 300,
188 };
189 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
190 EXPECT_TRUE(ret >= 0);
191 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
192 EXPECT_TRUE(ret == RET_OK);
193 }
194
195 /**
196 * @tc.name: LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_001
197 * @tc.desc: Verify invalid subscribeId when unsubscribe long press event
198 * @tc.type: Function
199 * @tc.require:
200 */
201 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_001, TestSize.Level1)
202 {
203 CALL_TEST_DEBUG;
204 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
205 UDS_PID);
206 int32_t subscribeId = -1;
207 int32_t ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
208 EXPECT_TRUE(ret < 0);
209 }
210
211 /**
212 * @tc.name: LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_002
213 * @tc.desc: Verify invalid subscribeId when unsubscribe long press event
214 * @tc.type: Function
215 * @tc.require:
216 */
217 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_002, TestSize.Level1)
218 {
219 CALL_TEST_DEBUG;
220 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
221 UDS_PID);
222 int32_t subscribeId = 0;
223 LongPressRequest longPressRequest {
224 .fingerCount = 1,
225 .duration = 300,
226 };
227 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
228 EXPECT_TRUE(ret >= 0);
229 subscribeId = -1;
230 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
231 EXPECT_TRUE(ret == RET_ERR);
232 }
233
234 /**
235 * @tc.name: LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_003
236 * @tc.desc: Verify invalid sess when unsubscribe long press event
237 * @tc.type: Function
238 * @tc.require:
239 */
240 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_003, TestSize.Level1)
241 {
242 CALL_TEST_DEBUG;
243 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
244 UDS_PID);
245 int32_t subscribeId = 0;
246 LongPressRequest longPressRequest {
247 .fingerCount = 1,
248 .duration = 300,
249 };
250 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
251 EXPECT_TRUE(ret >= 0);
252 sess = nullptr;
253 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
254 EXPECT_TRUE(ret == ERROR_NULL_POINTER);
255 }
256
257 /**
258 * @tc.name: LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_004
259 * @tc.desc: Verify invalid sess and invalid subscribeId when unsubscribe long press event
260 * @tc.type: Function
261 * @tc.require:
262 */
263 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_004, TestSize.Level1)
264 {
265 CALL_TEST_DEBUG;
266 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
267 UDS_PID);
268 int32_t subscribeId = 0;
269 LongPressRequest longPressRequest {
270 .fingerCount = 1,
271 .duration = 300,
272 };
273 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
274 EXPECT_TRUE(ret >= 0);
275 sess = nullptr;
276 subscribeId = -1;
277 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
278 EXPECT_TRUE(ret == ERROR_NULL_POINTER);
279 }
280
281 /**
282 * @tc.name: LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_005
283 * @tc.desc: Verify !subscribers.empty()
284 * @tc.type: Function
285 * @tc.require:
286 */
287 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_UnsubscribeLongPressEvent_005, TestSize.Level1)
288 {
289 CALL_TEST_DEBUG;
290 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
291 UDS_PID);
292 int32_t subscribeId1 = 0;
293 LongPressRequest longPressRequest1 {
294 .fingerCount = 1,
295 .duration = 300,
296 };
297 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
298 EXPECT_TRUE(ret >= 0);
299
300 int32_t subscribeId2 = 1;
301 LongPressRequest longPressRequest2 {
302 .fingerCount = 1,
303 .duration = 900,
304 };
305 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
306 EXPECT_TRUE(ret >= 0);
307
308 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
309 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
310 }
311
312 /**
313 * @tc.name: LongPressSubscribeHandlerTest_AddDurationTimer_001
314 * @tc.desc: Verify durationTimer.duration == duration
315 * @tc.type: Function
316 * @tc.require:
317 */
318 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_AddDurationTimer_001, TestSize.Level1)
319 {
320 CALL_TEST_DEBUG;
321 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
322 UDS_PID);
323 int32_t subscribeId1 = 0;
324 LongPressRequest longPressRequest1 {
325 .fingerCount = 1,
326 .duration = 300,
327 };
328 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
329 EXPECT_TRUE(ret >= 0);
330
331 int32_t subscribeId2 = 1;
332 LongPressRequest longPressRequest2 {
333 .fingerCount = 2,
334 .duration = 300,
335 };
336 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
337 EXPECT_TRUE(ret >= 0);
338
339 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
340 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
341 }
342
343 /**
344 * @tc.name: LongPressSubscribeHandlerTest_RemoveDurationTimer_001
345 * @tc.desc: Verify durationTimer.duration == duration
346 * @tc.type: Function
347 * @tc.require:
348 */
349 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_RemoveDurationTimer_001, TestSize.Level1)
350 {
351 CALL_TEST_DEBUG;
352 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
353 UDS_PID);
354 int32_t subscribeId1 = 0;
355 LongPressRequest longPressRequest1 {
356 .fingerCount = 1,
357 .duration = 300,
358 };
359 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
360 EXPECT_TRUE(ret >= 0);
361
362 int32_t subscribeId2 = 1;
363 LongPressRequest longPressRequest2 {
364 .fingerCount = 2,
365 .duration = 300,
366 };
367 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
368 EXPECT_TRUE(ret >= 0);
369
370 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
371 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
372 }
373
374 /**
375 * @tc.name: LongPressSubscribeHandlerTest_RemoveDurationTimer_002
376 * @tc.desc: Verify it->first.second == duration && !it->second.empty()
377 * @tc.type: Function
378 * @tc.require:
379 */
380 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_RemoveDurationTimer_002, TestSize.Level1)
381 {
382 CALL_TEST_DEBUG;
383 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
384 UDS_PID);
385 int32_t subscribeId1 = 0;
386 LongPressRequest longPressRequest1 {
387 .fingerCount = 1,
388 .duration = 300,
389 };
390 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
391 EXPECT_TRUE(ret >= 0);
392
393 int32_t subscribeId2 = 1;
394 LongPressRequest longPressRequest2 {
395 .fingerCount = 1,
396 .duration = 300,
397 };
398 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
399 EXPECT_TRUE(ret >= 0);
400
401 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
402 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
403 }
404
405 /**
406 * @tc.name: LongPressSubscribeHandlerTest_RemoveDurationTimer_003
407 * @tc.desc: Verify it->first.second != duration && !it->second.empty()
408 * @tc.type: Function
409 * @tc.require:
410 */
411 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_RemoveDurationTimer_003, TestSize.Level1)
412 {
413 CALL_TEST_DEBUG;
414 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
415 UDS_PID);
416 int32_t subscribeId1 = 0;
417 LongPressRequest longPressRequest1 {
418 .fingerCount = 1,
419 .duration = 300,
420 };
421 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
422 EXPECT_TRUE(ret >= 0);
423
424 int32_t subscribeId2 = 1;
425 LongPressRequest longPressRequest2 {
426 .fingerCount = 1,
427 .duration = 900,
428 };
429 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
430 EXPECT_TRUE(ret >= 0);
431
432 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
433 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
434 }
435
436 /**
437 * @tc.name: LongPressSubscribeHandlerTest_OnSubscribeLongPressEvent_001
438 * @tc.desc: Verify subscriberInfos_.find(pair) == subscriberInfos_.end()
439 * @tc.type: Function
440 * @tc.require:
441 */
442 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSubscribeLongPressEvent_001, TestSize.Level1)
443 {
444 CALL_TEST_DEBUG;
445 int32_t fingerCount = 1;
446 int32_t duration = 300;
447 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressEvent(fingerCount, duration));
448 }
449
450 /**
451 * @tc.name: LongPressSubscribeHandlerTest_OnSubscribeLongPressEvent_002
452 * @tc.desc: Verify subscriberInfos_.find(pair) != subscriberInfos_.end()
453 * @tc.type: Function
454 * @tc.require:
455 */
456 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSubscribeLongPressEvent_002, TestSize.Level1)
457 {
458 CALL_TEST_DEBUG;
459 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
460 UDS_PID);
461 int32_t subscribeId1 = 0;
462 LongPressRequest longPressRequest1 {
463 .fingerCount = 1,
464 .duration = 300,
465 };
466 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
467 EXPECT_TRUE(ret >= 0);
468 int32_t fingerCount = 1;
469 int32_t duration = 300;
470 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressEvent(fingerCount, duration));
471
472 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
473 }
474
475 /**
476 * @tc.name: LongPressSubscribeHandlerTest_InsertSubScriber_001
477 * @tc.desc: Verify subscriber->sess_ != nullptr && sub->id_ == subscriber->id_ && sub->sess_ == subscriber->sess
478 * @tc.type: Function
479 * @tc.require:
480 */
481 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_InsertSubScriber_001, TestSize.Level1)
482 {
483 CALL_TEST_DEBUG;
484 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
485 UDS_PID);
486 int32_t subscribeId1 = 0;
487 LongPressRequest longPressRequest1 {
488 .fingerCount = 1,
489 .duration = 300,
490 };
491 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId1, longPressRequest1);
492 EXPECT_TRUE(ret >= 0);
493
494 int32_t subscribeId2 = 0;
495 LongPressRequest longPressRequest2 {
496 .fingerCount = 1,
497 .duration = 900,
498 };
499 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
500 EXPECT_TRUE(ret >= 0);
501
502 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId1));
503 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2));
504 }
505
506 /**
507 * @tc.name: LongPressSubscribeHandlerTest_InsertSubScriber_002
508 * @tc.desc: Verify subscriber->sess_ != nullptr && sub->id_ == subscriber->id_ && sub->sess_ != subscriber->sess
509 * @tc.type: Function
510 * @tc.require:
511 */
512 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_InsertSubScriber_002, TestSize.Level1)
513 {
514 CALL_TEST_DEBUG;
515 SessionPtr sess1 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
516 UDS_PID);
517 int32_t subscribeId1 = 0;
518 LongPressRequest longPressRequest1 {
519 .fingerCount = 1,
520 .duration = 300,
521 };
522 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess1, subscribeId1, longPressRequest1);
523 EXPECT_TRUE(ret >= 0);
524
525 SessionPtr sess2 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
526 UDS_PID);
527 int32_t subscribeId2 = 0;
528 LongPressRequest longPressRequest2 {
529 .fingerCount = 1,
530 .duration = 900,
531 };
532 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess2, subscribeId2, longPressRequest2);
533 EXPECT_TRUE(ret >= 0);
534
535 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess1, subscribeId1));
536 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess2, subscribeId2));
537 }
538
539 /**
540 * @tc.name: LongPressSubscribeHandlerTest_InsertSubScriber_003
541 * @tc.desc: Verify subscriber->sess_ != nullptr && sub->id_ != subscriber->id_ && sub->sess_ != subscriber->sess
542 * @tc.type: Function
543 * @tc.require:
544 */
545 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_InsertSubScriber_003, TestSize.Level1)
546 {
547 CALL_TEST_DEBUG;
548 SessionPtr sess1 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
549 UDS_PID);
550 int32_t subscribeId1 = 0;
551 LongPressRequest longPressRequest1 {
552 .fingerCount = 1,
553 .duration = 300,
554 };
555 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess1, subscribeId1, longPressRequest1);
556 EXPECT_TRUE(ret >= 0);
557
558 SessionPtr sess2 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
559 UDS_PID);
560 int32_t subscribeId2 = 1;
561 LongPressRequest longPressRequest2 {
562 .fingerCount = 1,
563 .duration = 900,
564 };
565 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess2, subscribeId2, longPressRequest2);
566 EXPECT_TRUE(ret >= 0);
567
568 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess1, subscribeId1));
569 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess2, subscribeId2));
570 }
571
572 /**
573 * @tc.name: LongPressSubscribeHandlerTest_OnSessionDelete_001
574 * @tc.desc: Verify (*iter)->sess_ == sess and subscribers.empty()
575 * @tc.type: Function
576 * @tc.require:
577 */
578 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSessionDelete_001, TestSize.Level1)
579 {
580 CALL_TEST_DEBUG;
581 SessionPtr sess1 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
582 UDS_PID);
583 int32_t subscribeId1 = 0;
584 LongPressRequest longPressRequest1 {
585 .fingerCount = 1,
586 .duration = 300,
587 };
588 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess1, subscribeId1, longPressRequest1);
589 EXPECT_TRUE(ret >= 0);
590
591 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSessionDelete(sess1));
592
593 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess1, subscribeId1));
594 }
595
596 /**
597 * @tc.name: LongPressSubscribeHandlerTest_OnSessionDelete_002
598 * @tc.desc: Verify (*iter)->sess_ != sess and !subscribers.empty()
599 * @tc.type: Function
600 * @tc.require:
601 */
602 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSessionDelete_002, TestSize.Level1)
603 {
604 CALL_TEST_DEBUG;
605 SessionPtr sess1 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
606 UDS_PID);
607 int32_t subscribeId1 = 0;
608 LongPressRequest longPressRequest1 {
609 .fingerCount = 1,
610 .duration = 300,
611 };
612 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess1, subscribeId1, longPressRequest1);
613 EXPECT_TRUE(ret >= 0);
614
615 SessionPtr sess2 = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
616 UDS_PID);
617 int32_t subscribeId2 = 1;
618 LongPressRequest longPressRequest2 {
619 .fingerCount = 1,
620 .duration = 300,
621 };
622 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess2, subscribeId2, longPressRequest2);
623 EXPECT_TRUE(ret >= 0);
624
625 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSessionDelete(sess2));
626 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSessionDelete(sess1));
627
628 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess1, subscribeId1));
629 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess2, subscribeId2));
630 }
631
632 /**
633 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureDownEvent_001
634 * @tc.desc: Verify if (fingerCount > 0 && fingerCount <= TwoFingerGesture::MAX_TOUCH_NUM)
635 * @tc.type: Function
636 * @tc.require:
637 */
638 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureDownEvent_001,
639 TestSize.Level1)
640 {
641 CALL_TEST_DEBUG;
642 auto pointerEvent = SetupZeroFingerDownEvent();
643 ASSERT_TRUE(pointerEvent != nullptr);
644 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
645
646 pointerEvent = SetupSingleFingerDownEvent();
647 ASSERT_TRUE(pointerEvent != nullptr);
648 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
649
650 pointerEvent = SetupDoubleFingerDownEvent();
651 ASSERT_TRUE(pointerEvent != nullptr);
652 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
653
654 pointerEvent = SetupThreeFingerDownEvent();
655 ASSERT_TRUE(pointerEvent != nullptr);
656 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
657 }
658
659 /**
660 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureDownEvent_002
661 * @tc.desc: Verify if (pressTimeInterval > TWO_FINGERS_TIME_LIMIT)
662 * @tc.type: Function
663 * @tc.require:
664 */
665 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureDownEvent_002,
666 TestSize.Level1)
667 {
668 CALL_TEST_DEBUG;
669 auto pointerEvent = SetupDoubleFingerDownEvent();
670 ASSERT_TRUE(pointerEvent != nullptr);
671 auto fingerCount = pointerEvent->GetPointerIds().size();
672 ASSERT_TRUE(fingerCount == 2);
673 PointerEvent::PointerItem item;
674 int32_t pointerId = 1;
675 bool result = pointerEvent->GetPointerItem(pointerId, item);
676 ASSERT_TRUE(result);
677 item.SetDownTime(item.GetDownTime() + 150000);
678 pointerEvent->UpdatePointerItem(pointerId, item);
679 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
680 }
681
682 /**
683 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_001
684 * @tc.desc: Verify if (isAllTimerClosed)
685 * @tc.type: Function
686 * @tc.require:
687 */
688 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_001,
689 TestSize.Level1)
690 {
691 CALL_TEST_DEBUG;
692 auto pointerEvent = SetupThreeFingerDownEvent();
693 ASSERT_TRUE(pointerEvent != nullptr);
694 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = true;
695 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureMoveEvent(pointerEvent));
696 }
697
698 /**
699 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_002
700 * @tc.desc: Verify if (fingerCount > static_cast<size_t>(TWO_FINGER))
701 * @tc.type: Function
702 * @tc.require:
703 */
704 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_002,
705 TestSize.Level1)
706 {
707 CALL_TEST_DEBUG;
708 auto pointerEvent = SetupThreeFingerDownEvent();
709 ASSERT_TRUE(pointerEvent != nullptr);
710 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
711 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureMoveEvent(pointerEvent));
712 }
713
714 /**
715 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_003
716 * @tc.desc: Verify if (pos == std::end(fingerGesture_.touches))
717 * @tc.type: Function
718 * @tc.require:
719 */
720 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_003,
721 TestSize.Level1)
722 {
723 CALL_TEST_DEBUG;
724 auto pointerEvent = SetupSingleFingerDownEvent();
725 ASSERT_TRUE(pointerEvent != nullptr);
726 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
727
728 PointerEvent::PointerItem item;
729 int32_t pointerId = 0;
730 bool result = pointerEvent->GetPointerItem(pointerId, item);
731 ASSERT_TRUE(result);
732 item.SetPointerId(item.GetPointerId() + 1);
733 pointerEvent->UpdatePointerItem(pointerId, item);
734
735 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
736 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureMoveEvent(pointerEvent));
737 }
738
739 /**
740 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_004
741 * @tc.desc: Verify if (pos == std::end(fingerGesture_.touches))
742 * @tc.type: Function
743 * @tc.require:
744 */
745 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_004,
746 TestSize.Level1)
747 {
748 CALL_TEST_DEBUG;
749 auto pointerEvent = SetupSingleFingerDownEvent();
750 ASSERT_TRUE(pointerEvent != nullptr);
751 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
752
753 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
754 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureMoveEvent(pointerEvent));
755 }
756
757 /**
758 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_005
759 * @tc.desc: Verify if (moveDistance > TOUCH_MOVE_THRESHOLD)
760 * @tc.type: Function
761 * @tc.require:
762 */
763 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureMoveEvent_005,
764 TestSize.Level1)
765 {
766 CALL_TEST_DEBUG;
767 auto pointerEvent = SetupSingleFingerDownEvent();
768 ASSERT_TRUE(pointerEvent != nullptr);
769 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
770
771 PointerEvent::PointerItem item;
772 int32_t pointerId = 0;
773 bool result = pointerEvent->GetPointerItem(pointerId, item);
774 ASSERT_TRUE(result);
775 item.SetDisplayX(item.GetDisplayX() + 100);
776 pointerEvent->UpdatePointerItem(pointerId, item);
777
778 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
779 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureMoveEvent(pointerEvent));
780 }
781
782 /**
783 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_001
784 * @tc.desc: Verify if (isAllTimerClosed)
785 * @tc.type: Function
786 * @tc.require:
787 */
788 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_001,
789 TestSize.Level1)
790 {
791 CALL_TEST_DEBUG;
792 auto pointerEvent = SetupSingleFingerDownEvent();
793 ASSERT_TRUE(pointerEvent != nullptr);
794 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = true;
795 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureUpEvent(pointerEvent));
796 }
797
798 /**
799 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_002
800 * @tc.desc: Verify if (touchEvent->GetPointerIds().size() > static_cast<size_t>(TWO_FINGER))
801 * @tc.type: Function
802 * @tc.require:
803 */
804 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_002,
805 TestSize.Level1)
806 {
807 CALL_TEST_DEBUG;
808 auto pointerEvent = SetupThreeFingerDownEvent();
809 ASSERT_TRUE(pointerEvent != nullptr);
810 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
811 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureUpEvent(pointerEvent));
812 }
813
814 /**
815 * @tc.name: LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_003
816 * @tc.desc: Verify if (touchEvent->GetPointerIds().size() > static_cast<size_t>(TWO_FINGER))
817 * @tc.type: Function
818 * @tc.require:
819 */
820 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_HandleFingerGestureUpEvent_003,
821 TestSize.Level1)
822 {
823 CALL_TEST_DEBUG;
824 auto pointerEvent = SetupDoubleFingerDownEvent();
825 ASSERT_TRUE(pointerEvent != nullptr);
826 LONG_PRESS_EVENT_HANDLER->isAllTimerClosed = false;
827 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureUpEvent(pointerEvent));
828 }
829
830 /**
831 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_001
832 * @tc.desc: Verify if (index < 0 || index > static_cast<size_t>(ONE_FINGER))
833 * @tc.type: Function
834 * @tc.require:
835 */
836 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_001,
837 TestSize.Level1)
838 {
839 CALL_TEST_DEBUG;
840 auto pointerEvent = SetupThreeFingerDownEvent();
841 ASSERT_TRUE(pointerEvent != nullptr);
842 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
843
844 pointerEvent = SetupZeroFingerDownEvent();
845 ASSERT_TRUE(pointerEvent != nullptr);
846 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
847 }
848
849 /**
850 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_002
851 * @tc.desc: Verify if (!durationTimers_.empty())
852 * @tc.type: Function
853 * @tc.require:
854 */
855 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_002,
856 TestSize.Level1)
857 {
858 CALL_TEST_DEBUG;
859 auto pointerEvent = SetupSingleFingerDownEvent();
860 ASSERT_TRUE(pointerEvent != nullptr);
861 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
862 }
863
864 /**
865 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_003
866 * @tc.desc: Verify if (!durationTimers_.empty())
867 * @tc.type: Function
868 * @tc.require:
869 */
870 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_003,
871 TestSize.Level1)
872 {
873 CALL_TEST_DEBUG;
874 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
875 UDS_PID);
876 int32_t subscribeId = 0;
877 LongPressRequest longPressRequest {
878 .fingerCount = 1,
879 .duration = 300,
880 };
881 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
882 EXPECT_TRUE(ret >= 0);
883
884 auto pointerEvent = SetupSingleFingerDownEvent();
885 PointerEvent::PointerItem item;
886 int32_t pointerId = 0;
887 bool result = pointerEvent->GetPointerItem(pointerId, item);
888 ASSERT_TRUE(result);
889 item.SetDownTime(0);
890 pointerEvent->UpdatePointerItem(pointerId, item);
891 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
892
893 int64_t downTime = 100000;
894 item.SetDownTime(downTime);
895 pointerEvent->UpdatePointerItem(pointerId, item);
896 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
897
898 downTime = 400000;
899 item.SetDownTime(downTime);
900 pointerEvent->UpdatePointerItem(pointerId, item);
901 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
902
903 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
904 EXPECT_TRUE(ret == RET_OK);
905 }
906
907 /**
908 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_004
909 * @tc.desc: Verify if (tempSubs.size() < static_cast<size_t>(TWO_FINGER))
910 * @tc.type: Function
911 * @tc.require:
912 */
913 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureCancelEvent_004,
914 TestSize.Level1)
915 {
916 CALL_TEST_DEBUG;
917 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
918 UDS_PID);
919 int32_t subscribeId = 0;
920 LongPressRequest longPressRequest { .fingerCount = 1, .duration = 300, };
921 int32_t subscribeId2 = 0;
922 LongPressRequest longPressRequest2 { .fingerCount = 1, .duration = 900, };
923 int32_t subscribeId3 = 0;
924 LongPressRequest longPressRequest3 { .fingerCount = 1, .duration = 1500, };
925 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
926 EXPECT_TRUE(ret >= 0);
927 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId2, longPressRequest2);
928 EXPECT_TRUE(ret >= 0);
929 ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId3, longPressRequest3);
930 EXPECT_TRUE(ret >= 0);
931 auto pointerEvent = SetupSingleFingerDownEvent();
932 PointerEvent::PointerItem item;
933 int32_t pointerId = 0;
934 bool result = pointerEvent->GetPointerItem(pointerId, item);
935 ASSERT_TRUE(result);
936 item.SetDownTime(0);
937 pointerEvent->UpdatePointerItem(pointerId, item);
938 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->HandleFingerGestureDownEvent(pointerEvent));
939 int64_t downTime = 400000;
940 item.SetDownTime(downTime);
941 pointerEvent->UpdatePointerItem(pointerId, item);
942 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
943 downTime = 1000000;
944 item.SetDownTime(downTime);
945 pointerEvent->UpdatePointerItem(pointerId, item);
946 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
947 downTime = 1600000;
948 item.SetDownTime(downTime);
949 pointerEvent->UpdatePointerItem(pointerId, item);
950 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->CheckFingerGestureCancelEvent(pointerEvent));
951 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
952 EXPECT_TRUE(ret == RET_OK);
953 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId2);
954 EXPECT_TRUE(ret == RET_OK);
955 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId3);
956 EXPECT_TRUE(ret == RET_OK);
957 }
958
959 /**
960 * @tc.name: LongPressSubscribeHandlerTest_OnSubscribeLongPressCancelEvent_001
961 * @tc.desc: Verify if (it == sessManager_.end())
962 * @tc.type: Function
963 * @tc.require:
964 */
965 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSubscribeLongPressCancelEvent_001,
966 TestSize.Level1)
967 {
968 CALL_TEST_DEBUG;
969 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
970 UDS_PID);
971
972 int32_t fingerCount = 1;
973 int32_t duration = 300;
974 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressCancelEvent(sess, fingerCount, duration));
975 }
976
977 /**
978 * @tc.name: LongPressSubscribeHandlerTest_OnSubscribeLongPressCancelEvent_002
979 * @tc.desc: Verify if (subscriber->fingerCount_ == fingerCount && subscriber->duration_ == duration)
980 * @tc.type: Function
981 * @tc.require:
982 */
983 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_OnSubscribeLongPressCancelEvent_002,
984 TestSize.Level1)
985 {
986 CALL_TEST_DEBUG;
987 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
988 UDS_PID);
989 int32_t subscribeId = 0;
990 LongPressRequest longPressRequest {
991 .fingerCount = 1,
992 .duration = 300,
993 };
994 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
995 EXPECT_TRUE(ret >= 0);
996
997 int32_t fingerCount = 1;
998 int32_t duration = 300;
999 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressCancelEvent(sess, fingerCount, duration));
1000
1001 fingerCount = 2;
1002 duration = 300;
1003 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressCancelEvent(sess, fingerCount, duration));
1004
1005 fingerCount = 1;
1006 duration = 900;
1007 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressCancelEvent(sess, fingerCount, duration));
1008
1009 fingerCount = 2;
1010 duration = 900;
1011 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->OnSubscribeLongPressCancelEvent(sess, fingerCount, duration));
1012
1013 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
1014 EXPECT_TRUE(ret == RET_OK);
1015 }
1016
1017 /**
1018 * @tc.name: LongPressSubscribeHandlerTest_StartFingerGesture_001
1019 * @tc.desc: Verify if (!CheckFingerGestureAction(fingerCount))
1020 * @tc.type: Function
1021 * @tc.require:
1022 */
1023 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_StartFingerGesture_001,
1024 TestSize.Level1)
1025 {
1026 CALL_TEST_DEBUG;
1027 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
1028 UDS_PID);
1029 int32_t subscribeId = 0;
1030 LongPressRequest longPressRequest {
1031 .fingerCount = 1,
1032 .duration = 300,
1033 };
1034 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
1035 EXPECT_TRUE(ret >= 0);
1036
1037 int32_t fingerCount = 2;
1038 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->StartFingerGesture(fingerCount));
1039
1040 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
1041 EXPECT_TRUE(ret == RET_OK);
1042 }
1043
1044 /**
1045 * @tc.name: LongPressSubscribeHandlerTest_StartFingerGesture_002
1046 * @tc.desc: Verify if (!CheckFingerGestureAction(fingerCount))
1047 * @tc.type: Function
1048 * @tc.require:
1049 */
1050 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_StartFingerGesture_002,
1051 TestSize.Level1)
1052 {
1053 CALL_TEST_DEBUG;
1054 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
1055 UDS_PID);
1056 int32_t subscribeId = 0;
1057 LongPressRequest longPressRequest {
1058 .fingerCount = 1,
1059 .duration = 300,
1060 };
1061 int32_t ret = LONG_PRESS_EVENT_HANDLER->SubscribeLongPressEvent(sess, subscribeId, longPressRequest);
1062 EXPECT_TRUE(ret >= 0);
1063
1064 DisplayInfo displayInfo;
1065 displayInfo.dpi = 320;
1066 displayInfo.width = 1260;
1067 displayInfo.height = 2720;
1068 displayInfo.uniq = "default0";
1069 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1070 inputWindowsManager->displayGroupInfo_.displaysInfo.push_back(displayInfo);
1071 IInputWindowsManager::instance_ = inputWindowsManager;
1072 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1073 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1074 int32_t fingerCount = 1;
1075 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->StartFingerGesture(fingerCount));
1076
1077 ret = LONG_PRESS_EVENT_HANDLER->UnsubscribeLongPressEvent(sess, subscribeId);
1078 EXPECT_TRUE(ret == RET_OK);
1079 }
1080
1081 /**
1082 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureAction_001
1083 * @tc.desc: Verify if (firstFinger.x <= leftLimit || firstFinger.x >= rightLimit ||
1084 * firstFinger.y <= topLimit || firstFinger.y >= bottomLimit)
1085 * @tc.type: Function
1086 * @tc.require:
1087 */
1088 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureAction_001,
1089 TestSize.Level1)
1090 {
1091 CALL_TEST_DEBUG;
1092 DisplayInfo displayInfo;
1093 displayInfo.dpi = 320;
1094 displayInfo.width = 1260;
1095 displayInfo.height = 2720;
1096 displayInfo.uniq = "default0";
1097 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1098 inputWindowsManager->displayGroupInfo_.displaysInfo.push_back(displayInfo);
1099 IInputWindowsManager::instance_ = inputWindowsManager;
1100 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1101 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1102 int32_t fingerCount = 1;
1103 bool ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1104 EXPECT_EQ(ret, true);
1105
1106 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 20;
1107 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1108 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1109 EXPECT_EQ(ret, false);
1110
1111 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 1250;
1112 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1113 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1114 EXPECT_EQ(ret, false);
1115
1116 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1117 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 10;
1118 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1119 EXPECT_EQ(ret, false);
1120
1121 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1122 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 2700;
1123 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1124 EXPECT_EQ(ret, false);
1125 }
1126
1127 /**
1128 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureAction_002
1129 * @tc.desc: Verify if (secondFinger.x <= leftLimit || secondFinger.x >= rightLimit ||
1130 * secondFinger.y <= topLimit || secondFinger.y >= bottomLimit)
1131 * @tc.type: Function
1132 * @tc.require:
1133 */
1134 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureAction_002,
1135 TestSize.Level1)
1136 {
1137 CALL_TEST_DEBUG;
1138 DisplayInfo displayInfo;
1139 displayInfo.dpi = 320;
1140 displayInfo.width = 1260;
1141 displayInfo.height = 2720;
1142 displayInfo.uniq = "default0";
1143 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1144 inputWindowsManager->displayGroupInfo_.displaysInfo.push_back(displayInfo);
1145 IInputWindowsManager::instance_ = inputWindowsManager;
1146 int32_t fingerCount = 2;
1147 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1148 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1149
1150 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 800;
1151 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 600;
1152 bool ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1153 EXPECT_EQ(ret, true);
1154
1155 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 10;
1156 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 600;
1157 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1158 EXPECT_EQ(ret, false);
1159
1160 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 1250;
1161 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 600;
1162 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1163 EXPECT_EQ(ret, false);
1164
1165 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 600;
1166 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 10;
1167 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1168 EXPECT_EQ(ret, false);
1169
1170 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 600;
1171 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 2710;
1172 ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1173 EXPECT_EQ(ret, false);
1174 }
1175
1176 /**
1177 * @tc.name: LongPressSubscribeHandlerTest_CheckFingerGestureAction_003
1178 * @tc.desc: Verify if (distance < ConvertVPToPX(TWO_FINGERS_DISTANCE_LIMIT))
1179 * @tc.type: Function
1180 * @tc.require:
1181 */
1182 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_CheckFingerGestureAction_003,
1183 TestSize.Level1)
1184 {
1185 CALL_TEST_DEBUG;
1186 DisplayInfo displayInfo;
1187 displayInfo.dpi = 320;
1188 displayInfo.width = 1260;
1189 displayInfo.height = 2720;
1190 displayInfo.uniq = "default0";
1191 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1192 inputWindowsManager->displayGroupInfo_.displaysInfo.push_back(displayInfo);
1193 IInputWindowsManager::instance_ = inputWindowsManager;
1194 int32_t fingerCount = 2;
1195 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].x = 600;
1196 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[0].y = 600;
1197
1198 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].x = 610;
1199 LONG_PRESS_EVENT_HANDLER->fingerGesture_.touches[1].y = 600;
1200 bool ret = LONG_PRESS_EVENT_HANDLER->CheckFingerGestureAction(fingerCount);
1201 EXPECT_EQ(ret, false);
1202 }
1203
1204 /**
1205 * @tc.name: LongPressSubscribeHandlerTest_InitSessionDeleteCallback_001
1206 * @tc.desc: Verify if (callbackInitialized_)
1207 * @tc.type: Function
1208 * @tc.require:
1209 */
1210 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_InitSessionDeleteCallback_001,
1211 TestSize.Level1)
1212 {
1213 CALL_TEST_DEBUG;
1214 LONG_PRESS_EVENT_HANDLER->callbackInitialized_ = true;
1215 bool ret = LONG_PRESS_EVENT_HANDLER->InitSessionDeleteCallback();
1216 EXPECT_EQ(ret, true);
1217 }
1218
1219 /**
1220 * @tc.name: LongPressSubscribeHandlerTest_InitSessionDeleteCallback_002
1221 * @tc.desc: Verify if (callbackInitialized_)
1222 * @tc.type: Function
1223 * @tc.require:
1224 */
1225 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_InitSessionDeleteCallback_002,
1226 TestSize.Level1)
1227 {
1228 CALL_TEST_DEBUG;
1229 LONG_PRESS_EVENT_HANDLER->callbackInitialized_ = false;
1230 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->InitSessionDeleteCallback());
1231 }
1232
1233 /**
1234 * @tc.name: LongPressSubscribeHandlerTest_ConvertVPToPX_001
1235 * @tc.desc: Verify if (vp <= 0)
1236 * @tc.type: Function
1237 * @tc.require:
1238 */
1239 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_ConvertVPToPX_001,
1240 TestSize.Level1)
1241 {
1242 CALL_TEST_DEBUG;
1243 int32_t vp = -1;
1244 int32_t ret = LONG_PRESS_EVENT_HANDLER->ConvertVPToPX(vp);
1245 ASSERT_EQ(ret, 0);
1246 ret = LONG_PRESS_EVENT_HANDLER->ConvertVPToPX(vp);
1247 }
1248
1249 /**
1250 * @tc.name: LongPressSubscribeHandlerTest_ConvertVPToPX_002
1251 * @tc.desc: Verify if (dpi <= 0)
1252 * @tc.type: Function
1253 * @tc.require:
1254 */
1255 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_ConvertVPToPX_002,
1256 TestSize.Level1)
1257 {
1258 CALL_TEST_DEBUG;
1259 int32_t vp = 5;
1260 DisplayInfo displayInfo;
1261 displayInfo.id = 1;
1262 displayInfo.x = 2;
1263 displayInfo.y = 3;
1264 displayInfo.width = 4;
1265 displayInfo.height = 5;
1266 displayInfo.dpi = -1;
1267 displayInfo.uniq = "default0";
1268 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1269 inputWindowsManager->displayGroupInfo_.displaysInfo.push_back(displayInfo);
1270 IInputWindowsManager::instance_ = inputWindowsManager;
1271 int32_t ret = LONG_PRESS_EVENT_HANDLER->ConvertVPToPX(vp);
1272 ASSERT_EQ(ret, 0);
1273 }
1274
1275 /**
1276 * @tc.name: LongPressSubscribeHandlerTest_GetBundleName_001
1277 * @tc.desc: Verify if (userid < 0);
1278 * @tc.type: Function
1279 * @tc.require:
1280 */
1281 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_GetBundleName_001,
1282 TestSize.Level1)
1283 {
1284 CALL_TEST_DEBUG;
1285 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1286 int32_t currentUserId = -1;
1287 inputWindowsManager->SetCurrentUser(currentUserId);
1288 IInputWindowsManager::instance_ = inputWindowsManager;
1289 std::string bundleName = "test";
1290 int32_t windowPid = 0;
1291 int32_t ret = LONG_PRESS_EVENT_HANDLER->GetBundleName(bundleName, windowPid);
1292 ASSERT_EQ(ret, RET_ERR);
1293 }
1294
1295 /**
1296 * @tc.name: LongPressSubscribeHandlerTest_NotifySubscriber_001
1297 * @tc.desc: Verify if (subscriber->sess_ == nullptr)
1298 * @tc.type: Function
1299 * @tc.require:
1300 */
1301 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_NotifySubscriber_001,
1302 TestSize.Level1)
1303 {
1304 CALL_TEST_DEBUG;
1305 std::shared_ptr<Subscriber> subscriber { nullptr };
1306 int32_t result = 0;
1307 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->NotifySubscriber(subscriber, result));
1308 }
1309
1310 /**
1311 * @tc.name: LongPressSubscribeHandlerTest_NotifySubscriber_002
1312 * @tc.desc: Verify if (windowPid == RET_ERR)
1313 * @tc.type: Function
1314 * @tc.require:
1315 */
1316 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_NotifySubscriber_002,
1317 TestSize.Level1)
1318 {
1319 CALL_TEST_DEBUG;
1320 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
1321 UDS_PID);
1322 int32_t subscribeId = 0;
1323 LongPressRequest longPressRequest {
1324 .fingerCount = 1,
1325 .duration = 300,
1326 };
1327 auto subscriber = std::make_shared<Subscriber>(subscribeId, sess, longPressRequest.fingerCount,
1328 longPressRequest.duration);
1329 auto pair = std::make_pair(longPressRequest.fingerCount, longPressRequest.duration);
1330 LONG_PRESS_EVENT_HANDLER->subscriberInfos_[pair].push_back(subscriber);
1331 int32_t result = 0;
1332 UDSServer* udsServer = new UDSServer();
1333 ASSERT_TRUE(udsServer != nullptr);
1334 InputHandler->udsServer_ = udsServer;
1335 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->NotifySubscriber(subscriber, result));
1336 }
1337
1338 /**
1339 * @tc.name: LongPressSubscribeHandlerTest_NotifySubscriber_003
1340 * @tc.desc: Verify if (GetBundleName(bundleName, windowPid) == RET_ERR)
1341 * @tc.type: Function
1342 * @tc.require:
1343 */
1344 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_NotifySubscriber_003,
1345 TestSize.Level1)
1346 {
1347 CALL_TEST_DEBUG;
1348 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
1349 UDS_PID);
1350 int32_t subscribeId = 0;
1351 LongPressRequest longPressRequest {
1352 .fingerCount = 1,
1353 .duration = 300,
1354 };
1355 auto subscriber = std::make_shared<Subscriber>(subscribeId, sess, longPressRequest.fingerCount,
1356 longPressRequest.duration);
1357 auto pair = std::make_pair(longPressRequest.fingerCount, longPressRequest.duration);
1358 LONG_PRESS_EVENT_HANDLER->subscriberInfos_[pair].push_back(subscriber);
1359 int32_t result = 0;
1360 UDSServer* udsServer = new UDSServer();
1361 ASSERT_TRUE(udsServer != nullptr);
1362 InputHandler->udsServer_ = udsServer;
1363 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->NotifySubscriber(subscriber, result));
1364 }
1365
1366 /**
1367 * @tc.name: LongPressSubscribeHandlerTest_NotifySubscriber_004
1368 * @tc.desc: Verify if (GetBundleName(bundleName, windowPid) == RET_ERR)
1369 * @tc.type: Function
1370 * @tc.require:
1371 */
1372 HWTEST_F(LongPressSubscribeHandlerTest, LongPressSubscribeHandlerTest_NotifySubscriber_004,
1373 TestSize.Level1)
1374 {
1375 CALL_TEST_DEBUG;
1376 SessionPtr sess = std::make_shared<UDSSession>("LongPressSubscribeHandlerTest", MODULE_TYPE, UDS_FD, UDS_UID,
1377 UDS_PID);
1378 int32_t subscribeId = 0;
1379 LongPressRequest longPressRequest {
1380 .fingerCount = 1,
1381 .duration = 300,
1382 };
1383
1384 WindowInfo windowInfo;
1385 windowInfo.id = 10000;
1386 auto inputWindowsManager = std::make_shared<InputWindowsManager>();
1387 inputWindowsManager->displayGroupInfo_.windowsInfo.push_back(windowInfo);
1388 IInputWindowsManager::instance_ = inputWindowsManager;
1389
1390 auto pointerEvent = SetupSingleFingerDownEvent();
1391 ASSERT_TRUE(pointerEvent != nullptr);
1392 PointerEvent::PointerItem item;
1393 int32_t pointerId = 0;
1394 bool ret = pointerEvent->GetPointerItem(pointerId, item);
1395 ASSERT_TRUE(ret);
1396 item.SetTargetWindowId(windowInfo.id);
1397 pointerEvent->UpdatePointerItem(pointerId, item);
1398 LONG_PRESS_EVENT_HANDLER->touchEvent_ = pointerEvent;
1399
1400 auto subscriber = std::make_shared<Subscriber>(subscribeId, sess, longPressRequest.fingerCount,
1401 longPressRequest.duration);
1402 auto pair = std::make_pair(longPressRequest.fingerCount, longPressRequest.duration);
1403 LONG_PRESS_EVENT_HANDLER->subscriberInfos_[pair].push_back(subscriber);
1404 int32_t result = 0;
1405 UDSServer* udsServer = new UDSServer();
1406 ASSERT_TRUE(udsServer != nullptr);
1407 InputHandler->udsServer_ = udsServer;
1408 ASSERT_NO_FATAL_FAILURE(LONG_PRESS_EVENT_HANDLER->NotifySubscriber(subscriber, result));
1409 }
1410 } // namespace MMI
1411 } // namespace OHOS