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 #include "input_event_builder_test.h"
16 #include "ddm_adapter.h"
17
18 #undef LOG_TAG
19 #define LOG_TAG "InputEventBuilderTest"
20
21 namespace OHOS {
22 namespace Msdp {
23 namespace DeviceStatus {
24 namespace Cooperate {
25 using namespace testing::ext;
26
27 namespace {
28 ContextService *g_instance = nullptr;
29 std::unique_ptr<IInputAdapter> input_;
30 std::unique_ptr<IPluginManager> pluginMgr_;
31 std::unique_ptr<IDSoftbusAdapter> dsoftbus_;
32 SocketSessionManager socketSessionMgr_;
33 InputEventBuilder *builder_ = {nullptr};
34 auto env_ = ContextService::GetInstance();
35 const std::string networkId_ = "1234";
36 } // namespace
37
ContextService()38 ContextService::ContextService()
39 {
40 ddm_ = std::make_unique<DDMAdapter>();
41 }
42
~ContextService()43 ContextService::~ContextService() {}
44
GetDelegateTasks()45 IDelegateTasks& ContextService::GetDelegateTasks()
46 {
47 return delegateTasks_;
48 }
49
GetDeviceManager()50 IDeviceManager& ContextService::GetDeviceManager()
51 {
52 return devMgr_;
53 }
54
GetTimerManager()55 ITimerManager& ContextService::GetTimerManager()
56 {
57 return timerMgr_;
58 }
59
GetDragManager()60 IDragManager& ContextService::GetDragManager()
61 {
62 return dragMgr_;
63 }
64
GetInstance()65 ContextService* ContextService::GetInstance()
66 {
67 static std::once_flag flag;
68 std::call_once(flag, [&]() {
69 ContextService *cooContext = new (std::nothrow) ContextService();
70 CHKPL(cooContext);
71 g_instance = cooContext;
72 });
73 return g_instance;
74 }
75
GetSocketSessionManager()76 ISocketSessionManager& ContextService::GetSocketSessionManager()
77 {
78 return socketSessionMgr_;
79 }
80
GetDDM()81 IDDMAdapter& ContextService::GetDDM()
82 {
83 return *ddm_;
84 }
85
GetPluginManager()86 IPluginManager& ContextService::GetPluginManager()
87 {
88 return *pluginMgr_;
89 }
90
GetInput()91 IInputAdapter& ContextService::GetInput()
92 {
93 return *input_;
94 }
95
GetDSoftbus()96 IDSoftbusAdapter& ContextService::GetDSoftbus()
97 {
98 return *dsoftbus_;
99 }
100
SetUpTestCase()101 void InputEventBuilderTest::SetUpTestCase()
102 {
103 ASSERT_NE(env_, nullptr);
104 builder_ = new InputEventBuilder(env_);
105 ASSERT_NE(builder_, nullptr);
106 dsoftbus_ = std::make_unique<DSoftbusAdapter>();
107 input_ = std::make_unique<InputAdapter>();
108 }
109
TearDownTestCase()110 void InputEventBuilderTest::TearDownTestCase()
111 {
112 delete builder_;
113 builder_ = nullptr;
114 }
115
SetUp()116 void InputEventBuilderTest::SetUp() {}
TearDown()117 void InputEventBuilderTest::TearDown() {}
118
119 /**
120 * @tc.name: EnableTest001
121 * @tc.desc: Test EnableTest001
122 * @tc.type: FUNC
123 */
124 HWTEST_F(InputEventBuilderTest, EnableTest001, TestSize.Level1)
125 {
126 CALL_TEST_DEBUG;
127 Context context(env_);
128 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
129 }
130
131 /**
132 * @tc.name: UpdateTest001
133 * @tc.desc: Test UpdateTest001
134 * @tc.type: FUNC
135 */
136 HWTEST_F(InputEventBuilderTest, UpdateTest001, TestSize.Level1)
137 {
138 CALL_TEST_DEBUG;
139 Context context(env_);
140 ASSERT_NO_FATAL_FAILURE(builder_->Update(context));
141 }
142
143 /**
144 * @tc.name: OnPacketTest001
145 * @tc.desc: Test OnPacketTest001
146 * @tc.type: FUNC
147 */
148 HWTEST_F(InputEventBuilderTest, OnPacketTest001, TestSize.Level1)
149 {
150 CALL_TEST_DEBUG;
151 builder_->remoteNetworkId_ = "12345";
152 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
153 bool ret = builder_->OnPacket(networkId_, packet);
154 ASSERT_EQ(ret, false);
155 }
156
157 /**
158 * @tc.name: OnPacketTest002
159 * @tc.desc: Test OnPacketTest002
160 * @tc.type: FUNC
161 */
162 HWTEST_F(InputEventBuilderTest, OnPacketTest002, TestSize.Level1)
163 {
164 CALL_TEST_DEBUG;
165 builder_->remoteNetworkId_ = "1234";
166 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
167 bool ret = builder_->OnPacket(networkId_, packet);
168 ASSERT_EQ(ret, true);
169 NetPacket packet1(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
170 ret = builder_->OnPacket(networkId_, packet1);
171 ASSERT_EQ(ret, true);
172 NetPacket packet2(MessageId::DSOFTBUS_RELAY_COOPERATE);
173 ret = builder_->OnPacket(networkId_, packet2);
174 ASSERT_EQ(ret, false);
175 }
176
177 /**
178 * @tc.name: OnPacketTest003
179 * @tc.desc: Test OnPacketTest003
180 * @tc.type: FUNC
181 */
182 HWTEST_F(InputEventBuilderTest, OnPacketTest003, TestSize.Level1)
183 {
184 CALL_TEST_DEBUG;
185 builder_->remoteNetworkId_ = "1234";
186 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
187 int32_t ret1 = InputEventSerialization::Marshalling(builder_->pointerEvent_, packet);
188 ASSERT_EQ(ret1, RET_OK);
189 bool ret = builder_->OnPacket(networkId_, packet);
190 ASSERT_EQ(ret, true);
191 }
192
193 /**
194 * @tc.name: InputEventBuilderTest_Freeze_001
195 * @tc.desc: Test the funcation Freeze
196 * @tc.type: FUNC
197 */
198 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Freeze_001, TestSize.Level1)
199 {
200 CALL_TEST_DEBUG;
201 builder_->enable_ = false;
202 ASSERT_NO_FATAL_FAILURE(builder_->Freeze());
203 builder_->enable_ = true;
204 ASSERT_NO_FATAL_FAILURE(builder_->Freeze());
205 }
206
207 /**
208 * @tc.name: InputEventBuilderTest_Thaw_001
209 * @tc.desc: Test the funcation Thaw
210 * @tc.type: FUNC
211 */
212 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Thaw_001, TestSize.Level1)
213 {
214 CALL_TEST_DEBUG;
215 builder_->enable_ = false;
216 ASSERT_NO_FATAL_FAILURE(builder_->Thaw());
217 builder_->enable_ = true;
218 ASSERT_NO_FATAL_FAILURE(builder_->Thaw());
219 }
220
221 /**
222 * @tc.name: InputEventBuilderTest_Enable_001
223 * @tc.desc: Test the funcation Enable
224 * @tc.type: FUNC
225 */
226 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_Enable_001, TestSize.Level1)
227 {
228 CALL_TEST_DEBUG;
229 Context context(env_);
230 builder_->enable_ = true;
231 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
232 builder_->enable_ = false;
233 ASSERT_NO_FATAL_FAILURE(builder_->Enable(context));
234 }
235
236 /**
237 * @tc.name: InputEventBuilderTest_UpdatePointerEvent_001
238 * @tc.desc: Test the funcation UpdatePointerEvent
239 * @tc.type: FUNC
240 */
241 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_UpdatePointerEvent_001, TestSize.Level1)
242 {
243 CALL_TEST_DEBUG;
244 auto pointerEvent = MMI::PointerEvent::Create();
245 ASSERT_NE(pointerEvent, nullptr);
246 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
247 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
248 MMI::PointerEvent::PointerItem pointerItem;
249 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
250 bool ret = builder_->UpdatePointerEvent(pointerEvent);
251 ASSERT_FALSE(ret);
252 }
253
254
255 /**
256 * @tc.name: InputEventBuilderTest_IsActive_001
257 * @tc.desc: Test the funcation IsActive
258 * @tc.type: FUNC
259 */
260 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_001, TestSize.Level1)
261 {
262 CALL_TEST_DEBUG;
263 auto pointerEvent = MMI::PointerEvent::Create();
264 ASSERT_NE(pointerEvent, nullptr);
265 MMI::PointerEvent::PointerItem pointerItem;
266 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
267 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
268 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
269 builder_->freezing_ = true;
270 builder_->IsActive(pointerEvent);
271 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_PULL_MOVE);
272 builder_->IsActive(pointerEvent);
273 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
274 bool ret = builder_->IsActive(pointerEvent);
275 ASSERT_TRUE(ret);
276 }
277
278 /**
279 * @tc.name: InputEventBuilderTest_IsActive_002
280 * @tc.desc: Test the funcation IsActive
281 * @tc.type: FUNC
282 */
283 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_002, TestSize.Level1)
284 {
285 CALL_TEST_DEBUG;
286 auto pointerEvent = MMI::PointerEvent::Create();
287 ASSERT_NE(pointerEvent, nullptr);
288 MMI::PointerEvent::PointerItem pointerItem;
289 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
290 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
291 builder_->freezing_ = true;
292 bool ret = builder_->IsActive(pointerEvent);
293 ASSERT_TRUE(ret);
294 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_PULL_MOVE);
295 ret = builder_->IsActive(pointerEvent);
296 ASSERT_TRUE(ret);
297 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
298 ret = builder_->IsActive(pointerEvent);
299 ASSERT_TRUE(ret);
300 }
301
302 /**
303 * @tc.name: InputEventBuilderTest_IsActive_003
304 * @tc.desc: Test the funcation IsActive
305 * @tc.type: FUNC
306 */
307 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_003, TestSize.Level1)
308 {
309 CALL_TEST_DEBUG;
310 auto pointerEvent = MMI::PointerEvent::Create();
311 ASSERT_NE(pointerEvent, nullptr);
312 MMI::PointerEvent::PointerItem pointerItem;
313 pointerItem.SetPointerId(1);
314 pointerEvent->AddPointerItem(pointerItem);
315 builder_->freezing_ = true;
316 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
317 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
318 bool ret = builder_->IsActive(pointerEvent);
319 ASSERT_FALSE(ret);
320 builder_->xDir_ = 1;
321 builder_->IsActive(pointerEvent);
322 builder_->movement_ = -1;
323 ret = builder_->IsActive(pointerEvent);
324 ASSERT_FALSE(ret);
325 }
326
327 /**
328 * @tc.name: InputEventBuilderTest_SetDamplingCoefficient
329 * @tc.desc: Test the funcation SetDamplingCoefficient
330 * @tc.type: FUNC
331 */
332 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_SetDamplingCoefficient, TestSize.Level1)
333 {
334 CALL_TEST_DEBUG;
335 uint32_t direction = COORDINATION_DAMPLING_UP;
336 double coefficient = 0.5;
337 ASSERT_NO_FATAL_FAILURE(builder_->SetDamplingCoefficient(direction, coefficient));
338 direction = COORDINATION_DAMPLING_DOWN;
339 ASSERT_NO_FATAL_FAILURE(builder_->SetDamplingCoefficient(direction, coefficient));
340 direction = COORDINATION_DAMPLING_RIGHT;
341 ASSERT_NO_FATAL_FAILURE(builder_->SetDamplingCoefficient(direction, coefficient));
342 direction = COORDINATION_DAMPLING_LEFT;
343 ASSERT_NO_FATAL_FAILURE(builder_->SetDamplingCoefficient(direction, coefficient));
344 direction = COORDINATION_DAMPLING_UP;
345 coefficient = 1.5;
346 ASSERT_NO_FATAL_FAILURE(builder_->SetDamplingCoefficient(direction, coefficient));
347 }
348 /**
349 * @tc.name: InputEventBuilderTest_DampPointerMotion_001
350 * @tc.desc: Test the funcation DampPointerMotion
351 * @tc.type: FUNC
352 */
353 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_DampPointerMotion_001, TestSize.Level1)
354 {
355 CALL_TEST_DEBUG;
356 auto pointerEvent = MMI::PointerEvent::Create();
357 ASSERT_NE(pointerEvent, nullptr);
358 int64_t downTime = GetMillisTime();
359 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
360 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
361 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
362 pointerEvent->SetPointerId(1);
363 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
364 MMI::PointerEvent::PointerItem item;
365 item.SetPointerId(1);
366 item.SetDownTime(downTime);
367 item.SetPressed(true);
368 item.SetRawDx(60);
369 item.SetRawDy(60);
370 pointerEvent->AddPointerItem(item);
371 bool ret = builder_->DampPointerMotion(pointerEvent);
372 ASSERT_TRUE(ret);
373 }
374
375 /**
376 * @tc.name: InputEventBuilderTest_DampPointerMotion_002
377 * @tc.desc: Test the funcation DampPointerMotion
378 * @tc.type: FUNC
379 */
380 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_DampPointerMotion_002, TestSize.Level1)
381 {
382 CALL_TEST_DEBUG;
383 auto pointerEvent = MMI::PointerEvent::Create();
384 ASSERT_NE(pointerEvent, nullptr);
385 int64_t downTime = GetMillisTime();
386 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
387 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
388 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
389 pointerEvent->SetPointerId(1);
390 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
391 MMI::PointerEvent::PointerItem item;
392 item.SetPointerId(1);
393 item.SetDownTime(downTime);
394 item.SetPressed(true);
395 item.SetRawDx(-60);
396 item.SetRawDy(-60);
397 pointerEvent->AddPointerItem(item);
398 bool ret = builder_->DampPointerMotion(pointerEvent);
399 ASSERT_TRUE(ret);
400 }
401
402 /**
403 * @tc.name: InputEventBuilderTest_UpdatePointerEvent_002
404 * @tc.desc: Test the funcation UpdatePointerEvent
405 * @tc.type: FUNC
406 */
407 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_UpdatePointerEvent_002, TestSize.Level1)
408 {
409 CALL_TEST_DEBUG;
410 auto pointerEvent = MMI::PointerEvent::Create();
411 ASSERT_NE(pointerEvent, nullptr);
412 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
413 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
414 MMI::PointerEvent::PointerItem pointerItem;
415 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
416 pointerEvent->SetPointerId(1);
417 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
418 MMI::PointerEvent::PointerItem item;
419 item.SetPointerId(1);
420 item.SetPressed(true);
421 item.SetRawDx(-60);
422 item.SetRawDy(-60);
423 pointerEvent->AddPointerItem(item);
424 bool ret = builder_->UpdatePointerEvent(pointerEvent);
425 ASSERT_TRUE(ret);
426 }
427
428 /**
429 * @tc.name: InputEventBuilderTest_IsActive_004
430 * @tc.desc: Test the funcation IsActive
431 * @tc.type: FUNC
432 */
433 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_004, TestSize.Level1)
434 {
435 CALL_TEST_DEBUG;
436 auto pointerEvent = MMI::PointerEvent::Create();
437 ASSERT_NE(pointerEvent, nullptr);
438 builder_->freezing_ = true;
439 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
440 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
441 MMI::PointerEvent::PointerItem pointerItem;
442 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
443 pointerEvent->SetPointerId(1);
444 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
445 MMI::PointerEvent::PointerItem item;
446 item.SetPointerId(1);
447 item.SetPressed(true);
448 item.SetRawDx(-60);
449 item.SetRawDy(-60);
450 pointerEvent->AddPointerItem(item);
451 builder_->xDir_ = 1;
452 builder_->movement_ = -1;
453 bool ret = builder_->IsActive(pointerEvent);
454 ASSERT_TRUE(ret);
455 item.SetRawDx(60);
456 item.SetRawDy(60);
457 pointerEvent->AddPointerItem(item);
458 builder_->movement_ = 1;
459 ret = builder_->IsActive(pointerEvent);
460 ASSERT_FALSE(ret);
461 item.SetRawDx(0);
462 item.SetRawDy(0);
463 builder_->movement_ = 1;
464 pointerEvent->AddPointerItem(item);
465 builder_->movement_ = 0;
466 ret = builder_->IsActive(pointerEvent);
467 ASSERT_TRUE(ret);
468 }
469
470 /**
471 * @tc.name: InputEventBuilderTest_IsActive_005
472 * @tc.desc: Test the funcation IsActive
473 * @tc.type: FUNC
474 */
475 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_005, TestSize.Level1)
476 {
477 CALL_TEST_DEBUG;
478 auto pointerEvent = MMI::PointerEvent::Create();
479 ASSERT_NE(pointerEvent, nullptr);
480 builder_->freezing_ = true;
481 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
482 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
483 MMI::PointerEvent::PointerItem pointerItem;
484 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
485 pointerEvent->SetPointerId(1);
486 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
487 MMI::PointerEvent::PointerItem item;
488 item.SetPointerId(1);
489 item.SetPressed(true);
490 item.SetRawDx(-60);
491 item.SetRawDy(-60);
492 pointerEvent->AddPointerItem(item);
493 builder_->xDir_ = 0;
494 builder_->movement_ = -1;
495 bool ret = builder_->IsActive(pointerEvent);
496 ASSERT_FALSE(ret);
497 }
498
499 /**
500 * @tc.name: InputEventBuilderTest_IsActive_006
501 * @tc.desc: Test the funcation IsActive
502 * @tc.type: FUNC
503 */
504 HWTEST_F(InputEventBuilderTest, InputEventBuilderTest_IsActive_006, TestSize.Level1)
505 {
506 CALL_TEST_DEBUG;
507 auto pointerEvent = MMI::PointerEvent::Create();
508 ASSERT_NE(pointerEvent, nullptr);
509 builder_->freezing_ = true;
510 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
511 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
512 MMI::PointerEvent::PointerItem pointerItem;
513 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
514 pointerEvent->SetPointerId(1);
515 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
516 MMI::PointerEvent::PointerItem item;
517 item.SetPointerId(1);
518 item.SetPressed(true);
519 item.SetRawDx(-60);
520 item.SetRawDy(-60);
521 pointerEvent->AddPointerItem(item);
522 builder_->xDir_ = -1;
523 builder_->movement_ = -1;
524 bool ret = builder_->IsActive(pointerEvent);
525 ASSERT_FALSE(ret);
526 item.SetRawDx(60);
527 item.SetRawDy(60);
528 pointerEvent->AddPointerItem(item);
529 builder_->movement_ = 1;
530 ret = builder_->IsActive(pointerEvent);
531 ASSERT_TRUE(ret);
532 item.SetRawDx(0);
533 item.SetRawDy(0);
534 pointerEvent->AddPointerItem(item);
535 builder_->movement_ = 0;
536 ret = builder_->IsActive(pointerEvent);
537 ASSERT_TRUE(ret);
538 }
539
540 /**
541 * @tc.name: ResetPressedEventsTest001
542 * @tc.desc: Test ResetPressedEventsTest001
543 * @tc.type: FUNC
544 */
545 HWTEST_F(InputEventBuilderTest, ResetPressedEventsTest001, TestSize.Level1)
546 {
547 CALL_TEST_DEBUG;
548 builder_->remoteNetworkId_ = "1234";
549 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
550 auto pointerEvent = MMI::PointerEvent::Create();
551 ASSERT_NE(pointerEvent, nullptr);
552 builder_->freezing_ = true;
553 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
554 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
555 MMI::PointerEvent::PointerItem pointerItem;
556 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
557 pointerEvent->SetPointerId(1);
558 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
559 MMI::PointerEvent::PointerItem item;
560 item.SetPointerId(1);
561 item.SetPressed(true);
562 item.SetRawDx(-60);
563 item.SetRawDy(-60);
564 pointerEvent->AddPointerItem(item);
565 int32_t ret1 = InputEventSerialization::Marshalling(pointerEvent, packet);
566 ASSERT_EQ(ret1, RET_OK);
567 bool ret = builder_->OnPacket(networkId_, packet);
568 ASSERT_EQ(ret, true);
569 builder_->ResetPressedEvents();
570 env_->GetDragManager().SetDragState(DragState::START);
571 }
572
573 /**
574 * @tc.name: ResetPressedEventsTest002
575 * @tc.desc: Test ResetPressedEventsTest002
576 * @tc.type: FUNC
577 */
578 HWTEST_F(InputEventBuilderTest, ResetPressedEventsTest002, TestSize.Level1)
579 {
580 CALL_TEST_DEBUG;
581 builder_->remoteNetworkId_ = "1234";
582 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
583 auto pointerEvent = MMI::PointerEvent::Create();
584 ASSERT_NE(pointerEvent, nullptr);
585 builder_->freezing_ = true;
586 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
587 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
588 MMI::PointerEvent::PointerItem pointerItem;
589 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
590 pointerEvent->SetPointerId(1);
591 pointerEvent->SetButtonPressed(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
592 MMI::PointerEvent::PointerItem item;
593 item.SetPointerId(1);
594 item.SetPressed(true);
595 item.SetRawDx(-60);
596 item.SetRawDy(-60);
597 pointerEvent->AddPointerItem(item);
598 int32_t ret1 = InputEventSerialization::Marshalling(pointerEvent, packet);
599 ASSERT_EQ(ret1, RET_OK);
600 bool ret = builder_->OnPacket(networkId_, packet);
601 ASSERT_EQ(ret, true);
602 env_->GetDragManager().SetDragState(DragState::START);
603 builder_->ResetPressedEvents();
604 }
605
606 /**
607 * @tc.name: ResetPressedEventsTest003
608 * @tc.desc: Test ResetPressedEventsTest003
609 * @tc.type: FUNC
610 */
611 HWTEST_F(InputEventBuilderTest, ResetPressedEventsTest003, TestSize.Level1)
612 {
613 CALL_TEST_DEBUG;
614 builder_->remoteNetworkId_ = "1234";
615 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
616 auto pointerEvent = MMI::PointerEvent::Create();
617 ASSERT_NE(pointerEvent, nullptr);
618 builder_->freezing_ = true;
619 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
620 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
621 MMI::PointerEvent::PointerItem pointerItem;
622 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
623 pointerEvent->SetPointerId(1);
624 pointerEvent->SetButtonPressed(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
625 MMI::PointerEvent::PointerItem item;
626 item.SetPointerId(1);
627 item.SetPressed(true);
628 item.SetRawDx(-60);
629 item.SetRawDy(-60);
630 pointerEvent->AddPointerItem(item);
631 int32_t ret1 = InputEventSerialization::Marshalling(pointerEvent, packet);
632 ASSERT_EQ(ret1, RET_OK);
633 bool ret = builder_->OnPacket(networkId_, packet);
634 ASSERT_EQ(ret, true);
635 env_->GetDragManager().SetDragState(DragState::START);
636 builder_->ResetPressedEvents();
637 }
638
639 /**
640 * @tc.name: ResetPressedEventsTest004
641 * @tc.desc: Test ResetPressedEventsTest004
642 * @tc.type: FUNC
643 */
644 HWTEST_F(InputEventBuilderTest, ResetPressedEventsTest004, TestSize.Level1)
645 {
646 CALL_TEST_DEBUG;
647 builder_->remoteNetworkId_ = "1234";
648 NetPacket packet(MessageId::DSOFTBUS_INPUT_POINTER_EVENT);
649 auto pointerEvent = MMI::PointerEvent::Create();
650 ASSERT_NE(pointerEvent, nullptr);
651 builder_->freezing_ = true;
652 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
653 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
654 MMI::PointerEvent::PointerItem pointerItem;
655 pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem);
656 pointerEvent->SetPointerId(1);
657 pointerEvent->SetButtonPressed(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
658 MMI::PointerEvent::PointerItem item;
659 item.SetPointerId(1);
660 item.SetPressed(true);
661 item.SetRawDx(-60);
662 item.SetRawDy(-60);
663 pointerEvent->AddPointerItem(item);
664 int32_t ret1 = InputEventSerialization::Marshalling(pointerEvent, packet);
665 ASSERT_EQ(ret1, RET_OK);
666 bool ret = builder_->OnPacket(networkId_, packet);
667 ASSERT_EQ(ret, true);
668 env_->GetDragManager().SetDragState(DragState::MOTION_DRAGGING);
669 builder_->ResetPressedEvents();
670 }
671 } // namespace Cooperate
672 } // namespace DeviceStatus
673 } // namespace Msdp
674 } // namespace OHOS