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 <future>
17 #include <memory>
18 #include <optional>
19 #include <utility>
20 #include <vector>
21 #include <gtest/gtest.h>
22
23 #include "devicestatus_define.h"
24 #include "key_event.h"
25 #include "input_event_interceptor.h"
26 #include "input_event_serialization.h"
27
28 #undef LOG_TAG
29 #define LOG_TAG "InputEventSerializationTest"
30
31 namespace OHOS {
32 namespace Msdp {
33 namespace DeviceStatus {
34 using namespace testing::ext;
35 namespace {
36 NetPacket pkt(MessageId::INVALID);
37 } // namespace
38
39 class InputEventSerializationTest : public testing::Test {
40 public:
41 void SetUp();
42 static void SetUpTestCase();
43 };
44
SetUpTestCase()45 void InputEventSerializationTest::SetUpTestCase() {}
46
SetUp()47 void InputEventSerializationTest::SetUp() {}
48
49 /**
50 * @tc.name: TestKeyEventToNetPacket
51 * @tc.desc: Test KeyEventToNetPacket
52 * @tc.type: FUNC
53 * @tc.require:
54 */
55 HWTEST_F(InputEventSerializationTest, TestKeyEventToNetPacket, TestSize.Level1)
56 {
57 CALL_TEST_DEBUG;
58 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
59 ASSERT_NE(keyEvent, nullptr);
60 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
61 keyEvent->SetActionTime(1);
62 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
63 OHOS::MMI::KeyEvent::KeyItem item;
64 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
65 item.SetDownTime(1);
66 item.SetPressed(true);
67 keyEvent->AddKeyItem(item);
68 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
69 int32_t ret = Cooperate::InputEventSerialization::KeyEventToNetPacket(keyEvent, packet);
70 ASSERT_EQ(ret, RET_OK);
71 ret = Cooperate::InputEventSerialization::NetPacketToKeyEvent(packet, keyEvent);
72 ASSERT_EQ(ret, RET_OK);
73 }
74
75 /**
76 * @tc.name: TestSerializeInputEvent
77 * @tc.desc: Test SerializeInputEvent
78 * @tc.type: FUNC
79 * @tc.require:
80 */
81 HWTEST_F(InputEventSerializationTest, TestSerializeInputEvent, TestSize.Level1)
82 {
83 CALL_TEST_DEBUG;
84 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
85 ASSERT_NE(keyEvent, nullptr);
86 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
87 keyEvent->SetActionTime(1);
88 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
89 OHOS::MMI::KeyEvent::KeyItem item;
90 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
91 item.SetDownTime(1);
92 item.SetPressed(true);
93 keyEvent->AddKeyItem(item);
94 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
95 int32_t ret = Cooperate::InputEventSerialization::SerializeInputEvent(keyEvent, packet);
96 ASSERT_EQ(ret, RET_OK);
97 ret = Cooperate::InputEventSerialization::DeserializeInputEvent(packet, keyEvent);
98 ASSERT_EQ(ret, RET_OK);
99 }
100
101 /**
102 * @tc.name: TestReadFunctionKeys
103 * @tc.desc: Test ReadFunctionKeys
104 * @tc.type: FUNC
105 * @tc.require:
106 */
107 HWTEST_F(InputEventSerializationTest, TestReadFunctionKeys, TestSize.Level1)
108 {
109 CALL_TEST_DEBUG;
110 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
111 ASSERT_NE(keyEvent, nullptr);
112 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
113 keyEvent->SetActionTime(1);
114 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
115 OHOS::MMI::KeyEvent::KeyItem item;
116 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_BACK);
117 item.SetDownTime(1);
118 item.SetPressed(true);
119 keyEvent->AddKeyItem(item);
120 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
121 Cooperate::InputEventSerialization::ReadFunctionKeys(packet, keyEvent);
122 }
123
124 /**
125 * @tc.name: TestSwitchEventToNetPacket
126 * @tc.desc: Test SwitchEventToNetPacket
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(InputEventSerializationTest, TestSwitchEventToNetPacket, TestSize.Level1)
131 {
132 CALL_TEST_DEBUG;
133 std::shared_ptr<MMI::SwitchEvent> switchEvent = std::make_shared<MMI::SwitchEvent>(0);
134 ASSERT_NE(switchEvent, nullptr);
135 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
136 int32_t ret = Cooperate::InputEventSerialization::SwitchEventToNetPacket(switchEvent, packet);
137 ASSERT_EQ(ret, RET_OK);
138 ret = Cooperate::InputEventSerialization::NetPacketToSwitchEvent(packet, switchEvent);
139 ASSERT_EQ(ret, RET_OK);
140 }
141
142 /**
143 * @tc.name: TestSerializeBaseInfo
144 * @tc.desc: Test SerializeBaseInfo
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(InputEventSerializationTest, TestSerializeBaseInfo, TestSize.Level1)
149 {
150 CALL_TEST_DEBUG;
151 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
152 ASSERT_NE(pointerEvent, nullptr);
153 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
154 int32_t ret = Cooperate::InputEventSerialization::SerializeBaseInfo(pointerEvent, packet);
155 ASSERT_EQ(ret, RET_OK);
156 ret = Cooperate::InputEventSerialization::DeserializeBaseInfo(packet, pointerEvent);
157 ASSERT_EQ(ret, RET_OK);
158 }
159
160 /**
161 * @tc.name: TestSerializeAxes
162 * @tc.desc: Test SerializeAxes
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(InputEventSerializationTest, TestSerializeAxes, TestSize.Level1)
167 {
168 CALL_TEST_DEBUG;
169 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
170 ASSERT_NE(pointerEvent, nullptr);
171 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
172 int32_t ret = Cooperate::InputEventSerialization::SerializeAxes(pointerEvent, packet);
173 ASSERT_EQ(ret, RET_OK);
174 ret = Cooperate::InputEventSerialization::DeserializeAxes(packet, pointerEvent);
175 ASSERT_EQ(ret, RET_OK);
176 }
177
178 /**
179 * @tc.name: TestSerializePressedButtons
180 * @tc.desc: Test SerializePressedButtons
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184 HWTEST_F(InputEventSerializationTest, TestSerializePressedButtons, TestSize.Level1)
185 {
186 CALL_TEST_DEBUG;
187 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
188 ASSERT_NE(pointerEvent, nullptr);
189 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
190 int32_t ret = Cooperate::InputEventSerialization::SerializePressedButtons(pointerEvent, packet);
191 ASSERT_EQ(ret, RET_OK);
192 ret = Cooperate::InputEventSerialization::DeserializePressedButtons(packet, pointerEvent);
193 ASSERT_EQ(ret, RET_OK);
194 }
195
196 /**
197 * @tc.name: TestSerializePointerItem
198 * @tc.desc: Test SerializePointerItem
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(InputEventSerializationTest, TestSerializePointerItem, TestSize.Level1)
203 {
204 CALL_TEST_DEBUG;
205 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
206 OHOS::MMI::PointerEvent::PointerItem item;
207 pointerEvent->AddPointerItem(item);
208 ASSERT_NE(pointerEvent, nullptr);
209 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
210 int32_t ret = Cooperate::InputEventSerialization::SerializePointerItem(packet, item);
211 ASSERT_EQ(ret, RET_OK);
212 ret = Cooperate::InputEventSerialization::DeserializePointerItem(packet, item);
213 ASSERT_EQ(ret, RET_OK);
214 }
215
216 /**
217 * @tc.name: TestSerializePointers
218 * @tc.desc: Test SerializePointers
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(InputEventSerializationTest, TestSerializePointers, TestSize.Level1)
223 {
224 CALL_TEST_DEBUG;
225 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
226 ASSERT_NE(pointerEvent, nullptr);
227 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
228 int32_t ret = Cooperate::InputEventSerialization::SerializePointers(pointerEvent, packet);
229 ASSERT_EQ(ret, RET_OK);
230 ret = Cooperate::InputEventSerialization::DeserializePointers(packet, pointerEvent);
231 ASSERT_EQ(ret, RET_OK);
232 }
233
234 /**
235 * @tc.name: TestSerializePressedKeys
236 * @tc.desc: Test SerializePressedKeys
237 * @tc.type: FUNC
238 * @tc.require:
239 */
240 HWTEST_F(InputEventSerializationTest, TestSerializePressedKeys, TestSize.Level1)
241 {
242 CALL_TEST_DEBUG;
243 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
244 std::vector<int32_t> pressedKeys { OHOS::MMI::KeyEvent::KEYCODE_CTRL_LEFT };
245 pointerEvent->SetPressedKeys(pressedKeys);
246 ASSERT_NE(pointerEvent, nullptr);
247 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
248 int32_t ret = Cooperate::InputEventSerialization::SerializePressedKeys(pointerEvent, packet);
249 ASSERT_EQ(ret, RET_OK);
250 ret = Cooperate::InputEventSerialization::DeserializePressedKeys(packet, pointerEvent);
251 ASSERT_EQ(ret, RET_OK);
252 }
253
254 /**
255 * @tc.name: TestSerializeBuffer
256 * @tc.desc: Test SerializeBuffer
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(InputEventSerializationTest, TestSerializeBuffer, TestSize.Level1)
261 {
262 CALL_TEST_DEBUG;
263 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
264 std::vector<uint8_t> enhanceData;
265 pointerEvent->SetBuffer(enhanceData);
266 ASSERT_NE(pointerEvent, nullptr);
267 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
268 int32_t ret = Cooperate::InputEventSerialization::SerializeBuffer(pointerEvent, packet);
269 ASSERT_EQ(ret, RET_OK);
270 ret = Cooperate::InputEventSerialization::DeserializeBuffer(packet, pointerEvent);
271 ASSERT_EQ(ret, RET_OK);
272 }
273
274 /**
275 * @tc.name: TestMarshalling
276 * @tc.desc: Test Marshalling
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(InputEventSerializationTest, TestMarshalling, TestSize.Level1)
281 {
282 CALL_TEST_DEBUG;
283 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
284 ASSERT_NE(pointerEvent, nullptr);
285 NetPacket packet(MessageId::DSOFTBUS_INPUT_KEY_EVENT);
286 int32_t ret = Cooperate::InputEventSerialization::Marshalling(pointerEvent, packet);
287 ASSERT_EQ(ret, RET_OK);
288 ret = Cooperate::InputEventSerialization::Unmarshalling(packet, pointerEvent);
289 ASSERT_EQ(ret, RET_OK);
290 }
291
292 /**
293 * @tc.name: TestNetPacketToKeyEvent_01
294 * @tc.desc: Test NetPacketToKeyEvent
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(InputEventSerializationTest, TestNetPacketToKeyEvent_01, TestSize.Level1)
299 {
300 CALL_TEST_DEBUG;
301 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
302 ASSERT_NE(keyEvent, nullptr);
303 int32_t ret = Cooperate::InputEventSerialization::NetPacketToKeyEvent(pkt, keyEvent);
304 ASSERT_EQ(ret, RET_ERR);
305 }
306
307 /**
308 * @tc.name: TestSwitchEventToNetPacket_01
309 * @tc.desc: Test SwitchEventToNetPacket
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(InputEventSerializationTest, TestSwitchEventToNetPacket_01, TestSize.Level1)
314 {
315 CALL_TEST_DEBUG;
316 std::shared_ptr<MMI::SwitchEvent> switchEvent = std::make_shared<MMI::SwitchEvent>(0);
317 ASSERT_NE(switchEvent, nullptr);
318 int32_t ret = Cooperate::InputEventSerialization::SwitchEventToNetPacket(switchEvent, pkt);
319 ASSERT_EQ(ret, RET_ERR);
320 ret = Cooperate::InputEventSerialization::NetPacketToSwitchEvent(pkt, switchEvent);
321 ASSERT_EQ(ret, RET_ERR);
322 }
323
324 /**
325 * @tc.name: TestSerializeInputEvent_01
326 * @tc.desc: Test SerializeInputEvent
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(InputEventSerializationTest, TestSerializeInputEvent_01, TestSize.Level1)
331 {
332 CALL_TEST_DEBUG;
333 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
334 ASSERT_NE(keyEvent, nullptr);
335 int32_t ret = Cooperate::InputEventSerialization::SerializeInputEvent(keyEvent, pkt);
336 ASSERT_EQ(ret, RET_ERR);
337 ret = Cooperate::InputEventSerialization::DeserializeInputEvent(pkt, keyEvent);
338 ASSERT_EQ(ret, RET_ERR);
339 }
340
341 /**
342 * @tc.name: TestSerializeBaseInfo_01
343 * @tc.desc: Test SerializeBaseInfo
344 * @tc.type: FUNC
345 * @tc.require:
346 */
347 HWTEST_F(InputEventSerializationTest, TestSerializeBaseInfo_01, TestSize.Level1)
348 {
349 CALL_TEST_DEBUG;
350 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
351 ASSERT_NE(pointerEvent, nullptr);
352 int32_t ret = Cooperate::InputEventSerialization::SerializeBaseInfo(pointerEvent, pkt);
353 ASSERT_EQ(ret, RET_ERR);
354 ret = Cooperate::InputEventSerialization::DeserializeBaseInfo(pkt, pointerEvent);
355 ASSERT_EQ(ret, RET_ERR);
356 }
357
358 /**
359 * @tc.name: TestSerializeAxes_01
360 * @tc.desc: Test SerializeAxes
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(InputEventSerializationTest, TestSerializeAxes_01, TestSize.Level1)
365 {
366 CALL_TEST_DEBUG;
367 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
368 ASSERT_NE(pointerEvent, nullptr);
369 int32_t ret = Cooperate::InputEventSerialization::SerializeAxes(pointerEvent, pkt);
370 ASSERT_EQ(ret, RET_ERR);
371 ret = Cooperate::InputEventSerialization::DeserializeAxes(pkt, pointerEvent);
372 ASSERT_EQ(ret, RET_ERR);
373 }
374
375 /**
376 * @tc.name: TestSerializePressedButtons_01
377 * @tc.desc: Test SerializePressedButtons
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(InputEventSerializationTest, TestSerializePressedButtons_01, TestSize.Level1)
382 {
383 CALL_TEST_DEBUG;
384 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
385 ASSERT_NE(pointerEvent, nullptr);
386 int32_t ret = Cooperate::InputEventSerialization::SerializePressedButtons(pointerEvent, pkt);
387 ASSERT_EQ(ret, RET_ERR);
388 ret = Cooperate::InputEventSerialization::DeserializePressedButtons(pkt, pointerEvent);
389 ASSERT_EQ(ret, RET_ERR);
390 }
391
392 /**
393 * @tc.name: TestSerializePointerItem_01
394 * @tc.desc: Test SerializePointerItem
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(InputEventSerializationTest, TestSerializePointerItem_01, TestSize.Level1)
399 {
400 CALL_TEST_DEBUG;
401 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
402 OHOS::MMI::PointerEvent::PointerItem item;
403 pointerEvent->AddPointerItem(item);
404 ASSERT_NE(pointerEvent, nullptr);
405 int32_t ret = Cooperate::InputEventSerialization::SerializePointerItem(pkt, item);
406 ASSERT_EQ(ret, RET_ERR);
407 ret = Cooperate::InputEventSerialization::DeserializePointerItem(pkt, item);
408 ASSERT_EQ(ret, RET_ERR);
409 }
410
411 /**
412 * @tc.name: TestSerializePointers_01
413 * @tc.desc: Test SerializePointers
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(InputEventSerializationTest, TestSerializePointers_01, TestSize.Level1)
418 {
419 CALL_TEST_DEBUG;
420 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
421 ASSERT_NE(pointerEvent, nullptr);
422 int32_t ret = Cooperate::InputEventSerialization::SerializePointers(pointerEvent, pkt);
423 ASSERT_EQ(ret, RET_ERR);
424 ret = Cooperate::InputEventSerialization::DeserializePointers(pkt, pointerEvent);
425 ASSERT_EQ(ret, RET_ERR);
426 }
427
428 /**
429 * @tc.name: TestSerializeBuffer_01
430 * @tc.desc: Test SerializeBuffer
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(InputEventSerializationTest, TestSerializeBuffer_01, TestSize.Level1)
435 {
436 CALL_TEST_DEBUG;
437 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
438 std::vector<uint8_t> enhanceData;
439 pointerEvent->SetBuffer(enhanceData);
440 ASSERT_NE(pointerEvent, nullptr);
441 int32_t ret = Cooperate::InputEventSerialization::SerializeBuffer(pointerEvent, pkt);
442 ASSERT_EQ(ret, RET_ERR);
443 ret = Cooperate::InputEventSerialization::DeserializeBuffer(pkt, pointerEvent);
444 ASSERT_EQ(ret, RET_ERR);
445 }
446
447 /**
448 * @tc.name: TestSerializePressedKeys_01
449 * @tc.desc: Test SerializePressedKeys
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(InputEventSerializationTest, TestSerializePressedKeys_01, TestSize.Level1)
454 {
455 CALL_TEST_DEBUG;
456 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
457 std::vector<int32_t> pressedKeys { OHOS::MMI::KeyEvent::KEYCODE_CTRL_LEFT };
458 pointerEvent->SetPressedKeys(pressedKeys);
459 ASSERT_NE(pointerEvent, nullptr);
460 int32_t ret = Cooperate::InputEventSerialization::SerializePressedKeys(pointerEvent, pkt);
461 ASSERT_EQ(ret, RET_ERR);
462 ret = Cooperate::InputEventSerialization::DeserializePressedKeys(pkt, pointerEvent);
463 ASSERT_EQ(ret, RET_ERR);
464 }
465
466 /**
467 * @tc.name: TestKeyEventToNetPacket_01
468 * @tc.desc: Test KeyEventToNetPacket
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(InputEventSerializationTest, TestKeyEventToNetPacket_01, TestSize.Level1)
473 {
474 CALL_TEST_DEBUG;
475 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
476 ASSERT_NE(keyEvent, nullptr);
477 int32_t ret = Cooperate::InputEventSerialization::KeyEventToNetPacket(keyEvent, pkt);
478 ASSERT_EQ(ret, RET_ERR);
479 }
480
481 /**
482 * @tc.name: TestMarshalling_01
483 * @tc.desc: Test Marshalling
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(InputEventSerializationTest, TestMarshalling_01, TestSize.Level1)
488 {
489 CALL_TEST_DEBUG;
490 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
491 ASSERT_NE(pointerEvent, nullptr);
492 int32_t ret = Cooperate::InputEventSerialization::Marshalling(pointerEvent, pkt);
493 ASSERT_EQ(ret, RET_ERR);
494 }
495
496 /**
497 * @tc.name: TestUnmarshalling_01
498 * @tc.desc: Test Unmarshalling
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(InputEventSerializationTest, TestUnmarshalling_01, TestSize.Level1)
503 {
504 CALL_TEST_DEBUG;
505 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
506 ASSERT_NE(pointerEvent, nullptr);
507 int32_t ret = Cooperate::InputEventSerialization::Unmarshalling(pkt, pointerEvent);
508 ASSERT_EQ(ret, RET_ERR);
509 }
510 } // namespace DeviceStatus
511 } // namespace Msdp
512 } // namespace OHOS