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