1 /*
2  * Copyright (c) 2022-2023 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_register.h"
17 
18 #include <unistd.h>
19 
20 #include "device_manager_ipc_interface_code.h"
21 #include "ipc_client_manager.h"
22 #include "ipc_register_listener_req.h"
23 #include "ipc_get_trustdevice_rsp.h"
24 #include "ipc_get_info_by_network_rsp.h"
25 #include "ipc_get_info_by_network_req.h"
26 #include "ipc_get_trustdevice_req.h"
27 #include "ipc_start_discovery_req.h"
28 #include "ipc_stop_discovery_req.h"
29 #include "ipc_publish_req.h"
30 #include "ipc_unpublish_req.h"
31 #include "ipc_set_useroperation_req.h"
32 #include "ipc_unauthenticate_device_req.h"
33 #include "ipc_authenticate_device_req.h"
34 #include "ipc_get_local_device_info_rsp.h"
35 #include "ipc_set_credential_req.h"
36 #include "ipc_set_credential_rsp.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 IpcCmdRegisterTest::SetUp()
46 {
47 }
48 
TearDown()49 void IpcCmdRegisterTest::TearDown()
50 {
51 }
52 
SetUpTestCase()53 void IpcCmdRegisterTest::SetUpTestCase()
54 {
55 }
56 
TearDownTestCase()57 void IpcCmdRegisterTest::TearDownTestCase()
58 {
59 }
60 
61 namespace {
62 /**
63  * @tc.name: SetRequest_001
64  * @tc.desc: 1. set cmdCode not null
65  *              set MessageParcel data null
66  *              set IpcReq null
67  *           2. call IpcCmdRegister OnRemoteRequest with parameter
68  *           3. check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
69  * @tc.type: FUNC
70  * @tc.require: AR000GHSJK
71  */
72 HWTEST_F(IpcCmdRegisterTest, SetRequest_001, testing::ext::TestSize.Level0)
73 {
74     // 1. set cmdCode not null
75     int32_t cmdCode = 999;
76     //  set MessageParcel data null
77     MessageParcel data;
78     // set IpcReq null
79     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
80     // 2. call IpcCmdRegister OnRemoteRequest with parameter
81     int ret = 0;
82     ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
83     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
84     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
85 }
86 
87 /**
88  * @tc.name: SetRequest_002
89  * @tc.desc: 1. set cmdCode not null
90  *              set MessageParcel data null
91  *              set IpcRegisterListenerReq null
92  *           2. call IpcCmdRegister OnRemoteRequest with parameter
93  *           3. check ret is ERR_DM_IPC_WRITE_FAILED
94  * @tc.type: FUNC
95  * @tc.require: AR000GHSJK
96  */
97 HWTEST_F(IpcCmdRegisterTest, SetRequest_002, testing::ext::TestSize.Level0)
98 {
99     // 1. set cmdCode not null
100     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
101     //  set MessageParcel data null
102     MessageParcel data;
103     // set IpcRegisterListenerReq null
104     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
105     // 2. call IpcCmdRegister OnRemoteRequest with parameter
106     int ret = 0;
107     ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
108     // 3. check ret is ERR_DM_IPC_WRITE_FAILED
109     ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED);
110 }
111 
112 /**
113  * @tc.name: SetRequest_003
114  * @tc.desc: 1. set cmdCode not null
115  *              set MessageParcel data null
116  *              set IpcRegisterListenerReq with pkgName not null
117  *           2. call IpcCmdRegister OnRemoteRequest with parameter
118  *           3. check ret is ERR_DM_IPC_WRITE_FAILED
119  * @tc.type: FUNC
120  * @tc.require: AR000GHSJK
121  */
122 HWTEST_F(IpcCmdRegisterTest, SetRequest_003, testing::ext::TestSize.Level0)
123 {
124     // 1. set cmdCode not null
125     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
126     //  set MessageParcel data null
127     MessageParcel data;
128     // set IpcRegisterListenerReq null
129     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
130     std::string pkgName = "com.ohos.test";
131     req->SetPkgName(pkgName);
132     // 2. call IpcCmdRegister OnRemoteRequest with parameter
133     int ret = 0;
134     ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
135     // 3. check ret is ERR_DM_IPC_WRITE_FAILED
136     ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED);
137 }
138 
139 /**
140  * @tc.name: SetRequest_004
141  * @tc.desc: 1. set cmdCode not null
142  *              set MessageParcel data null
143  *              set IpcRegisterListenerReq with listener
144  *           2. call IpcCmdRegister OnRemoteRequest with parameter
145  *           3. check ret is ERR_DM_IPC_WRITE_FAILED
146  * @tc.type: FUNC
147  * @tc.require: AR000GHSJK
148  */
149 HWTEST_F(IpcCmdRegisterTest, SetRequest_004, testing::ext::TestSize.Level0)
150 {
151     // 1. set cmdCode not null
152     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
153     //  set MessageParcel data null
154     MessageParcel data;
155     // set IpcRegisterListenerReq null
156     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
157     sptr<IRemoteObject> listener = nullptr;
158     std::string pkgName = "";
159     req->SetPkgName(pkgName);
160     req->SetListener(listener);
161     // 2. call IpcCmdRegister OnRemoteRequest with parameter
162     int ret = 0;
163     ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
164     // 3. check ret is ERR_DM_IPC_WRITE_FAILED
165     ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED);
166 }
167 
168 /**
169  * @tc.name: SetRequest_005
170  * @tc.desc: 1. set cmdCode not null
171  *              set MessageParcel data null
172  *              set IpcRegisterListenerReq with listener
173  *           2. call IpcCmdRegister OnRemoteRequest with parameter
174  *           3. check ret is ERR_DM_IPC_WRITE_FAILED
175  * @tc.type: FUNC
176  * @tc.require: AR000GHSJK
177  */
178 HWTEST_F(IpcCmdRegisterTest, SetRequest_005, testing::ext::TestSize.Level0)
179 {
180     // 1. set cmdCode not null
181     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
182     //  set MessageParcel data null
183     MessageParcel data;
184     // set IpcRegisterListenerReq null
185     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
186     sptr<IRemoteObject> listener = nullptr;
187     std::string pkgName = "listen not null";
188     req->SetPkgName(pkgName);
189     req->SetListener(listener);
190     // 2. call IpcCmdRegister OnRemoteRequest with parameter
191     int ret = 0;
192     ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
193     // 3. check ret is ERR_DM_IPC_WRITE_FAILED
194     ASSERT_EQ(ret, ERR_DM_IPC_WRITE_FAILED);
195 }
196 
197 /**
198  * @tc.name: SetRequest_006
199  * @tc.type: FUNC
200  * @tc.require: AR000GHSJK
201  */
202 HWTEST_F(IpcCmdRegisterTest, SetRequest_006, testing::ext::TestSize.Level0)
203 {
204     int32_t cmdCode = UNREGISTER_DEVICE_MANAGER_LISTENER;
205     MessageParcel data;
206     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
207     std::string pkgName = "ohos.test";
208     req->SetPkgName(pkgName);
209     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
210     ASSERT_EQ(ret, DM_OK);
211 }
212 
213 /**
214  * @tc.name: SetRequest_007
215  * @tc.type: FUNC
216  * @tc.require: AR000GHSJK
217  */
218 HWTEST_F(IpcCmdRegisterTest, SetRequest_007, testing::ext::TestSize.Level0)
219 {
220     int32_t cmdCode = GET_TRUST_DEVICE_LIST;
221     MessageParcel data;
222     std::shared_ptr<IpcGetTrustDeviceReq> req = std::make_shared<IpcGetTrustDeviceReq>();
223     std::string pkgName = "ohos.test";
224     std::string extra;
225     req->SetPkgName(pkgName);
226     req->SetExtra(extra);
227     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
228     ASSERT_EQ(ret, DM_OK);
229 }
230 
231 /**
232  * @tc.name: SetRequest_008
233  * @tc.type: FUNC
234  * @tc.require: AR000GHSJK
235  */
236 HWTEST_F(IpcCmdRegisterTest, SetRequest_008, testing::ext::TestSize.Level0)
237 {
238     int32_t cmdCode = GET_LOCAL_DEVICE_INFO;
239     MessageParcel data;
240     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
241     std::string pkgName = "ohos.test";
242     req->SetPkgName(pkgName);
243     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
244     ASSERT_EQ(ret, DM_OK);
245 }
246 
247 /**
248  * @tc.name: SetRequest_009
249  * @tc.type: FUNC
250  * @tc.require: AR000GHSJK
251  */
252 HWTEST_F(IpcCmdRegisterTest, SetRequest_09, testing::ext::TestSize.Level0)
253 {
254     int32_t cmdCode = GET_UDID_BY_NETWORK;
255     MessageParcel data;
256     std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
257     std::string pkgName = "ohos.test";
258     std::string netWorkId = "123";
259     req->SetPkgName(pkgName);
260     req->SetNetWorkId(netWorkId);
261     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
262     ASSERT_EQ(ret, DM_OK);
263 }
264 
265 /**
266  * @tc.name: SetRequest_010
267  * @tc.type: FUNC
268  * @tc.require: AR000GHSJK
269  */
270 HWTEST_F(IpcCmdRegisterTest, SetRequest_010, testing::ext::TestSize.Level0)
271 {
272     int32_t cmdCode = GET_UUID_BY_NETWORK;
273     MessageParcel data;
274     std::shared_ptr<IpcGetInfoByNetWorkReq> req = std::make_shared<IpcGetInfoByNetWorkReq>();
275     std::string pkgName = "ohos.test";
276     std::string netWorkId = "1234";
277     req->SetPkgName(pkgName);
278     req->SetNetWorkId(netWorkId);
279     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
280     ASSERT_EQ(ret, DM_OK);
281 }
282 
283 /**
284  * @tc.name: SetRequest_011
285  * @tc.type: FUNC
286  * @tc.require: AR000GHSJK
287  */
288 HWTEST_F(IpcCmdRegisterTest, SetRequest_011, testing::ext::TestSize.Level0)
289 {
290     int32_t cmdCode = START_DEVICE_DISCOVER;
291     MessageParcel data;
292     std::shared_ptr<IpcStartDiscoveryReq> req = std::make_shared<IpcStartDiscoveryReq>();
293     std::string pkgName = "ohos.test";
294     std::string extra = "1234";
295     DmSubscribeInfo dmSubscribeInfo;
296     req->SetPkgName(pkgName);
297     req->SetExtra(extra);
298     req->SetSubscribeInfo(dmSubscribeInfo);
299     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
300     ASSERT_EQ(ret, DM_OK);
301 }
302 
303 /**
304  * @tc.name: SetRequest_012
305  * @tc.type: FUNC
306  * @tc.require: AR000GHSJK
307  */
308 HWTEST_F(IpcCmdRegisterTest, SetRequest_012, testing::ext::TestSize.Level0)
309 {
310     int32_t cmdCode = STOP_DEVICE_DISCOVER;
311     MessageParcel data;
312     std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>();
313     std::string pkgName = "ohos.test";
314     uint16_t subscribeId = 12;
315     req->SetPkgName(pkgName);
316     req->SetSubscribeId(subscribeId);
317     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
318     ASSERT_EQ(ret, DM_OK);
319 }
320 
321 /**
322  * @tc.name: SetRequest_013
323  * @tc.type: FUNC
324  * @tc.require: AR000GHSJK
325  */
326 HWTEST_F(IpcCmdRegisterTest, SetRequest_013, testing::ext::TestSize.Level0)
327 {
328     int32_t cmdCode = PUBLISH_DEVICE_DISCOVER;
329     MessageParcel data;
330     std::shared_ptr<IpcPublishReq> req = std::make_shared<IpcPublishReq>();
331     std::string pkgName = "ohos.test";
332     DmPublishInfo dmPublishInfo;
333     req->SetPkgName(pkgName);
334     req->SetPublishInfo(dmPublishInfo);
335     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
336     ASSERT_EQ(ret, DM_OK);
337 }
338 
339 /**
340  * @tc.name: SetRequest_014
341  * @tc.type: FUNC
342  * @tc.require: AR000GHSJK
343  */
344 HWTEST_F(IpcCmdRegisterTest, SetRequest_014, testing::ext::TestSize.Level0)
345 {
346     int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER;
347     MessageParcel data;
348     std::shared_ptr<IpcUnPublishReq> req = std::make_shared<IpcUnPublishReq>();
349     std::string pkgName = "ohos.test";
350     int32_t publishId = 1;
351     req->SetPkgName(pkgName);
352     req->SetPublishId(publishId);
353     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
354     ASSERT_EQ(ret, DM_OK);
355 }
356 
357 /**
358  * @tc.name: SetRequest_015
359  * @tc.type: FUNC
360  * @tc.require: AR000GHSJK
361  */
362 HWTEST_F(IpcCmdRegisterTest, SetRequest_015, testing::ext::TestSize.Level0)
363 {
364     int32_t cmdCode = AUTHENTICATE_DEVICE;
365     MessageParcel data;
366     std::shared_ptr<IpcAuthenticateDeviceReq> req = std::make_shared<IpcAuthenticateDeviceReq>();
367     std::string pkgName = "ohos.test";
368     std::string extra;
369     int32_t authType = 1;
370     DmDeviceInfo deviceInfo;
371     req->SetPkgName(pkgName);
372     req->SetAuthType(authType);
373     req->SetExtra(extra);
374     req->SetDeviceInfo(deviceInfo);
375     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
376     ASSERT_EQ(ret, DM_OK);
377 }
378 
379 /**
380  * @tc.name: SetRequest_016
381  * @tc.type: FUNC
382  * @tc.require: AR000GHSJK
383  */
384 HWTEST_F(IpcCmdRegisterTest, SetRequest_016, testing::ext::TestSize.Level0)
385 {
386     int32_t cmdCode = NOTIFY_EVENT;
387     MessageParcel data;
388     std::shared_ptr<IpcNotifyEventReq> req = std::make_shared<IpcNotifyEventReq>();
389     std::string pkgName = "ohos.test";
390     int32_t eventId = 1;
391     std::string event;
392     req->SetPkgName(pkgName);
393     req->SetEventId(eventId);
394     req->SetEvent(event);
395     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
396     ASSERT_EQ(ret, DM_OK);
397 }
398 
399 /**
400  * @tc.name: SetRequest_019
401  * @tc.type: FUNC
402  * @tc.require: AR000GHSJK
403  */
404 HWTEST_F(IpcCmdRegisterTest, SetRequest_019, testing::ext::TestSize.Level0)
405 {
406     int32_t cmdCode = SERVER_USER_AUTH_OPERATION;
407     MessageParcel data;
408     std::shared_ptr<IpcGetOperationReq> req = std::make_shared<IpcGetOperationReq>();
409     std::string pkgName = "ohos.test";
410     req->SetPkgName(pkgName);
411     int32_t action = 1;
412     std::string params;
413     req->SetOperation(action);
414     req->SetParams(params);
415     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
416     ASSERT_EQ(ret, DM_OK);
417 }
418 
419 /**
420  * @tc.name: SetRequest_022
421  * @tc.type: FUNC
422  * @tc.require: AR000GHSJK
423  */
424 HWTEST_F(IpcCmdRegisterTest, SetRequest_022, testing::ext::TestSize.Level0)
425 {
426     int32_t cmdCode = REQUEST_CREDENTIAL;
427     MessageParcel data;
428     std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
429     std::string pkgName = "ohos.test";
430     std::string requestJsonStr;
431     req->SetPkgName(pkgName);
432     req->SetCredentialParam(requestJsonStr);
433     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
434     ASSERT_EQ(ret, DM_OK);
435 }
436 
437 /**
438  * @tc.name: SetRequest_023
439  * @tc.type: FUNC
440  * @tc.require: AR000GHSJK
441  */
442 HWTEST_F(IpcCmdRegisterTest, SetRequest_023, testing::ext::TestSize.Level0)
443 {
444     int32_t cmdCode = IMPORT_CREDENTIAL;
445     MessageParcel data;
446     std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
447     std::string pkgName = "ohos.test";
448     std::string credentialInfo;
449     req->SetPkgName(pkgName);
450     req->SetCredentialParam(credentialInfo);
451     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
452     ASSERT_EQ(ret, DM_OK);
453 }
454 
455 /**
456  * @tc.name: SetRequest_024
457  * @tc.type: FUNC
458  * @tc.require: AR000GHSJK
459  */
460 HWTEST_F(IpcCmdRegisterTest, SetRequest_024, testing::ext::TestSize.Level0)
461 {
462     int32_t cmdCode = DELETE_CREDENTIAL;
463     MessageParcel data;
464     std::shared_ptr<IpcSetCredentialReq> req = std::make_shared<IpcSetCredentialReq>();
465     std::string pkgName = "ohos.test";
466     std::string deleteInfo;
467     req->SetPkgName(pkgName);
468     req->SetCredentialParam(deleteInfo);
469     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
470     ASSERT_EQ(ret, DM_OK);
471 }
472 
473 /**
474  * @tc.name: SetRequest_025
475  * @tc.type: FUNC
476  * @tc.require: AR000GHSJK
477  */
478 HWTEST_F(IpcCmdRegisterTest, SetRequest_025, testing::ext::TestSize.Level0)
479 {
480     int32_t cmdCode = REGISTER_CREDENTIAL_CALLBACK;
481     MessageParcel data;
482     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
483     std::string pkgName = "ohos.test";
484     req->SetPkgName(pkgName);
485     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
486     ASSERT_EQ(ret, DM_OK);
487 }
488 
489 /**
490  * @tc.name: SetRequest_026
491  * @tc.type: FUNC
492  * @tc.require: AR000GHSJK
493  */
494 HWTEST_F(IpcCmdRegisterTest, SetRequest_026, testing::ext::TestSize.Level0)
495 {
496     int32_t cmdCode = UNREGISTER_CREDENTIAL_CALLBACK;
497     MessageParcel data;
498     std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
499     std::string pkgName = "ohos.test";
500     req->SetPkgName(pkgName);
501     int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
502     ASSERT_EQ(ret, DM_OK);
503 }
504 
505 /**
506  * @tc.name: ReadResponse_001
507  * @tc.desc: 1. set cmdCode 9999
508  *              set MessageParcel reply null
509  *           2. call IpcCmdRegister ReadResponse with parameter
510  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
511  * @tc.type: FUNC
512  * @tc.require: AR000GHSJK
513  */
514 HWTEST_F(IpcCmdRegisterTest, ReadResponse_001, testing::ext::TestSize.Level0)
515 {
516     // 1. set cmdCode not null
517     int32_t cmdCode = 9999;
518     //  set MessageParcel data null
519     MessageParcel reply;
520     // set IpcRegisterListenerReq null
521     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
522     // 2. call IpcCmdRegister ReadResponse with parameter
523     int ret = 0;
524     ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
525     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
526     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
527 }
528 
529 /**
530  * @tc.name: ReadResponse_002
531  * @tc.desc: 1. set cmdCode REGISTER_DEVICE_MANAGER_LISTENER
532  *              set MessageParcel reply null
533  *              set IpcRsp null
534  *           2. call IpcCmdRegister ReadResponse with parameter
535  *           3. check ret is DM_OK
536  * @tc.type: FUNC
537  * @tc.require: AR000GHSJK
538  */
539 HWTEST_F(IpcCmdRegisterTest, ReadResponse_002, testing::ext::TestSize.Level0)
540 {
541     // 1. set cmdCode not null
542     int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
543     //  set MessageParcel data null
544     MessageParcel reply;
545     // set IpcRegisterListenerReq null
546     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
547     // 2. call IpcCmdRegister OnRemoteRequest with parameter
548     int ret = 0;
549     ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
550     // 3. check ret is DM_OK
551     ASSERT_EQ(ret, DM_OK);
552 }
553 
554 /**
555  * @tc.name: ReadResponse_003
556  * @tc.desc: 1. set cmdCode UNREGISTER_DEVICE_MANAGER_LISTENER
557  *              set MessageParcel reply null
558  *              set IpcRsp null
559  *           2. call IpcCmdRegister ReadResponse with parameter
560  *           3. check ret is DM_OK
561  * @tc.type: FUNC
562  * @tc.require: AR000GHSJK
563  */
564 HWTEST_F(IpcCmdRegisterTest, ReadResponse_003, testing::ext::TestSize.Level0)
565 {
566     // 1. set cmdCode not null
567     int32_t cmdCode = UNREGISTER_DEVICE_MANAGER_LISTENER;
568     //  set MessageParcel data null
569     MessageParcel reply;
570     // set IpcRegisterListenerReq null
571     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
572     // 2. call IpcCmdRegister OnRemoteRequest with parameter
573     int ret = 0;
574     ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
575     // 3. check ret is DM_OK
576     ASSERT_EQ(ret, DM_OK);
577 }
578 
579 /**
580  * @tc.name: ReadResponse_004
581  * @tc.desc: 1. set cmdCode GET_TRUST_DEVICE_LIST
582  *              set MessageParcel reply null
583  *              set IpcRsp null
584  *           2. call IpcCmdRegister ReadResponse with parameter
585  *           3. check ret is DM_OK
586  * @tc.type: FUNC
587  * @tc.require: AR000GHSJK
588  */
589 HWTEST_F(IpcCmdRegisterTest, ReadResponse_004, testing::ext::TestSize.Level0)
590 {
591     // 1. set cmdCode not null
592     int32_t cmdCode = GET_TRUST_DEVICE_LIST;
593     //  set MessageParcel data null
594     MessageParcel reply;
595     // set IpcRegisterListenerReq null
596     std::shared_ptr<IpcGetTrustDeviceRsp> rsp = std::make_shared<IpcGetTrustDeviceRsp>();
597     // 2. call IpcCmdRegister OnRemoteRequest with parameter
598     int ret = 0;
599     ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
600     // 3. check ret is DM_OK
601     ASSERT_EQ(ret, DM_OK);
602 }
603 
604 /**
605  * @tc.name: ReadResponse_006
606  * @tc.type: FUNC
607  * @tc.require: AR000GHSJK
608  */
609 HWTEST_F(IpcCmdRegisterTest, ReadResponse_006, testing::ext::TestSize.Level0)
610 {
611     int32_t cmdCode = GET_LOCAL_DEVICE_INFO;
612     MessageParcel reply;
613     std::shared_ptr<IpcGetLocalDeviceInfoRsp> rsp = std::make_shared<IpcGetLocalDeviceInfoRsp>();
614     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
615     ASSERT_EQ(ret, DM_OK);
616 }
617 
618 /**
619  * @tc.name: ReadResponse_007
620  * @tc.type: FUNC
621  * @tc.require: AR000GHSJK
622  */
623 HWTEST_F(IpcCmdRegisterTest, ReadResponse_007, testing::ext::TestSize.Level0)
624 {
625     int32_t cmdCode = GET_UDID_BY_NETWORK;
626     MessageParcel reply;
627     std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
628     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
629     ASSERT_EQ(ret, DM_OK);
630 }
631 
632 /**
633  * @tc.name: ReadResponse_008
634  * @tc.type: FUNC
635  * @tc.require: AR000GHSJK
636  */
637 HWTEST_F(IpcCmdRegisterTest, ReadResponse_008, testing::ext::TestSize.Level0)
638 {
639     int32_t cmdCode = GET_UUID_BY_NETWORK;
640     MessageParcel reply;
641     std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
642     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
643     ASSERT_EQ(ret, DM_OK);
644 }
645 
646 /**
647  * @tc.name: ReadResponse_009
648  * @tc.type: FUNC
649  * @tc.require: AR000GHSJK
650  */
651 HWTEST_F(IpcCmdRegisterTest, ReadResponse_009, testing::ext::TestSize.Level0)
652 {
653     int32_t cmdCode = START_DEVICE_DISCOVER;
654     MessageParcel reply;
655     std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
656     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
657     ASSERT_EQ(ret, DM_OK);
658 }
659 
660 /**
661  * @tc.name: ReadResponse_010
662  * @tc.type: FUNC
663  * @tc.require: AR000GHSJK
664  */
665 HWTEST_F(IpcCmdRegisterTest, ReadResponse_010, testing::ext::TestSize.Level0)
666 {
667     int32_t cmdCode = STOP_DEVICE_DISCOVER;
668     MessageParcel reply;
669     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
670     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
671     ASSERT_EQ(ret, DM_OK);
672 }
673 
674 /**
675  * @tc.name: ReadResponse_011
676  * @tc.type: FUNC
677  * @tc.require: AR000GHSJK
678  */
679 HWTEST_F(IpcCmdRegisterTest, ReadResponse_011, testing::ext::TestSize.Level0)
680 {
681     int32_t cmdCode = PUBLISH_DEVICE_DISCOVER;
682     MessageParcel reply;
683     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
684     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
685     ASSERT_EQ(ret, DM_OK);
686 }
687 
688 /**
689  * @tc.name: ReadResponse_012
690  * @tc.type: FUNC
691  * @tc.require: AR000GHSJK
692  */
693 HWTEST_F(IpcCmdRegisterTest, ReadResponse_012, testing::ext::TestSize.Level0)
694 {
695     int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER;
696     MessageParcel reply;
697     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
698     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
699     ASSERT_EQ(ret, DM_OK);
700 }
701 
702 /**
703  * @tc.name: ReadResponse_013
704  * @tc.type: FUNC
705  * @tc.require: AR000GHSJK
706  */
707 HWTEST_F(IpcCmdRegisterTest, ReadResponse_013, testing::ext::TestSize.Level0)
708 {
709     int32_t cmdCode = AUTHENTICATE_DEVICE;
710     MessageParcel reply;
711     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
712     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
713     ASSERT_EQ(ret, DM_OK);
714 }
715 
716 /**
717  * @tc.name: ReadResponse_014
718  * @tc.type: FUNC
719  * @tc.require: AR000GHSJK
720  */
721 HWTEST_F(IpcCmdRegisterTest, ReadResponse_014, testing::ext::TestSize.Level0)
722 {
723     int32_t cmdCode = UNAUTHENTICATE_DEVICE;
724     MessageParcel reply;
725     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
726     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
727     ASSERT_EQ(ret, DM_OK);
728 }
729 
730 /**
731  * @tc.name: ReadResponse_016
732  * @tc.type: FUNC
733  * @tc.require: AR000GHSJK
734  */
735 HWTEST_F(IpcCmdRegisterTest, ReadResponse_016, testing::ext::TestSize.Level0)
736 {
737     int32_t cmdCode = NOTIFY_EVENT;
738     MessageParcel reply;
739     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
740     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
741     ASSERT_EQ(ret, DM_OK);
742 }
743 
744 /**
745  * @tc.name: ReadResponse_017
746  * @tc.type: FUNC
747  * @tc.require: AR000GHSJK
748  */
749 HWTEST_F(IpcCmdRegisterTest, ReadResponse_017, testing::ext::TestSize.Level0)
750 {
751     int32_t cmdCode = SERVER_USER_AUTH_OPERATION;
752     MessageParcel reply;
753     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
754     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
755     ASSERT_EQ(ret, DM_OK);
756 }
757 
758 /**
759  * @tc.name: ReadResponse_020
760  * @tc.type: FUNC
761  * @tc.require: AR000GHSJK
762  */
763 HWTEST_F(IpcCmdRegisterTest, ReadResponse_020, testing::ext::TestSize.Level0)
764 {
765     int32_t cmdCode = UNREGISTER_CREDENTIAL_CALLBACK;
766     MessageParcel reply;
767     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
768     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
769     ASSERT_EQ(ret, DM_OK);
770 }
771 
772 /**
773  * @tc.name: ReadResponse_021
774  * @tc.type: FUNC
775  * @tc.require: AR000GHSJK
776  */
777 HWTEST_F(IpcCmdRegisterTest, ReadResponse_021, testing::ext::TestSize.Level0)
778 {
779     int32_t cmdCode = IMPORT_CREDENTIAL;
780     MessageParcel reply;
781     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
782     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
783     ASSERT_EQ(ret, DM_OK);
784 }
785 
786 /**
787  * @tc.name: ReadResponse_022
788  * @tc.type: FUNC
789  * @tc.require: AR000GHSJK
790  */
791 HWTEST_F(IpcCmdRegisterTest, ReadResponse_022, testing::ext::TestSize.Level0)
792 {
793     int32_t cmdCode = DELETE_CREDENTIAL;
794     MessageParcel reply;
795     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
796     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
797     ASSERT_EQ(ret, DM_OK);
798 }
799 
800 /**
801  * @tc.name: ReadResponse_023
802  * @tc.type: FUNC
803  * @tc.require: AR000GHSJK
804  */
805 HWTEST_F(IpcCmdRegisterTest, ReadResponse_023, testing::ext::TestSize.Level0)
806 {
807     int32_t cmdCode = REGISTER_CREDENTIAL_CALLBACK;
808     MessageParcel reply;
809     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
810     int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
811     ASSERT_EQ(ret, DM_OK);
812 }
813 
814 /**
815  * @tc.name: OnIpcCmd_001
816  * @tc.desc: 1. set cmdCode 9999
817  *              set MessageParcel reply null
818  *           2. call IpcCmdRegister OnIpcCmd with parameter
819  *           3. check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC
820  * @tc.type: FUNC
821  * @tc.require: AR000GHSJK
822  */
823 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_001, testing::ext::TestSize.Level0)
824 {
825     // 1. set cmdCode not null
826     int32_t cmdCode = 9999;
827     //  set MessageParcel data null
828     MessageParcel reply;
829     MessageParcel data;
830     // set IpcRegisterListenerReq null
831     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
832     // 2. call IpcCmdRegister ReadResponse with parameter
833     int ret = 0;
834     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
835     // 3. check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
836     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
837 }
838 
839 /**
840  * @tc.name: OnIpcCmd_002
841  * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
842  *           2. data.WriteString(pkgname)
843  *              data.WriteInt32(DEVICE_STATE_ONLINE)
844  *              data.WriteRawData(&dmDeviceInfo, deviceSize)
845  *           3. call IpcCmdRegister OnIpcCmd with parameter
846  *           4. check ret is DM_OK
847  *              check result is DM_OK
848  * @tc.type: FUNC
849  * @tc.require: AR000GHSJK
850  */
851 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_002, testing::ext::TestSize.Level0)
852 {
853     // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
854     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
855     MessageParcel reply;
856     MessageParcel data;
857     // 2. data.WriteString(pkgname)
858     data.WriteString("com.ohos.test");
859     // data.WriteInt32(DEVICE_STATE_ONLINE)
860     data.WriteInt32(DEVICE_STATE_ONLINE);
861     DmDeviceInfo dmDeviceInfo;
862     size_t deviceSize = sizeof(DmDeviceInfo);
863     // data.WriteRawData(&dmDeviceInfo, deviceSize)
864     data.WriteRawData(&dmDeviceInfo, deviceSize);
865     // 3. call IpcCmdRegister OnIpcCmd with parameter
866     int ret = 0;
867     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
868     // check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC
869     ASSERT_EQ(ret, DM_OK);
870 }
871 
872 /**
873  * @tc.name: OnIpcCmd_003
874  * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
875  *           2. data.WriteString(pkgname)
876  *              data.WriteInt32(DEVICE_STATE_ONLINE)
877  *              data.WriteRawData(nullptr, deviceSize)
878  *           3. call IpcCmdRegister OnIpcCmd with parameter
879  *           4. check ret is DEVICEMANAGER_OK
880  *              check result is DEVICE_STATE_ONLINE
881  * @tc.type: FUNC
882  * @tc.require: AR000GHSJK
883  */
884 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_003, testing::ext::TestSize.Level0)
885 {
886     // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
887     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
888     MessageParcel reply;
889     MessageParcel data;
890     // 2. data.WriteString(pkgname)
891     data.WriteString("com.ohos.test");
892     // data.WriteInt32(DEVICE_STATE_ONLINE)
893     data.WriteInt32(DEVICE_STATE_ONLINE);
894     // data.WriteRawData(nullptr, deviceSize)
895     size_t deviceSize = sizeof(DmDeviceInfo);
896     data.WriteRawData(nullptr, deviceSize);
897     // 3. call IpcCmdRegister OnIpcCmd with parameter
898     int ret = 0;
899     int32_t result = 0;
900     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
901     result = reply.ReadInt32();
902     // 4. check result is DEVICE_STATE_ONLINE
903     ASSERT_EQ(result, DEVICE_STATE_ONLINE);
904     // check ret is DM_OK
905     ASSERT_EQ(ret, DM_OK);
906 }
907 
908 /**
909  * @tc.name: OnIpcCmd_004
910  * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
911  *           2. data.WriteString(pkgname)
912  *              data.WriteInt32(DEVICE_STATE_OFFLINE)
913  *              data.WriteRawData(nullptr, deviceSize)
914  *           3. call IpcCmdRegister OnIpcCmd with parameter
915  *           4. check ret is DM_OK
916  * @tc.type: FUNC
917  * @tc.require: AR000GHSJK
918  */
919 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_004, testing::ext::TestSize.Level0)
920 {
921     // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
922     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
923     MessageParcel reply;
924     MessageParcel data;
925     // 2. data.WriteString(pkgname)
926     data.WriteString("com.ohos.test");
927     // data.WriteInt32(DEVICE_STATE_OFFLINE)
928     data.WriteInt32(DEVICE_STATE_OFFLINE);
929     size_t deviceSize = sizeof(DmDeviceInfo);
930     // data.WriteRawData(nullptr, deviceSize)
931     data.WriteRawData(nullptr, deviceSize);
932     // 3. call IpcCmdRegister OnIpcCmd with parameter
933     int ret = 0;
934     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
935     // check ret is DM_OK
936     ASSERT_EQ(ret, DM_OK);
937 }
938 
939 /**
940  * @tc.name: OnIpcCmd_005
941  * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
942  *           2. data.WriteString(pkgname)
943  *              data.WriteInt32(DEVICE_INFO_CHANGED)
944  *              data.WriteRawData(nullptr, deviceSize)
945  *           3. call IpcCmdRegister OnIpcCmd with parameter
946  *           4. check ret is DM_OK
947  * @tc.type: FUNC
948  * @tc.require: AR000GHSJK
949  */
950 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_005, testing::ext::TestSize.Level0)
951 {
952     // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
953     int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
954     MessageParcel reply;
955     MessageParcel data;
956     // 2. data.WriteString(pkgname)
957     data.WriteString("com.ohos.test");
958     // data.WriteInt32(DEVICE_INFO_CHANGED)
959     data.WriteInt32(DEVICE_INFO_CHANGED);
960     size_t deviceSize = sizeof(DmDeviceInfo);
961     // data.WriteRawData(nullptr, deviceSize)
962     data.WriteRawData(nullptr, deviceSize);
963     // 3. call IpcCmdRegister OnIpcCmd with parameter
964     int ret = 0;
965     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
966     // 4.check ret is DM_OK
967     ASSERT_EQ(ret, DM_OK);
968 }
969 
970 /**
971  * @tc.name: OnIpcCmd_006
972  * @tc.type: FUNC
973  * @tc.require: AR000GHSJK
974  */
975 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_006, testing::ext::TestSize.Level0)
976 {
977     int32_t cmdCode = SERVER_DEVICE_FOUND;
978     MessageParcel reply;
979     MessageParcel data;
980     uint16_t subscribeId = 1;
981     DmDeviceInfo deviceInfo;
982     data.WriteString("com.ohos.test");
983     data.WriteInt16(subscribeId);
984     size_t deviceSize = sizeof(DmDeviceInfo);
985     data.WriteRawData(&deviceInfo, deviceSize);
986     int ret = 0;
987     ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
988     ASSERT_EQ(ret, DM_OK);
989 }
990 
991 /**
992  * @tc.name: OnIpcCmd_007
993  * @tc.type: FUNC
994  */
995 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_007, testing::ext::TestSize.Level0)
996 {
997     int32_t cmdCode = -1;
998     MessageParcel reply;
999     MessageParcel data;
1000     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1001     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
1002 }
1003 
1004 /**
1005  * @tc.name: OnIpcCmd_008
1006  * @tc.type: FUNC
1007  */
1008 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_008, testing::ext::TestSize.Level0)
1009 {
1010     int32_t cmdCode = IPC_MSG_BUTT;
1011     MessageParcel reply;
1012     MessageParcel data;
1013     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1014     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
1015 }
1016 
1017 /**
1018  * @tc.name: OnIpcCmd_009
1019  * @tc.type: FUNC
1020  * @tc.require: AR000GHSJK
1021  */
1022 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_009, testing::ext::TestSize.Level0)
1023 {
1024     int32_t cmdCode = SERVER_DISCOVER_FINISH;
1025     MessageParcel reply;
1026     MessageParcel data;
1027     uint16_t subscribeId = 1;
1028     int32_t failedReason = 0;
1029     data.WriteString("com.ohos.test");
1030     data.WriteInt16(subscribeId);
1031     data.WriteInt32(failedReason);
1032     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1033     ASSERT_EQ(ret, DM_OK);
1034 }
1035 
1036 /**
1037  * @tc.name: OnIpcCmd_010
1038  * @tc.type: FUNC
1039  * @tc.require: AR000GHSJK
1040  */
1041 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_010, testing::ext::TestSize.Level0)
1042 {
1043     int32_t cmdCode = SERVER_PUBLISH_FINISH;
1044     MessageParcel reply;
1045     MessageParcel data;
1046     int32_t publishId = 1;
1047     int32_t publishResult = 0;
1048     data.WriteString("com.ohos.test");
1049     data.WriteInt32(publishId);
1050     data.WriteInt32(publishResult);
1051     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1052     ASSERT_EQ(ret, DM_OK);
1053 }
1054 
1055 /**
1056  * @tc.name: OnIpcCmd_011
1057  * @tc.type: FUNC
1058  * @tc.require: AR000GHSJK
1059  */
1060 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_011, testing::ext::TestSize.Level0)
1061 {
1062     int32_t cmdCode = SERVER_AUTH_RESULT;
1063     MessageParcel reply;
1064     MessageParcel data;
1065     std::string pkgName = "ohos.test";
1066     std::string deviceId = "123";
1067     std::string token = "123456";
1068     int32_t status = 1;
1069     int32_t reason = 0;
1070     data.WriteString(pkgName);
1071     data.WriteString(deviceId);
1072     data.WriteString(token);
1073     data.WriteInt32(status);
1074     data.WriteInt32(reason);
1075     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1076     ASSERT_EQ(ret, DM_OK);
1077 }
1078 
1079 /**
1080  * @tc.name: OnIpcCmd_013
1081  * @tc.type: FUNC
1082  * @tc.require: AR000GHSJK
1083  */
1084 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_013, testing::ext::TestSize.Level0)
1085 {
1086     int32_t cmdCode = SERVER_DEVICE_FA_NOTIFY;
1087     MessageParcel reply;
1088     MessageParcel data;
1089     std::string pkgName = "ohos.test";
1090     std::string paramJson = "123";
1091     data.WriteString(pkgName);
1092     data.WriteString(paramJson);
1093     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1094     ASSERT_EQ(ret, DM_OK);
1095 }
1096 
1097 /**
1098  * @tc.name: OnIpcCmd_014
1099  * @tc.type: FUNC
1100  * @tc.require: AR000GHSJK
1101  */
1102 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_014, testing::ext::TestSize.Level0)
1103 {
1104     int32_t cmdCode = SERVER_CREDENTIAL_RESULT;
1105     MessageParcel reply;
1106     MessageParcel data;
1107     std::string pkgName = "ohos.test";
1108     std::string credentialResult = "123";
1109     int32_t action = 0;
1110     data.WriteString(pkgName);
1111     data.WriteInt32(action);
1112     data.WriteString(credentialResult);
1113     int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1114     ASSERT_EQ(ret, DM_OK);
1115 }
1116 } // namespace
1117 } // namespace DistributedHardware
1118 } // namespace OHOS