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