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