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