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: SetRequest_027
507 * @tc.type: FUNC
508 */
509 HWTEST_F(IpcCmdRegisterTest, SetRequest_027, testing::ext::TestSize.Level0)
510 {
511 int32_t cmdCode = CHECK_API_ACCESS_PERMISSION;
512 MessageParcel data;
513 std::shared_ptr<IpcReq> req = std::make_shared<IpcReq>();
514 int ret = IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data);
515 ASSERT_EQ(ret, DM_OK);
516 }
517
518 /**
519 * @tc.name: ReadResponse_001
520 * @tc.desc: 1. set cmdCode 9999
521 * set MessageParcel reply null
522 * 2. call IpcCmdRegister ReadResponse with parameter
523 * 3. check ret is ERR_DM_INPUT_PARA_INVALID
524 * @tc.type: FUNC
525 * @tc.require: AR000GHSJK
526 */
527 HWTEST_F(IpcCmdRegisterTest, ReadResponse_001, testing::ext::TestSize.Level0)
528 {
529 // 1. set cmdCode not null
530 int32_t cmdCode = 9999;
531 // set MessageParcel data null
532 MessageParcel reply;
533 // set IpcRegisterListenerReq null
534 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
535 // 2. call IpcCmdRegister ReadResponse with parameter
536 int ret = 0;
537 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
538 // 3. check ret is ERR_DM_INPUT_PARA_INVALID
539 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
540 }
541
542 /**
543 * @tc.name: ReadResponse_002
544 * @tc.desc: 1. set cmdCode REGISTER_DEVICE_MANAGER_LISTENER
545 * set MessageParcel reply null
546 * set IpcRsp null
547 * 2. call IpcCmdRegister ReadResponse with parameter
548 * 3. check ret is DM_OK
549 * @tc.type: FUNC
550 * @tc.require: AR000GHSJK
551 */
552 HWTEST_F(IpcCmdRegisterTest, ReadResponse_002, testing::ext::TestSize.Level0)
553 {
554 // 1. set cmdCode not null
555 int32_t cmdCode = REGISTER_DEVICE_MANAGER_LISTENER;
556 // set MessageParcel data null
557 MessageParcel reply;
558 // set IpcRegisterListenerReq null
559 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
560 // 2. call IpcCmdRegister OnRemoteRequest with parameter
561 int ret = 0;
562 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
563 // 3. check ret is DM_OK
564 ASSERT_EQ(ret, DM_OK);
565 }
566
567 /**
568 * @tc.name: ReadResponse_003
569 * @tc.desc: 1. set cmdCode UNREGISTER_DEVICE_MANAGER_LISTENER
570 * set MessageParcel reply null
571 * set IpcRsp null
572 * 2. call IpcCmdRegister ReadResponse with parameter
573 * 3. check ret is DM_OK
574 * @tc.type: FUNC
575 * @tc.require: AR000GHSJK
576 */
577 HWTEST_F(IpcCmdRegisterTest, ReadResponse_003, testing::ext::TestSize.Level0)
578 {
579 // 1. set cmdCode not null
580 int32_t cmdCode = UNREGISTER_DEVICE_MANAGER_LISTENER;
581 // set MessageParcel data null
582 MessageParcel reply;
583 // set IpcRegisterListenerReq null
584 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
585 // 2. call IpcCmdRegister OnRemoteRequest with parameter
586 int ret = 0;
587 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
588 // 3. check ret is DM_OK
589 ASSERT_EQ(ret, DM_OK);
590 }
591
592 /**
593 * @tc.name: ReadResponse_004
594 * @tc.desc: 1. set cmdCode GET_TRUST_DEVICE_LIST
595 * set MessageParcel reply null
596 * set IpcRsp null
597 * 2. call IpcCmdRegister ReadResponse with parameter
598 * 3. check ret is DM_OK
599 * @tc.type: FUNC
600 * @tc.require: AR000GHSJK
601 */
602 HWTEST_F(IpcCmdRegisterTest, ReadResponse_004, testing::ext::TestSize.Level0)
603 {
604 // 1. set cmdCode not null
605 int32_t cmdCode = GET_TRUST_DEVICE_LIST;
606 // set MessageParcel data null
607 MessageParcel reply;
608 // set IpcRegisterListenerReq null
609 std::shared_ptr<IpcGetTrustDeviceRsp> rsp = std::make_shared<IpcGetTrustDeviceRsp>();
610 // 2. call IpcCmdRegister OnRemoteRequest with parameter
611 int ret = 0;
612 ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
613 // 3. check ret is DM_OK
614 ASSERT_EQ(ret, DM_OK);
615 }
616
617 /**
618 * @tc.name: ReadResponse_006
619 * @tc.type: FUNC
620 * @tc.require: AR000GHSJK
621 */
622 HWTEST_F(IpcCmdRegisterTest, ReadResponse_006, testing::ext::TestSize.Level0)
623 {
624 int32_t cmdCode = GET_LOCAL_DEVICE_INFO;
625 MessageParcel reply;
626 std::shared_ptr<IpcGetLocalDeviceInfoRsp> rsp = std::make_shared<IpcGetLocalDeviceInfoRsp>();
627 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
628 ASSERT_EQ(ret, DM_OK);
629 }
630
631 /**
632 * @tc.name: ReadResponse_007
633 * @tc.type: FUNC
634 * @tc.require: AR000GHSJK
635 */
636 HWTEST_F(IpcCmdRegisterTest, ReadResponse_007, testing::ext::TestSize.Level0)
637 {
638 int32_t cmdCode = GET_UDID_BY_NETWORK;
639 MessageParcel reply;
640 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
641 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
642 ASSERT_EQ(ret, DM_OK);
643 }
644
645 /**
646 * @tc.name: ReadResponse_008
647 * @tc.type: FUNC
648 * @tc.require: AR000GHSJK
649 */
650 HWTEST_F(IpcCmdRegisterTest, ReadResponse_008, testing::ext::TestSize.Level0)
651 {
652 int32_t cmdCode = GET_UUID_BY_NETWORK;
653 MessageParcel reply;
654 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
655 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
656 ASSERT_EQ(ret, DM_OK);
657 }
658
659 /**
660 * @tc.name: ReadResponse_009
661 * @tc.type: FUNC
662 * @tc.require: AR000GHSJK
663 */
664 HWTEST_F(IpcCmdRegisterTest, ReadResponse_009, testing::ext::TestSize.Level0)
665 {
666 int32_t cmdCode = START_DEVICE_DISCOVER;
667 MessageParcel reply;
668 std::shared_ptr<IpcGetInfoByNetWorkRsp> rsp = std::make_shared<IpcGetInfoByNetWorkRsp>();
669 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
670 ASSERT_EQ(ret, DM_OK);
671 }
672
673 /**
674 * @tc.name: ReadResponse_010
675 * @tc.type: FUNC
676 * @tc.require: AR000GHSJK
677 */
678 HWTEST_F(IpcCmdRegisterTest, ReadResponse_010, testing::ext::TestSize.Level0)
679 {
680 int32_t cmdCode = STOP_DEVICE_DISCOVER;
681 MessageParcel reply;
682 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
683 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
684 ASSERT_EQ(ret, DM_OK);
685 }
686
687 /**
688 * @tc.name: ReadResponse_011
689 * @tc.type: FUNC
690 * @tc.require: AR000GHSJK
691 */
692 HWTEST_F(IpcCmdRegisterTest, ReadResponse_011, testing::ext::TestSize.Level0)
693 {
694 int32_t cmdCode = PUBLISH_DEVICE_DISCOVER;
695 MessageParcel reply;
696 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
697 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
698 ASSERT_EQ(ret, DM_OK);
699 }
700
701 /**
702 * @tc.name: ReadResponse_012
703 * @tc.type: FUNC
704 * @tc.require: AR000GHSJK
705 */
706 HWTEST_F(IpcCmdRegisterTest, ReadResponse_012, testing::ext::TestSize.Level0)
707 {
708 int32_t cmdCode = UNPUBLISH_DEVICE_DISCOVER;
709 MessageParcel reply;
710 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
711 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
712 ASSERT_EQ(ret, DM_OK);
713 }
714
715 /**
716 * @tc.name: ReadResponse_013
717 * @tc.type: FUNC
718 * @tc.require: AR000GHSJK
719 */
720 HWTEST_F(IpcCmdRegisterTest, ReadResponse_013, testing::ext::TestSize.Level0)
721 {
722 int32_t cmdCode = AUTHENTICATE_DEVICE;
723 MessageParcel reply;
724 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
725 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
726 ASSERT_EQ(ret, DM_OK);
727 }
728
729 /**
730 * @tc.name: ReadResponse_014
731 * @tc.type: FUNC
732 * @tc.require: AR000GHSJK
733 */
734 HWTEST_F(IpcCmdRegisterTest, ReadResponse_014, testing::ext::TestSize.Level0)
735 {
736 int32_t cmdCode = UNAUTHENTICATE_DEVICE;
737 MessageParcel reply;
738 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
739 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
740 ASSERT_EQ(ret, DM_OK);
741 }
742
743 /**
744 * @tc.name: ReadResponse_016
745 * @tc.type: FUNC
746 * @tc.require: AR000GHSJK
747 */
748 HWTEST_F(IpcCmdRegisterTest, ReadResponse_016, testing::ext::TestSize.Level0)
749 {
750 int32_t cmdCode = NOTIFY_EVENT;
751 MessageParcel reply;
752 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
753 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
754 ASSERT_EQ(ret, DM_OK);
755 }
756
757 /**
758 * @tc.name: ReadResponse_017
759 * @tc.type: FUNC
760 * @tc.require: AR000GHSJK
761 */
762 HWTEST_F(IpcCmdRegisterTest, ReadResponse_017, testing::ext::TestSize.Level0)
763 {
764 int32_t cmdCode = SERVER_USER_AUTH_OPERATION;
765 MessageParcel reply;
766 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
767 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
768 ASSERT_EQ(ret, DM_OK);
769 }
770
771 /**
772 * @tc.name: ReadResponse_020
773 * @tc.type: FUNC
774 * @tc.require: AR000GHSJK
775 */
776 HWTEST_F(IpcCmdRegisterTest, ReadResponse_020, testing::ext::TestSize.Level0)
777 {
778 int32_t cmdCode = UNREGISTER_CREDENTIAL_CALLBACK;
779 MessageParcel reply;
780 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
781 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
782 ASSERT_EQ(ret, DM_OK);
783 }
784
785 /**
786 * @tc.name: ReadResponse_021
787 * @tc.type: FUNC
788 * @tc.require: AR000GHSJK
789 */
790 HWTEST_F(IpcCmdRegisterTest, ReadResponse_021, testing::ext::TestSize.Level0)
791 {
792 int32_t cmdCode = IMPORT_CREDENTIAL;
793 MessageParcel reply;
794 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
795 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
796 ASSERT_EQ(ret, DM_OK);
797 }
798
799 /**
800 * @tc.name: ReadResponse_022
801 * @tc.type: FUNC
802 * @tc.require: AR000GHSJK
803 */
804 HWTEST_F(IpcCmdRegisterTest, ReadResponse_022, testing::ext::TestSize.Level0)
805 {
806 int32_t cmdCode = DELETE_CREDENTIAL;
807 MessageParcel reply;
808 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
809 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
810 ASSERT_EQ(ret, DM_OK);
811 }
812
813 /**
814 * @tc.name: ReadResponse_023
815 * @tc.type: FUNC
816 * @tc.require: AR000GHSJK
817 */
818 HWTEST_F(IpcCmdRegisterTest, ReadResponse_023, testing::ext::TestSize.Level0)
819 {
820 int32_t cmdCode = REGISTER_CREDENTIAL_CALLBACK;
821 MessageParcel reply;
822 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
823 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
824 ASSERT_EQ(ret, DM_OK);
825 }
826
827 /**
828 * @tc.name: ReadResponse_024
829 * @tc.type: FUNC
830 * @tc.require: AR000GHSJK
831 */
832 HWTEST_F(IpcCmdRegisterTest, ReadResponse_024, testing::ext::TestSize.Level0)
833 {
834 int32_t cmdCode = CHECK_API_ACCESS_PERMISSION;
835 MessageParcel reply;
836 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
837 int ret = IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp);
838 ASSERT_EQ(ret, DM_OK);
839 }
840
841 /**
842 * @tc.name: OnIpcCmd_001
843 * @tc.desc: 1. set cmdCode 9999
844 * set MessageParcel reply null
845 * 2. call IpcCmdRegister OnIpcCmd with parameter
846 * 3. check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC
847 * @tc.type: FUNC
848 * @tc.require: AR000GHSJK
849 */
850 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_001, testing::ext::TestSize.Level0)
851 {
852 // 1. set cmdCode not null
853 int32_t cmdCode = 9999;
854 // set MessageParcel data null
855 MessageParcel reply;
856 MessageParcel data;
857 // set IpcRegisterListenerReq null
858 std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
859 // 2. call IpcCmdRegister ReadResponse with parameter
860 int ret = 0;
861 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
862 // 3. check ret is ERR_DM_UNSUPPORTED_IPC_COMMAND
863 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
864 }
865
866 /**
867 * @tc.name: OnIpcCmd_002
868 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
869 * 2. data.WriteString(pkgname)
870 * data.WriteInt32(DEVICE_STATE_ONLINE)
871 * data.WriteRawData(&dmDeviceInfo, deviceSize)
872 * 3. call IpcCmdRegister OnIpcCmd with parameter
873 * 4. check ret is DM_OK
874 * check result is DM_OK
875 * @tc.type: FUNC
876 * @tc.require: AR000GHSJK
877 */
878 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_002, testing::ext::TestSize.Level0)
879 {
880 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
881 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
882 MessageParcel reply;
883 MessageParcel data;
884 // 2. data.WriteString(pkgname)
885 data.WriteString("com.ohos.test");
886 // data.WriteInt32(DEVICE_STATE_ONLINE)
887 data.WriteInt32(DEVICE_STATE_ONLINE);
888 DmDeviceInfo dmDeviceInfo;
889 size_t deviceSize = sizeof(DmDeviceInfo);
890 // data.WriteRawData(&dmDeviceInfo, deviceSize)
891 data.WriteRawData(&dmDeviceInfo, deviceSize);
892 // 3. call IpcCmdRegister OnIpcCmd with parameter
893 int ret = 0;
894 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
895 // check ret is DEVICEMANAGER_IPC_NOT_REGISTER_FUNC
896 ASSERT_EQ(ret, DM_OK);
897 }
898
899 /**
900 * @tc.name: OnIpcCmd_003
901 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
902 * 2. data.WriteString(pkgname)
903 * data.WriteInt32(DEVICE_STATE_ONLINE)
904 * data.WriteRawData(nullptr, deviceSize)
905 * 3. call IpcCmdRegister OnIpcCmd with parameter
906 * 4. check ret is DEVICEMANAGER_OK
907 * check result is DEVICE_STATE_ONLINE
908 * @tc.type: FUNC
909 * @tc.require: AR000GHSJK
910 */
911 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_003, testing::ext::TestSize.Level0)
912 {
913 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
914 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
915 MessageParcel reply;
916 MessageParcel data;
917 // 2. data.WriteString(pkgname)
918 data.WriteString("com.ohos.test");
919 // data.WriteInt32(DEVICE_STATE_ONLINE)
920 data.WriteInt32(DEVICE_STATE_ONLINE);
921 // data.WriteRawData(nullptr, deviceSize)
922 size_t deviceSize = sizeof(DmDeviceInfo);
923 data.WriteRawData(nullptr, deviceSize);
924 // 3. call IpcCmdRegister OnIpcCmd with parameter
925 int ret = 0;
926 int32_t result = 0;
927 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
928 result = reply.ReadInt32();
929 // 4. check result is DEVICE_STATE_ONLINE
930 ASSERT_EQ(result, DEVICE_STATE_ONLINE);
931 // check ret is DM_OK
932 ASSERT_EQ(ret, DM_OK);
933 }
934
935 /**
936 * @tc.name: OnIpcCmd_004
937 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
938 * 2. data.WriteString(pkgname)
939 * data.WriteInt32(DEVICE_STATE_OFFLINE)
940 * data.WriteRawData(nullptr, deviceSize)
941 * 3. call IpcCmdRegister OnIpcCmd with parameter
942 * 4. check ret is DM_OK
943 * @tc.type: FUNC
944 * @tc.require: AR000GHSJK
945 */
946 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_004, testing::ext::TestSize.Level0)
947 {
948 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
949 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
950 MessageParcel reply;
951 MessageParcel data;
952 // 2. data.WriteString(pkgname)
953 data.WriteString("com.ohos.test");
954 // data.WriteInt32(DEVICE_STATE_OFFLINE)
955 data.WriteInt32(DEVICE_STATE_OFFLINE);
956 size_t deviceSize = sizeof(DmDeviceInfo);
957 // data.WriteRawData(nullptr, deviceSize)
958 data.WriteRawData(nullptr, deviceSize);
959 // 3. call IpcCmdRegister OnIpcCmd with parameter
960 int ret = 0;
961 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
962 // check ret is DM_OK
963 ASSERT_EQ(ret, DM_OK);
964 }
965
966 /**
967 * @tc.name: OnIpcCmd_005
968 * @tc.desc: 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
969 * 2. data.WriteString(pkgname)
970 * data.WriteInt32(DEVICE_INFO_CHANGED)
971 * data.WriteRawData(nullptr, deviceSize)
972 * 3. call IpcCmdRegister OnIpcCmd with parameter
973 * 4. check ret is DM_OK
974 * @tc.type: FUNC
975 * @tc.require: AR000GHSJK
976 */
977 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_005, testing::ext::TestSize.Level0)
978 {
979 // 1. set cmdCode SERVER_DEVICE_STATE_NOTIFY
980 int32_t cmdCode = SERVER_DEVICE_STATE_NOTIFY;
981 MessageParcel reply;
982 MessageParcel data;
983 // 2. data.WriteString(pkgname)
984 data.WriteString("com.ohos.test");
985 // data.WriteInt32(DEVICE_INFO_CHANGED)
986 data.WriteInt32(DEVICE_INFO_CHANGED);
987 size_t deviceSize = sizeof(DmDeviceInfo);
988 // data.WriteRawData(nullptr, deviceSize)
989 data.WriteRawData(nullptr, deviceSize);
990 // 3. call IpcCmdRegister OnIpcCmd with parameter
991 int ret = 0;
992 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
993 // 4.check ret is DM_OK
994 ASSERT_EQ(ret, DM_OK);
995 }
996
997 /**
998 * @tc.name: OnIpcCmd_006
999 * @tc.type: FUNC
1000 * @tc.require: AR000GHSJK
1001 */
1002 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_006, testing::ext::TestSize.Level0)
1003 {
1004 int32_t cmdCode = SERVER_DEVICE_FOUND;
1005 MessageParcel reply;
1006 MessageParcel data;
1007 uint16_t subscribeId = 1;
1008 DmDeviceInfo deviceInfo;
1009 data.WriteString("com.ohos.test");
1010 data.WriteInt16(subscribeId);
1011 size_t deviceSize = sizeof(DmDeviceInfo);
1012 data.WriteRawData(&deviceInfo, deviceSize);
1013 int ret = 0;
1014 ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1015 ASSERT_EQ(ret, DM_OK);
1016 }
1017
1018 /**
1019 * @tc.name: OnIpcCmd_007
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_007, testing::ext::TestSize.Level0)
1023 {
1024 int32_t cmdCode = -1;
1025 MessageParcel reply;
1026 MessageParcel data;
1027 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1028 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
1029 }
1030
1031 /**
1032 * @tc.name: OnIpcCmd_008
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_008, testing::ext::TestSize.Level0)
1036 {
1037 int32_t cmdCode = IPC_MSG_BUTT;
1038 MessageParcel reply;
1039 MessageParcel data;
1040 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1041 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_IPC_COMMAND);
1042 }
1043
1044 /**
1045 * @tc.name: OnIpcCmd_009
1046 * @tc.type: FUNC
1047 * @tc.require: AR000GHSJK
1048 */
1049 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_009, testing::ext::TestSize.Level0)
1050 {
1051 int32_t cmdCode = SERVER_DISCOVER_FINISH;
1052 MessageParcel reply;
1053 MessageParcel data;
1054 uint16_t subscribeId = 1;
1055 int32_t failedReason = 0;
1056 data.WriteString("com.ohos.test");
1057 data.WriteInt16(subscribeId);
1058 data.WriteInt32(failedReason);
1059 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1060 ASSERT_EQ(ret, DM_OK);
1061 }
1062
1063 /**
1064 * @tc.name: OnIpcCmd_010
1065 * @tc.type: FUNC
1066 * @tc.require: AR000GHSJK
1067 */
1068 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_010, testing::ext::TestSize.Level0)
1069 {
1070 int32_t cmdCode = SERVER_PUBLISH_FINISH;
1071 MessageParcel reply;
1072 MessageParcel data;
1073 int32_t publishId = 1;
1074 int32_t publishResult = 0;
1075 data.WriteString("com.ohos.test");
1076 data.WriteInt32(publishId);
1077 data.WriteInt32(publishResult);
1078 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1079 ASSERT_EQ(ret, DM_OK);
1080 }
1081
1082 /**
1083 * @tc.name: OnIpcCmd_011
1084 * @tc.type: FUNC
1085 * @tc.require: AR000GHSJK
1086 */
1087 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_011, testing::ext::TestSize.Level0)
1088 {
1089 int32_t cmdCode = SERVER_AUTH_RESULT;
1090 MessageParcel reply;
1091 MessageParcel data;
1092 std::string pkgName = "ohos.test";
1093 std::string deviceId = "123";
1094 std::string token = "123456";
1095 int32_t status = 1;
1096 int32_t reason = 0;
1097 data.WriteString(pkgName);
1098 data.WriteString(deviceId);
1099 data.WriteString(token);
1100 data.WriteInt32(status);
1101 data.WriteInt32(reason);
1102 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1103 ASSERT_EQ(ret, DM_OK);
1104 }
1105
1106 /**
1107 * @tc.name: OnIpcCmd_013
1108 * @tc.type: FUNC
1109 * @tc.require: AR000GHSJK
1110 */
1111 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_013, testing::ext::TestSize.Level0)
1112 {
1113 int32_t cmdCode = SERVER_DEVICE_FA_NOTIFY;
1114 MessageParcel reply;
1115 MessageParcel data;
1116 std::string pkgName = "ohos.test";
1117 std::string paramJson = "123";
1118 data.WriteString(pkgName);
1119 data.WriteString(paramJson);
1120 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1121 ASSERT_EQ(ret, DM_OK);
1122 }
1123
1124 /**
1125 * @tc.name: OnIpcCmd_014
1126 * @tc.type: FUNC
1127 * @tc.require: AR000GHSJK
1128 */
1129 HWTEST_F(IpcCmdRegisterTest, OnIpcCmd_014, testing::ext::TestSize.Level0)
1130 {
1131 int32_t cmdCode = SERVER_CREDENTIAL_RESULT;
1132 MessageParcel reply;
1133 MessageParcel data;
1134 std::string pkgName = "ohos.test";
1135 std::string credentialResult = "123";
1136 int32_t action = 0;
1137 data.WriteString(pkgName);
1138 data.WriteInt32(action);
1139 data.WriteString(credentialResult);
1140 int ret = IpcCmdRegister::GetInstance().OnIpcCmd(cmdCode, data, reply);
1141 ASSERT_EQ(ret, DM_OK);
1142 }
1143 } // namespace
1144 } // namespace DistributedHardware
1145 } // namespace OHOS