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 "UTTest_ipc_cmd_parser_client.h"
17 
18 #include <unistd.h>
19 
20 #include "device_manager_ipc_interface_code.h"
21 #include "ipc_acl_profile_req.h"
22 #include "ipc_client_manager.h"
23 #include "ipc_cmd_register.h"
24 #include "ipc_common_param_req.h"
25 #include "ipc_create_pin_holder_req.h"
26 #include "ipc_register_listener_req.h"
27 #include "ipc_get_info_by_network_req.h"
28 #include "ipc_get_trustdevice_req.h"
29 #include "ipc_start_discovery_req.h"
30 #include "ipc_stop_discovery_req.h"
31 #include "ipc_publish_req.h"
32 #include "ipc_unpublish_req.h"
33 #include "ipc_unauthenticate_device_req.h"
34 #include "ipc_unbind_device_req.h"
35 #include "ipc_authenticate_device_req.h"
36 #include "ipc_set_credential_req.h"
37 #include "ipc_notify_event_req.h"
38 #include "device_manager_notify.h"
39 #include "ipc_req.h"
40 #include "dm_device_info.h"
41 #include "dm_constants.h"
42 
43 namespace OHOS {
44 namespace DistributedHardware {
SetUp()45 void IpcCmdParserClientTest::SetUp()
46 {
47 }
48 
TearDown()49 void IpcCmdParserClientTest::TearDown()
50 {
51 }
52 
SetUpTestCase()53 void IpcCmdParserClientTest::SetUpTestCase()
54 {
55 }
56 
TearDownTestCase()57 void IpcCmdParserClientTest::TearDownTestCase()
58 {
59 }
60 
61 namespace {
GetIpcRequestFunc(int32_t cmdCode)62 SetIpcRequestFunc GetIpcRequestFunc(int32_t cmdCode)
63 {
64     SetIpcRequestFunc ptr = nullptr;
65     auto setRequestMapIter = IpcCmdRegister::GetInstance().setIpcRequestFuncMap_.find(cmdCode);
66     if (setRequestMapIter != IpcCmdRegister::GetInstance().setIpcRequestFuncMap_.end()) {
67         ptr = setRequestMapIter->second;
68     }
69     return ptr;
70 }
71 
GetResponseFunc(int32_t cmdCode)72 ReadResponseFunc GetResponseFunc(int32_t cmdCode)
73 {
74     auto readResponseMapIter = IpcCmdRegister::GetInstance().readResponseFuncMap_.find(cmdCode);
75     if (readResponseMapIter == IpcCmdRegister::GetInstance().readResponseFuncMap_.end()) {
76         return nullptr;
77     }
78     return readResponseMapIter->second;
79 }
80 
GetIpcCmdFunc(int32_t cmdCode)81 OnIpcCmdFunc GetIpcCmdFunc(int32_t cmdCode)
82 {
83     auto onIpcCmdMapIter = IpcCmdRegister::GetInstance().onIpcCmdFuncMap_.find(cmdCode);
84     if (onIpcCmdMapIter == IpcCmdRegister::GetInstance().onIpcCmdFuncMap_.end()) {
85         return nullptr;
86     }
87     return onIpcCmdMapIter->second;
88 }
89 
TestReadResponseRspNull(int32_t cmdCode)90 int32_t TestReadResponseRspNull(int32_t cmdCode)
91 {
92     MessageParcel reply;
93     std::shared_ptr<IpcRsp> rsp = nullptr;
94     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
95     ReadResponseFunc ptr = GetResponseFunc(cmdCode);
96     if (ptr) {
97         ret = ptr(reply, rsp);
98     }
99     return ret;
100 }
101 
TestReadResponseRspNotNull(int32_t cmdCode)102 int32_t TestReadResponseRspNotNull(int32_t cmdCode)
103 {
104     MessageParcel reply;
105     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
106     int32_t retCode = 0;
107     reply.WriteInt32(retCode);
108     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
109     ReadResponseFunc ptr = GetResponseFunc(cmdCode);
110     if (ptr) {
111         ret = ptr(reply, rsp);
112     }
113     return ret;
114 }
115 
EncodePeerTargetId(const PeerTargetId & targetId,MessageParcel & parcel)116 bool EncodePeerTargetId(const PeerTargetId &targetId, MessageParcel &parcel)
117 {
118     bool bRet = true;
119     bRet = (bRet && parcel.WriteString(targetId.deviceId));
120     bRet = (bRet && parcel.WriteString(targetId.brMac));
121     bRet = (bRet && parcel.WriteString(targetId.bleMac));
122     bRet = (bRet && parcel.WriteString(targetId.wifiIp));
123     bRet = (bRet && parcel.WriteUint16(targetId.wifiPort));
124     return bRet;
125 }
126 
127 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_001, testing::ext::TestSize.Level0)
128 {
129     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
130     ASSERT_EQ(ERR_DM_FAILED, TestReadResponseRspNull(cmdCode));
131 }
132 
133 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_003, testing::ext::TestSize.Level0)
134 {
135     int32_t cmdCode = STOP_DEVICE_DISCOVER;
136     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
137 }
138 
139 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_004, testing::ext::TestSize.Level0)
140 {
141     int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER;
142     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
143 }
144 
145 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_005, testing::ext::TestSize.Level0)
146 {
147     int32_t cmdCode = AUTHENTICATE_DEVICE;
148     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
149 }
150 
151 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_007, testing::ext::TestSize.Level0)
152 {
153     int32_t cmdCode = BIND_DEVICE;
154     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
155 }
156 
157 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_008, testing::ext::TestSize.Level0)
158 {
159     int32_t cmdCode = UNBIND_DEVICE;
160     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
161 }
162 
163 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_009, testing::ext::TestSize.Level0)
164 {
165     int32_t cmdCode = REGISTER_UI_STATE_CALLBACK;
166     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
167 }
168 
169 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_010, testing::ext::TestSize.Level0)
170 {
171     int32_t cmdCode = UNREGISTER_UI_STATE_CALLBACK;
172     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
173 }
174 
175 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_011, testing::ext::TestSize.Level0)
176 {
177     int32_t cmdCode = REGISTER_DISCOVERY_CALLBACK;
178     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
179 }
180 
181 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_012, testing::ext::TestSize.Level0)
182 {
183     int32_t cmdCode = REGISTER_DISCOVERY_CALLBACK;
184     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
185 }
186 
187 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_013, testing::ext::TestSize.Level0)
188 {
189     int32_t cmdCode = UNREGISTER_DISCOVERY_CALLBACK;
190     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
191 }
192 
193 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_014, testing::ext::TestSize.Level0)
194 {
195     int32_t cmdCode = UNREGISTER_DISCOVERY_CALLBACK;
196     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
197 }
198 
199 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_015, testing::ext::TestSize.Level0)
200 {
201     int32_t cmdCode = START_DISCOVERING;
202     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
203 }
204 
205 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_016, testing::ext::TestSize.Level0)
206 {
207     int32_t cmdCode = STOP_DISCOVERING;
208     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
209 }
210 
211 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_017, testing::ext::TestSize.Level0)
212 {
213     int32_t cmdCode = START_ADVERTISING;
214     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
215 }
216 
217 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_018, testing::ext::TestSize.Level0)
218 {
219     int32_t cmdCode = START_ADVERTISING;
220     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
221 }
222 
223 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_019, testing::ext::TestSize.Level0)
224 {
225     int32_t cmdCode = START_ADVERTISING;
226     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
227 }
228 
229 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_020, testing::ext::TestSize.Level0)
230 {
231     int32_t cmdCode = STOP_ADVERTISING;
232     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
233 }
234 
235 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_021, testing::ext::TestSize.Level0)
236 {
237     int32_t cmdCode = STOP_ADVERTISING;
238     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
239 }
240 
241 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_022, testing::ext::TestSize.Level0)
242 {
243     int32_t cmdCode = BIND_TARGET;
244     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
245 }
246 
247 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_023, testing::ext::TestSize.Level0)
248 {
249     int32_t cmdCode = UNBIND_TARGET;
250     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
251 }
252 
253 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_024, testing::ext::TestSize.Level0)
254 {
255     int32_t cmdCode = CREATE_PIN_HOLDER;
256     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
257 }
258 
259 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_025, testing::ext::TestSize.Level0)
260 {
261     int32_t cmdCode = DESTROY_PIN_HOLDER;
262     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
263 }
264 
265 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_026, testing::ext::TestSize.Level0)
266 {
267     int32_t cmdCode = DP_ACL_ADD;
268     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
269 }
270 
271 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_027, testing::ext::TestSize.Level0)
272 {
273     int32_t cmdCode = DP_ACL_ADD;
274     ASSERT_EQ(TestReadResponseRspNotNull(cmdCode), DM_OK);
275 }
276 
277 HWTEST_F(IpcCmdParserClientTest, ReadResponseFunc_028, testing::ext::TestSize.Level0)
278 {
279     int32_t cmdCode = IS_SAME_ACCOUNT;
280     ASSERT_EQ(TestReadResponseRspNull(cmdCode), ERR_DM_FAILED);
281 }
282 
283 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_002, testing::ext::TestSize.Level0)
284 {
285     int32_t cmdCode = GET_NETWORKTYPE_BY_NETWORK;
286     MessageParcel data;
287     std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
288     std::string pkgName = "ohos.dm.test";
289     std::string netWorkId = "xxx";
290     req->SetPkgName(pkgName);
291     req->SetNetWorkId(netWorkId);
292     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
293     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
294     if (ptr) {
295         ret = ptr(req, data);
296     }
297     ASSERT_EQ(DM_OK, ret);
298 }
299 
300 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_003, testing::ext::TestSize.Level0)
301 {
302     int32_t cmdCode = UNBIND_DEVICE;
303     MessageParcel data;
304     std::shared_ptr<IpcUnBindDeviceReq> req = std::make_shared<IpcUnBindDeviceReq>();
305     std::string pkgName = "ohos.dm.test";
306     std::string deviceId = "xxx";
307     req->SetPkgName(pkgName);
308     req->SetDeviceId(deviceId);
309     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
310     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
311     if (ptr) {
312         ret = ptr(req, data);
313     }
314     ASSERT_EQ(DM_OK, ret);
315 }
316 
317 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_004, testing::ext::TestSize.Level0)
318 {
319     int32_t cmdCode = GET_NETWORKTYPE_BY_NETWORK;
320     MessageParcel data;
321     std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
322     std::string pkgName = "ohos.dm.test";
323     std::string netWorkId = "xxx";
324     req->SetPkgName(pkgName);
325     req->SetNetWorkId(netWorkId);
326     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
327     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
328     if (ptr) {
329         ret = ptr(req, data);
330     }
331     ASSERT_EQ(DM_OK, ret);
332 }
333 
334 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_005, testing::ext::TestSize.Level0)
335 {
336     int32_t cmdCode = REGISTER_UI_STATE_CALLBACK;
337     MessageParcel data;
338     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
339     std::string pkgName = "ohos.dm.test";
340     req->SetPkgName(pkgName);
341     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
342     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
343     if (ptr) {
344         ret = ptr(req, data);
345     }
346     ASSERT_EQ(DM_OK, ret);
347 }
348 
349 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_006, testing::ext::TestSize.Level0)
350 {
351     int32_t cmdCode = UNREGISTER_UI_STATE_CALLBACK;
352     MessageParcel data;
353     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
354     std::string pkgName = "ohos.dm.test";
355     req->SetPkgName(pkgName);
356     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
357     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
358     if (ptr) {
359         ret = ptr(req, data);
360     }
361     ASSERT_EQ(DM_OK, ret);
362 }
363 
364 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_007, testing::ext::TestSize.Level0)
365 {
366     int32_t cmdCode = REGISTER_DISCOVERY_CALLBACK;
367     MessageParcel data;
368     std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
369     std::string pkgName = "ohos.dm.test";
370     std::string discParaStr = "XXX";
371     std::string filterOpStr = "XXX";
372     req->SetPkgName(pkgName);
373     req->SetFirstParam(discParaStr);
374     req->SetSecondParam(filterOpStr);
375     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
376     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
377     if (ptr) {
378         ret = ptr(req, data);
379     }
380     ASSERT_EQ(DM_OK, ret);
381 }
382 
383 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_008, testing::ext::TestSize.Level0)
384 {
385     int32_t cmdCode = UNREGISTER_DISCOVERY_CALLBACK;
386     MessageParcel data;
387     std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
388     std::string pkgName = "ohos.dm.test";
389     std::string discParaStr = "XXX";
390     req->SetPkgName(pkgName);
391     req->SetFirstParam(discParaStr);
392     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
393     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
394     if (ptr) {
395         ret = ptr(req, data);
396     }
397     ASSERT_EQ(DM_OK, ret);
398 }
399 
400 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_009, testing::ext::TestSize.Level0)
401 {
402     int32_t cmdCode = START_ADVERTISING;
403     MessageParcel data;
404     std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
405     std::string pkgName = "ohos.dm.test";
406     std::string discParaStr = "XXX";
407     req->SetPkgName(pkgName);
408     req->SetFirstParam(discParaStr);
409     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
410     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
411     if (ptr) {
412         ret = ptr(req, data);
413     }
414     ASSERT_EQ(DM_OK, ret);
415 }
416 
417 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_010, testing::ext::TestSize.Level0)
418 {
419     int32_t cmdCode = STOP_ADVERTISING;
420     MessageParcel data;
421     std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
422     std::string pkgName = "ohos.dm.test";
423     std::string discParaStr = "XXX";
424     req->SetPkgName(pkgName);
425     req->SetFirstParam(discParaStr);
426     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
427     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
428     if (ptr) {
429         ret = ptr(req, data);
430     }
431     ASSERT_EQ(DM_OK, ret);
432 }
433 
434 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_011, testing::ext::TestSize.Level0)
435 {
436     int32_t cmdCode = CREATE_PIN_HOLDER;
437     MessageParcel data;
438     std::shared_ptr<IpcCreatePinHolderReq> req = std::make_shared<IpcCreatePinHolderReq>();
439     std::string pkgName = "ohos.dm.test";
440     PeerTargetId targetId;
441     DmPinType pinType = NUMBER_PIN_CODE;
442     std::string payload = "XXX";
443     req->SetPkgName(pkgName);
444     req->SetPeerTargetId(targetId);
445     req->SetPinType(pinType);
446     req->SetPayload(payload);
447     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
448     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
449     if (ptr) {
450         ret = ptr(req, data);
451     }
452     ASSERT_EQ(DM_OK, ret);
453 }
454 
455 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_012, testing::ext::TestSize.Level0)
456 {
457     int32_t cmdCode = DESTROY_PIN_HOLDER;
458     MessageParcel data;
459     std::shared_ptr<IpcCreatePinHolderReq> req = std::make_shared<IpcCreatePinHolderReq>();
460     std::string pkgName = "ohos.dm.test";
461     PeerTargetId targetId;
462     DmPinType pinType = NUMBER_PIN_CODE;
463     std::string payload = "XXX";
464     req->SetPkgName(pkgName);
465     req->SetPeerTargetId(targetId);
466     req->SetPinType(pinType);
467     req->SetPayload(payload);
468     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
469     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
470     if (ptr) {
471         ret = ptr(req, data);
472     }
473     ASSERT_EQ(DM_OK, ret);
474 }
475 
476 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_013, testing::ext::TestSize.Level0)
477 {
478     int32_t cmdCode = DP_ACL_ADD;
479     MessageParcel data;
480     std::shared_ptr<IpcAclProfileReq> req = std::make_shared<IpcAclProfileReq>();
481     std::string udid = "XXX";
482     req->SetStr(udid);
483     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
484     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
485     if (ptr) {
486         ret = ptr(req, data);
487     }
488     ASSERT_EQ(DM_OK, ret);
489 }
490 
491 HWTEST_F(IpcCmdParserClientTest, SetIpcRequestFunc_014, testing::ext::TestSize.Level0)
492 {
493     int32_t cmdCode = GET_SECURITY_LEVEL;
494     MessageParcel data;
495     std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
496     std::string networkId = "XXX";
497     std::string pkgName = "ohos.dm.test";
498     req->SetPkgName(pkgName);
499     req->SetNetWorkId(networkId);
500     int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
501     SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode);
502     if (ptr) {
503         ret = ptr(req, data);
504     }
505     ASSERT_EQ(DM_OK, ret);
506 }
507 
508 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_001, testing::ext::TestSize.Level0)
509 {
510     int32_t cmdCode = SERVER_DEVICE_DISCOVERY;
511     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
512     MessageParcel data;
513     MessageParcel reply;
514     std::string pkgName = "ohos.dm.test";
515     int16_t subscribeId = 100;
516     std::string deviceId = "xxx";
517     data.WriteString(pkgName);
518     data.WriteInt16(subscribeId);
519     DmDeviceBasicInfo basicInfo;
520     data.WriteRawData(&basicInfo, sizeof(DmDeviceBasicInfo));
521     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
522     if (ptr) {
523         ret = ptr(data, reply);
524     }
525     ASSERT_EQ(ret, DM_OK);
526 }
527 
528 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_002, testing::ext::TestSize.Level0)
529 {
530     int32_t cmdCode = BIND_TARGET_RESULT;
531     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
532     MessageParcel data;
533     MessageParcel reply;
534     std::string pkgName = "ohos.dm.test";
535     PeerTargetId targetId;
536     int32_t result = 1;
537     int32_t status = 1;
538     std::string content = "XX";
539     data.WriteString(pkgName);
540     EncodePeerTargetId(targetId, data);
541     data.WriteInt32(result);
542     data.WriteInt32(status);
543     data.WriteString(content);
544     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
545     if (ptr) {
546         ret = ptr(data, reply);
547     }
548     ASSERT_EQ(ret, DM_OK);
549 }
550 
551 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_003, testing::ext::TestSize.Level0)
552 {
553     int32_t cmdCode = UNBIND_TARGET_RESULT;
554     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
555     MessageParcel data;
556     MessageParcel reply;
557     std::string pkgName = "ohos.dm.test";
558     PeerTargetId targetId;
559     int32_t result = 1;
560     std::string content = "XX";
561     data.WriteString(pkgName);
562     EncodePeerTargetId(targetId, data);
563     data.WriteInt32(result);
564     data.WriteString(content);
565     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
566     if (ptr) {
567         ret = ptr(data, reply);
568     }
569     ASSERT_EQ(ret, DM_OK);
570 }
571 
572 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_004, testing::ext::TestSize.Level0)
573 {
574     int32_t cmdCode = SERVER_CREATE_PIN_HOLDER;
575     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
576     MessageParcel data;
577     MessageParcel reply;
578     std::string pkgName = "ohos.dm.test";
579     std::string deviceId = "xxx";
580     int32_t pinType = 1;
581     std::string payload = "xx";
582     data.WriteString(pkgName);
583     data.WriteString(deviceId);
584     data.WriteInt32(pinType);
585     data.WriteString(payload);
586     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
587     if (ptr) {
588         ret = ptr(data, reply);
589     }
590     ASSERT_EQ(ret, DM_OK);
591 }
592 
593 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_005, testing::ext::TestSize.Level0)
594 {
595     int32_t cmdCode = SERVER_DESTROY_PIN_HOLDER;
596     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
597     MessageParcel data;
598     MessageParcel reply;
599     std::string pkgName = "ohos.dm.test";
600     int32_t pinType = 1;
601     std::string payload = "xx";
602     data.WriteString(pkgName);
603     data.WriteInt32(pinType);
604     data.WriteString(payload);
605     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
606     if (ptr) {
607         ret = ptr(data, reply);
608     }
609     ASSERT_EQ(ret, DM_OK);
610 }
611 
612 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_006, testing::ext::TestSize.Level0)
613 {
614     int32_t cmdCode = SERVER_CREATE_PIN_HOLDER_RESULT;
615     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
616     MessageParcel data;
617     MessageParcel reply;
618     std::string pkgName = "ohos.dm.test";
619     int32_t result = 1;
620     data.WriteString(pkgName);
621     data.WriteInt32(result);
622     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
623     if (ptr) {
624         ret = ptr(data, reply);
625     }
626     ASSERT_EQ(ret, DM_OK);
627 }
628 
629 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_007, testing::ext::TestSize.Level0)
630 {
631     int32_t cmdCode = SERVER_DESTROY_PIN_HOLDER_RESULT;
632     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
633     MessageParcel data;
634     MessageParcel reply;
635     std::string pkgName = "ohos.dm.test";
636     int32_t result = 1;
637     data.WriteString(pkgName);
638     data.WriteInt32(result);
639     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
640     if (ptr) {
641         ret = ptr(data, reply);
642     }
643     ASSERT_EQ(ret, DM_OK);
644 }
645 
646 HWTEST_F(IpcCmdParserClientTest, OnIpcCmdFunc_008, testing::ext::TestSize.Level0)
647 {
648     int32_t cmdCode = SERVER_ON_PIN_HOLDER_EVENT;
649     int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND;
650     MessageParcel data;
651     MessageParcel reply;
652     std::string pkgName = "ohos.dm.test";
653     int32_t result = 1;
654     std::string content = "xxx";
655     int32_t pinHolderEvent = 1;
656     data.WriteString(pkgName);
657     data.WriteInt32(result);
658     data.WriteInt32(pinHolderEvent);
659     data.WriteString(content);
660     OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode);
661     if (ptr) {
662         ret = ptr(data, reply);
663     }
664     ASSERT_EQ(ret, DM_OK);
665 }
666 } // namespace
667 } // namespace DistributedHardware
668 } // namespace OHOS