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