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