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