1 /*
2  * Copyright (c) 2022-2024 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_device_manager_impl.h"
17 #include "dm_device_info.h"
18 
19 #include <unistd.h>
20 #include "accesstoken_kit.h"
21 #include "device_manager_notify.h"
22 #include "dm_constants.h"
23 #include "dm_log.h"
24 #include "ipc_authenticate_device_req.h"
25 #include "ipc_get_info_by_network_req.h"
26 #include "ipc_get_info_by_network_rsp.h"
27 #include "ipc_get_local_device_info_rsp.h"
28 #include "ipc_get_trustdevice_req.h"
29 #include "ipc_get_trustdevice_rsp.h"
30 #include "ipc_req.h"
31 #include "ipc_rsp.h"
32 #include "ipc_set_useroperation_req.h"
33 #include "ipc_skeleton.h"
34 #include "ipc_start_discovery_req.h"
35 #include "ipc_stop_discovery_req.h"
36 #include "ipc_publish_req.h"
37 #include "ipc_unpublish_req.h"
38 #include "ipc_unauthenticate_device_req.h"
39 #include "nativetoken_kit.h"
40 #include "securec.h"
41 #include "token_setproc.h"
42 #include "softbus_error_code.h"
43 
44 namespace OHOS {
45 namespace DistributedHardware {
SetUp()46 void DeviceManagerImplTest::SetUp()
47 {
48     const int32_t permsNum = 2;
49     const int32_t indexZero = 0;
50     const int32_t indexOne = 1;
51     uint64_t tokenId;
52     const char *perms[permsNum];
53     perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
54     perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
55     NativeTokenInfoParams infoInstance = {
56         .dcapsNum = 0,
57         .permsNum = permsNum,
58         .aclsNum = 0,
59         .dcaps = NULL,
60         .perms = perms,
61         .acls = NULL,
62         .processName = "dsoftbus_service",
63         .aplStr = "system_core",
64     };
65     tokenId = GetAccessTokenId(&infoInstance);
66     SetSelfTokenID(tokenId);
67     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
68 }
69 
TearDown()70 void DeviceManagerImplTest::TearDown()
71 {
72 }
73 
SetUpTestCase()74 void DeviceManagerImplTest::SetUpTestCase()
75 {
76 }
77 
TearDownTestCase()78 void DeviceManagerImplTest::TearDownTestCase()
79 {
80 }
81 
82 namespace {
83 /**
84  * @tc.name: InitDeviceManager_001
85  * @tc.desc: 1. set packName not null
86  *              set dmInitCallback not null
87  *           2. call DeviceManagerImpl::InitDeviceManager with parameter
88  *           4. check ret is DM_OK
89  * deviceTypeId
90  * @tc.type: FUNC
91  * @tc.require: AR000GHSJK
92  */
93 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_101, testing::ext::TestSize.Level0)
94 {
95     // 1. set packName not null
96     std::string packName = "com.ohos.test";
97     // set dmInitCallback not null
98     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
99     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
100     // 3. check ret is DM_OK
101     ASSERT_EQ(ret, DM_OK);
102     DeviceManager::GetInstance().UnInitDeviceManager(packName);
103 }
104 
105 /**
106  * @tc.name: UnInitDeviceManager_101
107  * @tc.desc: 1. set packName not null
108  *           2. MOCK IpcClientProxy UnInit return DM_OK
109  *           3. call DeviceManagerImpl::UnInitDeviceManager with parameter
110  *           4. check ret is DM_OK
111  * deviceTypeId
112  * @tc.type: FUNC
113  * @tc.require: AR000GHSJK
114  */
115 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_101, testing::ext::TestSize.Level0)
116 {
117     std::string packName = "com.ohos.test2";
118     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
119     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
120     ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
121     ASSERT_EQ(ret, DM_OK);
122 }
123 
124 /**
125  * @tc.name: GetTrustedDeviceList_101
126  * @tc.desc: 1. set packName not null
127  *              set extra null
128  *              set deviceList null
129  *           2. MOCK IpcClientProxy SendRequest return DM_OK
130  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
131  *           4. check ret is DM_OK
132  * deviceTypeId
133  * @tc.type: FUNC
134  * @tc.require: AR000GHSJK
135  */
136 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_101, testing::ext::TestSize.Level0)
137 {
138     // 1. set packName not null
139     std::string packName = "com.ohos.test";
140     // set extra null
141     std::string extra = "";
142     // set deviceList null
143     std::vector<DmDeviceInfo> deviceList;
144     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
145     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
146     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
147     ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
148     // 3. check ret is DM_OK
149     ASSERT_EQ(ret, DM_OK);
150     DeviceManager::GetInstance().UnInitDeviceManager(packName);
151 }
152 
153 /**
154  * @tc.name: GetAvailableDeviceList_101
155  * @tc.desc: 1. set packName null
156  *              set deviceList null
157  *           2. call DeviceManagerImpl::GetAvailableDeviceList with parameter
158  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
159  * deviceTypeId
160  * @tc.type: FUNC
161  */
162 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_101, testing::ext::TestSize.Level0)
163 {
164     std::string packName;
165     std::vector<DmDeviceBasicInfo> deviceList;
166     int32_t ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
167     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
168 }
169 
170 /**
171  * @tc.name: GetAvailableDeviceList_102
172  * @tc.desc: 1. set packName not null
173  *              set deviceList null
174  *           2. InitDeviceManager return DM_OK
175  *           3. call DeviceManagerImpl::GetAvailableDeviceList with parameter
176  *           4. check ret is DM_OK
177  * deviceTypeId
178  * @tc.type: FUNC
179  */
180 HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_102, testing::ext::TestSize.Level0)
181 {
182     std::string packName = "com.ohos.test";
183     std::vector<DmDeviceBasicInfo> deviceList;
184     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
185     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
186     ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList);
187     ASSERT_EQ(ret, DM_OK);
188     DeviceManager::GetInstance().UnInitDeviceManager(packName);
189 }
190 
191 /**
192  * @tc.name: GetLocalDeviceNetWorkId_101
193  * @tc.desc: 1. set packName null
194  *              set networkId null
195  *           2. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
196  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
197  * deviceTypeId
198  * @tc.type: FUNC
199  */
200 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_101, testing::ext::TestSize.Level0)
201 {
202     std::string packName;
203     std::string networkId;
204     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
205     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
206 }
207 
208 /**
209  * @tc.name: GetLocalDeviceNetWorkId_102
210  * @tc.desc: 1. set packName not null
211  *              set networkId not null
212  *           2. InitDeviceManager return DM_OK
213  *           3. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter
214  *           4. check ret is DM_OK
215  * deviceTypeId
216  * @tc.type: FUNC
217  */
218 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_102, testing::ext::TestSize.Level0)
219 {
220     std::string packName = "com.ohos.test";
221     std::string networkId = "networkId";
222     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
223     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
224     ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId);
225     ASSERT_EQ(ret, DM_OK);
226     DeviceManager::GetInstance().UnInitDeviceManager(packName);
227 }
228 
229 /**
230  * @tc.name: GetLocalDeviceId_101
231  * @tc.desc: 1. set packName null
232  *              set deviceId null
233  *           2. call DeviceManagerImpl::GetLocalDeviceId with parameter
234  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
235  * deviceTypeId
236  * @tc.type: FUNC
237  */
238 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_101, testing::ext::TestSize.Level0)
239 {
240     std::string packName;
241     std::string deviceId;
242     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
243     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
244 }
245 
246 /**
247  * @tc.name: GetLocalDeviceId_102
248  * @tc.desc: 1. set packName not null
249  *              set deviceId not null
250  *           2. InitDeviceManager return DM_OK
251  *           3. call DeviceManagerImpl::GetLocalDeviceId with parameter
252  *           4. check ret is DM_OK
253  * deviceTypeId
254  * @tc.type: FUNC
255  */
256 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_102, testing::ext::TestSize.Level0)
257 {
258     std::string packName = "com.ohos.test";
259     std::string deviceId = "deviceId";
260     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
261     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
262     ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId);
263     ASSERT_EQ(ret, DM_OK);
264     DeviceManager::GetInstance().UnInitDeviceManager(packName);
265 }
266 
267 /**
268  * @tc.name: GetLocalDeviceName_101
269  * @tc.desc: 1. set packName null
270  *              set deviceName null
271  *           2. call DeviceManagerImpl::GetLocalDeviceName with parameter
272  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
273  * deviceTypeId
274  * @tc.type: FUNC
275  */
276 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_101, testing::ext::TestSize.Level0)
277 {
278     std::string packName;
279     std::string deviceName;
280     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
281     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
282 }
283 
284 /**
285  * @tc.name: GetLocalDeviceName_102
286  * @tc.desc: 1. set packName not null
287  *              set deviceName not null
288  *           2. InitDeviceManager return DM_OK
289  *           3. call DeviceManagerImpl::GetLocalDeviceName with parameter
290  *           4. check ret is DM_OK
291  * deviceTypeId
292  * @tc.type: FUNC
293  */
294 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_102, testing::ext::TestSize.Level0)
295 {
296     std::string packName = "com.ohos.test";
297     std::string deviceName = "deviceName";
298     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
299     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
300     ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName);
301     ASSERT_EQ(ret, DM_OK);
302     DeviceManager::GetInstance().UnInitDeviceManager(packName);
303 }
304 
305 
306 /**
307  * @tc.name: GetLocalDeviceType_101
308  * @tc.desc: 1. set packName null
309  *              set deviceType 0
310  *           2. call DeviceManagerImpl::GetLocalDeviceType with parameter
311  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
312  * deviceTypeId
313  * @tc.type: FUNC
314  */
315 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_101, testing::ext::TestSize.Level0)
316 {
317     std::string packName;
318     int32_t deviceType = 0;
319     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
320     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
321 }
322 
323 /**
324  * @tc.name: GetLocalDeviceType_102
325  * @tc.desc: 1. set packName not null
326  *              set deviceType 0
327  *           2. InitDeviceManager return DM_OK
328  *           3. call DeviceManagerImpl::GetLocalDeviceType with parameter
329  *           4. check ret is DM_OK
330  * deviceTypeId
331  * @tc.type: FUNC
332  */
333 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_102, testing::ext::TestSize.Level0)
334 {
335     std::string packName = "com.ohos.test";
336     int32_t deviceType = 0;
337     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
338     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
339     ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType);
340     ASSERT_EQ(ret, DM_OK);
341     DeviceManager::GetInstance().UnInitDeviceManager(packName);
342 }
343 
344 /**
345  * @tc.name: GetDeviceName_101
346  * @tc.desc: 1. set packName null
347  *              set networkId not null
348  *              set deviceName null
349  *           3. call DeviceManagerImpl::GetDeviceName with parameter
350  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
351  * deviceTypeId
352  * @tc.type: FUNC
353  */
354 HWTEST_F(DeviceManagerImplTest, GetDeviceName_101, testing::ext::TestSize.Level0)
355 {
356     std::string packName;
357     std::string networkId = "networkId";
358     std::string deviceName;
359     int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
360     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
361 }
362 
363 /**
364  * @tc.name: GetDeviceName_102
365  * @tc.desc: 1. set packName not null
366  *              set networkId null
367  *              set deviceName null
368  *           2. call DeviceManagerImpl::GetDeviceName with parameter
369  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
370  * deviceTypeId
371  * @tc.type: FUNC
372  */
373 HWTEST_F(DeviceManagerImplTest, GetDeviceName_102, testing::ext::TestSize.Level0)
374 {
375     std::string packName = "com.ohos.test";
376     std::string networkId;
377     std::string deviceName;
378     int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
379     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
380 }
381 
382 /**
383  * @tc.name: GetDeviceName_103
384  * @tc.desc: 1. set packName not null
385  *              set networkId not null
386  *              set deviceName null
387  *           2. call DeviceManagerImpl::GetDeviceName with parameter
388  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
389  * deviceTypeId
390  * @tc.type: FUNC
391  */
392 HWTEST_F(DeviceManagerImplTest, GetDeviceName_103, testing::ext::TestSize.Level0)
393 {
394     std::string packName = "com.ohos.test";
395     std::string networkId = "networkId";
396     std::string deviceName;
397     int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
398     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
399 }
400 
401 /**
402  * @tc.name: GetDeviceName_104
403  * @tc.desc: 1. set packName not null
404  *              set networkId not null
405  *              set deviceName null
406  *           2. InitDeviceManager return DM_OK
407  *           3. call DeviceManagerImpl::GetDeviceName with parameter
408  *           4. check ret is DM_OK
409  * deviceTypeId
410  * @tc.type: FUNC
411  */
412 HWTEST_F(DeviceManagerImplTest, GetDeviceName_104, testing::ext::TestSize.Level0)
413 {
414     std::string packName = "com.ohos.test";
415     std::string networkId = "networkId";
416     std::string deviceName;
417     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
418     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
419     ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName);
420     ASSERT_EQ(ret, DM_OK);
421     DeviceManager::GetInstance().UnInitDeviceManager(packName);
422 }
423 
424 /**
425  * @tc.name: GetDeviceType_101
426  * @tc.desc: 1. set packName null
427  *              set deviceList not null
428  *              set deviceType 0
429  *           2. call DeviceManagerImpl::GetDeviceType with parameter
430  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
431  * deviceTypeId
432  * @tc.type: FUNC
433  */
434 HWTEST_F(DeviceManagerImplTest, GetDeviceType_101, testing::ext::TestSize.Level0)
435 {
436     std::string packName;
437     std::string networkId = "networkId";
438     int32_t deviceType = 0;
439     int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
440     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
441 }
442 
443 /**
444  * @tc.name: GetDeviceType_102
445  * @tc.desc: 1. set packName not null
446  *              set networkId null
447  *              set deviceType 0
448  *           2. call DeviceManagerImpl::GetDeviceType with parameter
449  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
450  * deviceTypeId
451  * @tc.type: FUNC
452  */
453 HWTEST_F(DeviceManagerImplTest, GetDeviceType_102, testing::ext::TestSize.Level0)
454 {
455     std::string packName = "com.ohos.test";
456     std::string networkId;
457     int32_t deviceType = 0;
458     int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
459     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
460 }
461 
462 /**
463  * @tc.name: GetDeviceType_103
464  * @tc.desc: 1. set packName not null
465  *              set networkId not null
466  *              set deviceType 0
467  *           2. call DeviceManagerImpl::GetDeviceType with parameter
468  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
469  * deviceTypeId
470  * @tc.type: FUNC
471  */
472 HWTEST_F(DeviceManagerImplTest, GetDeviceType_103, testing::ext::TestSize.Level0)
473 {
474     std::string packName = "com.ohos.test";
475     std::string networkId = "networkId";
476     int32_t deviceType = 0;
477     int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
478     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
479 }
480 
481 /**
482  * @tc.name: GetDeviceType_104
483  * @tc.desc: 1. set packName not null
484  *              set networkId not null
485  *              set deviceType 0
486  *           2. InitDeviceManager return DM_OK
487  *           3. call DeviceManagerImpl::GetDeviceType with parameter
488  *           4. check ret is DM_OK
489  * deviceTypeId
490  * @tc.type: FUNC
491  */
492 HWTEST_F(DeviceManagerImplTest, GetDeviceType_104, testing::ext::TestSize.Level0)
493 {
494     std::string packName = "com.ohos.test";
495     std::string networkId = "networkId";
496     int32_t deviceType = 0;
497     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
498     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
499     ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType);
500     ASSERT_EQ(ret, DM_OK);
501     DeviceManager::GetInstance().UnInitDeviceManager(packName);
502 }
503 
504 /**
505  * @tc.name: UnBindDevice_101
506  * @tc.desc: 1. set packName null
507  *              set deviceId not null
508  *           2. call DeviceManagerImpl::UnBindDevice with parameter
509  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
510  * deviceTypeId
511  * @tc.type: FUNC
512  */
513 HWTEST_F(DeviceManagerImplTest, UnBindDevice_101, testing::ext::TestSize.Level0)
514 {
515     std::string packName ;
516     std::string deviceId = "deviceId";
517     int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
518     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
519 }
520 
521 /**
522  * @tc.name: UnBindDevice_102
523  * @tc.desc: 1. set packName not null
524  *              set deviceId null
525  *           2. call DeviceManagerImpl::UnBindDevice with parameter
526  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
527  * deviceTypeId
528  * @tc.type: FUNC
529  */
530 HWTEST_F(DeviceManagerImplTest, UnBindDevice_102, testing::ext::TestSize.Level0)
531 {
532     std::string packName = "com.ohos.test";
533     std::string deviceId;
534     int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
535     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
536 }
537 
538 /**
539  * @tc.name: UnBindDevice_103
540  * @tc.desc: 1. set packName not null
541  *              set deviceId not null
542  *           2. call DeviceManagerImpl::UnBindDevice with parameter
543  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
544  * deviceTypeId
545  * @tc.type: FUNC
546  */
547 HWTEST_F(DeviceManagerImplTest, UnBindDevice_103, testing::ext::TestSize.Level0)
548 {
549     std::string packName = "com.ohos.test";
550     std::string deviceId = "deviceId";
551     int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
552     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
553 }
554 
555 /**
556  * @tc.name: UnBindDevice_104
557  * @tc.desc: 1. set packName not null
558  *              set deviceId not null
559  *           2. InitDeviceManager return DM_OK
560  *           3. call DeviceManagerImpl::UnBindDevice with parameter
561  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
562  * deviceTypeId
563  * @tc.type: FUNC
564  */
565 HWTEST_F(DeviceManagerImplTest, UnBindDevice_104, testing::ext::TestSize.Level0)
566 {
567     std::string packName;
568     std::string deviceId;
569     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
570     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
571     ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId);
572     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
573     DeviceManager::GetInstance().UnInitDeviceManager(packName);
574 }
575 
576 /**
577  * @tc.name: BindDevice_101
578  * @tc.desc: 1. set packName null
579  *              set bindType 0
580  *              set deviceId not null
581  *              set bindParam null
582  *              set callback null
583  *           2. call DeviceManagerImpl::BindDevice with parameter
584  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
585  * deviceTypeId
586  * @tc.type: FUNC
587  */
588 HWTEST_F(DeviceManagerImplTest, BindDevice_101, testing::ext::TestSize.Level0)
589 {
590     std::string packName ;
591     int32_t bindType = 0;
592     std::string deviceId = "deviceId";
593     std::string bindParam;
594     std::shared_ptr<AuthenticateCallback> callback = nullptr;
595     int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
596     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
597 }
598 
599 /**
600  * @tc.name: BindDevice_102
601  * @tc.desc: 1. set packName not null
602  *              set bindType 0
603  *              set deviceId null
604  *              set bindParam null
605  *              set callback null
606  *           2. call DeviceManagerImpl::BindDevice with parameter
607  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
608  * deviceTypeId
609  * @tc.type: FUNC
610  */
611 HWTEST_F(DeviceManagerImplTest, BindDevice_102, testing::ext::TestSize.Level0)
612 {
613     std::string packName = "com.ohos.test";
614     int32_t bindType = 0;
615     std::string deviceId;
616     std::string bindParam;
617     std::shared_ptr<AuthenticateCallback> callback = nullptr;
618     int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
619     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
620 }
621 
622 /**
623  * @tc.name: BindDevice_103
624  * @tc.desc: 1. set packName not null
625  *              set bindType 0
626  *              set deviceId not null
627  *              set bindParam null
628  *              set callback null
629  *           2. call DeviceManagerImpl::BindDevice with parameter
630  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
631  * deviceTypeId
632  * @tc.type: FUNC
633  */
634 HWTEST_F(DeviceManagerImplTest, BindDevice_103, testing::ext::TestSize.Level0)
635 {
636     std::string packName = "com.ohos.test";
637     int32_t bindType = 0;
638     std::string deviceId = "deviceId";
639     std::string bindParam;
640     std::shared_ptr<AuthenticateCallback> callback = nullptr;
641     int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
642     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
643 }
644 
645 /**
646  * @tc.name: BindDevice_104
647  * @tc.desc: 1. set packName not null
648  *              set bindType 0
649  *              set deviceId not null
650  *              set bindParam null
651  *              set callback null
652  *           2. InitDeviceManager return DM_OK
653  *           3. call DeviceManagerImpl::BindDevice with parameter
654  *           4. check ret is not DM_OK
655  * deviceTypeId
656  * @tc.type: FUNC
657  */
658 HWTEST_F(DeviceManagerImplTest, BindDevice_104, testing::ext::TestSize.Level0)
659 {
660     std::string packName = "com.ohos.test";
661     int32_t bindType = 0;
662     std::string deviceId = "deviceId";
663     std::string bindParam;
664     std::shared_ptr<AuthenticateCallback> callback = nullptr;
665     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
666     DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
667     int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback);
668     ASSERT_NE(ret, DM_OK);
669     DeviceManager::GetInstance().UnInitDeviceManager(packName);
670 }
671 
672 /**
673  * @tc.name: RegisterDevStateCallback_101
674  * @tc.desc: 1. set packName not null
675  *              set extra not null
676  *              set callback not null
677  *           2. InitDeviceManager return DM_OK
678  *           3. call DeviceManagerImpl::RegisterDevStateCallback with parameter
679  *           4. check ret is DM_OK
680  * deviceTypeId
681  * @tc.type: FUNC
682  */
683 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_101, testing::ext::TestSize.Level0)
684 {
685     std::string packName = "com.ohos.test";
686     std::string extra = "extra";
687     std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
688     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
689     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
690     ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
691     ASSERT_EQ(ret, ERR_DM_NO_PERMISSION);
692     DeviceManager::GetInstance().UnInitDeviceManager(packName);
693 }
694 
695 /**
696  * @tc.name: RegisterDevStateCallback_102
697  * @tc.desc: 1. set packName null
698  *              set extra not null
699  *              set callback not null
700  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
701  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
702  * deviceTypeId
703  * @tc.type: FUNC
704  */
705 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_102, testing::ext::TestSize.Level0)
706 {
707     std::string packName;
708     std::string extra = "extra";
709     std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>();
710     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
711     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
712 }
713 
714 /**
715  * @tc.name: RegisterDevStateCallback_103
716  * @tc.desc: 1. set packName null
717  *              set extra not null
718  *              set callback not null
719  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
720  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
721  * deviceTypeId
722  * @tc.type: FUNC
723  */
724 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_103, testing::ext::TestSize.Level0)
725 {
726     std::string packName = "com.ohos.test";
727     std::string extra = "extra";
728     std::shared_ptr<DeviceStateCallback> callback = nullptr;
729     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
730     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
731 }
732 
733 /**
734  * @tc.name: UnRegisterDevStateCallback_101
735  * @tc.desc: 1. set packName not null
736  *           2. InitDeviceManager return DM_OK
737  *           3. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
738  *           4. check ret is DM_OK
739  * deviceTypeId
740  * @tc.type: FUNC
741  */
742 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallbackk_101, testing::ext::TestSize.Level0)
743 {
744     std::string packName = "com.ohos.test";
745     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
746     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
747     ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
748     ASSERT_EQ(ret, DM_OK);
749     DeviceManager::GetInstance().UnInitDeviceManager(packName);
750 }
751 
752 /**
753  * @tc.name: UnRegisterDevStateCallback_102
754  * @tc.desc: 1. set packName null
755  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
756  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
757  * deviceTypeId
758  * @tc.type: FUNC
759  */
760 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_102, testing::ext::TestSize.Level0)
761 {
762     std::string packName;
763     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
764     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
765 }
766 
767 /**
768  * @tc.name: GetLocalDeviceInfo_101
769  * @tc.desc: 1. set packName null
770  *              set extra null
771  *              set deviceList null
772  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
773  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
774  * deviceTypeId
775  * @tc.type: FUNC
776  * @tc.require: AR000GHSJK
777  */
778 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_101, testing::ext::TestSize.Level0)
779 {
780     // 1. set packName not null
781     std::string packName = "com.ohos.test";
782     // set extra null
783     DmDeviceInfo info;
784     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
785     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
786     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
787     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
788     ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
789     // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
790     ASSERT_EQ(ret, DM_OK);
791     DeviceManager::GetInstance().UnInitDeviceManager(packName);
792 }
793 
794 /**
795  * @tc.name: StartDeviceDiscovery_101
796  * @tc.desc: 1. set packName not null
797  *              set subscribeInfo null
798  *              set callback not null
799  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
800  *           3. check ret is DM_OK
801  * deviceTypeId
802  * @tc.type: FUNC
803  * @tc.require: AR000GHSJK
804  */
805 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_101, testing::ext::TestSize.Level0)
806 {
807     std::string packName = "com.ohos.helloworld";
808     std::string extra = "";
809     DmSubscribeInfo subscribeInfo;
810     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
811     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
812     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
813     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
814     ASSERT_EQ(ret, DM_OK);
815     DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
816     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
817 }
818 
819 /**
820  * @tc.name: StartDeviceDiscovery_102
821  * @tc.desc: 1. set packName not null
822  *              set subscribeInfo null
823  *              set callback not null
824  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
825  *           3. check ret is DM_OK
826  * deviceTypeId
827  * @tc.type: FUNC
828  * @tc.require: AR000GHSJK
829  */
830 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_102, testing::ext::TestSize.Level0)
831 {
832     std::string packName = "com.ohos.helloworld";
833     std::string extra = "{\"findDeviceMode\":1}";
834     DmSubscribeInfo subscribeInfo;
835     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
836     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
837     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
838     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
839     ASSERT_EQ(ret, DM_OK);
840     ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
841     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
842 }
843 
844 /**
845  * @tc.name: StartDeviceDiscovery_103
846  * @tc.desc: 1. set packName not null
847  *              set subscribeId 0
848  *              set filterOptions null
849  *              set callback not null
850  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
851  *           3. check ret is DM_OK
852  * deviceTypeId
853  * @tc.type: FUNC
854  * @tc.require: AR000GHSJK
855  */
856 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_103, testing::ext::TestSize.Level0)
857 {
858     std::string packName = "com.ohos.helloworld";
859     uint16_t subscribeId = 0;
860     std::string filterOptions;
861     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
862     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
863     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
864     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
865     ASSERT_EQ(ret, DM_OK);
866     DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
867     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
868 }
869 
870 /**
871  * @tc.name: StartDeviceDiscovery_104
872  * @tc.desc: 1. set packName not null
873  *              set subscribeId 0
874  *              set filterOptions null
875  *              set callback not null
876  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
877  *           3. check ret is ERR_DM_DISCOVERY_REPEATED
878  * deviceTypeId
879  * @tc.type: FUNC
880  * @tc.require: AR000GHSJK
881  */
882 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)
883 {
884     std::string packName = "com.ohos.helloworld";
885     uint16_t subscribeId = 0;
886     std::string filterOptions;
887     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
888     DmDeviceInfo deviceInfo;
889     callback->OnDeviceFound(subscribeId, deviceInfo);
890     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
891     ASSERT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
892 }
893 
894 /**
895  * @tc.name: StopDeviceDiscovery_101
896  * @tc.desc: 1. set packName not null
897  *              set subscribeInfo null
898  *              set callback not null
899  *           2. call DeviceManagerImpl::StopDeviceDiscovery with parameter
900  *           3. check ret is DM_OK
901  * deviceTypeId
902  * @tc.type: FUNC
903  * @tc.require: AR000GHSJK
904  */
905 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.Level0)
906 {
907     std::string packName = "com.ohos.test";
908     std::string extra = "";
909     DmSubscribeInfo subscribeInfo;
910     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
911     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
912     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
913     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
914     ASSERT_EQ(ret, DM_OK);
915     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
916 }
917 
918 /**
919  * @tc.name: StopDeviceDiscovery_102
920  * @tc.desc: 1. set packName not null
921  *              set subscribeId is 0
922  *           2. InitDeviceManager return DM_OK
923  *           3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
924  *           4. check ret is DM_OK
925  * deviceTypeId
926  * @tc.type: FUNC
927  * @tc.require: AR000GHSJK
928  */
929 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_102, testing::ext::TestSize.Level0)
930 {
931     // 1. set packName not null
932     std::string packName = "com.ohos.test";
933     // set subscribeInfo is 0
934     uint16_t subscribeId = 0;
935     // 2. InitDeviceManager return DM_OK
936     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
937     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
938     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
939     ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
940     // 4. check ret is DM_OK
941     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
942     DeviceManager::GetInstance().UnInitDeviceManager(packName);
943 }
944 
945 /**
946  * @tc.name: PublishDeviceDiscovery_101
947  * @tc.desc: 1. set packName not null
948  *              set publishInfo null
949  *              set callback not null
950  *           2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter
951  *           3. check ret is DM_OK
952  * deviceTypeId
953  * @tc.type: FUNC
954  * @tc.require: I5N1K3
955  */
956 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
957 {
958     std::string packName = "com.ohos.helloworld";
959     DmPublishInfo publishInfo;
960     std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>();
961     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
962     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
963     int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback);
964     ASSERT_EQ(ret, DM_OK);
965     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
966 }
967 
968 /**
969  * @tc.name: UnPublishDeviceDiscovery_101
970  * @tc.desc: 1. set packName not null
971  *              set publishId is 0
972  *           2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter
973  *           3. check ret is DM_OK
974  * deviceTypeId
975  * @tc.type: FUNC
976  * @tc.require: I5N1K3
977  */
978 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_101, testing::ext::TestSize.Level0)
979 {
980     std::string packName = "com.ohos.test";
981     int32_t publishId = 0;
982     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
983     auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
984     DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
985     int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId);
986     ASSERT_EQ(ret, DM_OK);
987     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
988 }
989 
990 /**
991  * @tc.name: AuthenticateDevice_101
992  * @tc.desc: 1. set packName not null
993  *              set dmDeviceInfo null
994  *              set dmAppImageInfo null
995  *              set extra null
996  *              set callback null
997  *           2. InitDeviceManager return DM_OK
998  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
999  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
1000  * deviceTypeId
1001  * @tc.type: FUNC
1002  * @tc.require: AR000GHSJK
1003  */
1004 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_101, testing::ext::TestSize.Level0)
1005 {
1006     // 1. set packName not null
1007     std::string packName = "com.ohos.helloworld";
1008     // set dmDeviceInfo null
1009     int32_t authType = 1;
1010     // set dmAppImageInfo null
1011     DmDeviceInfo dmDeviceInfo;
1012     strcpy_s(dmDeviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, "123XXXX");
1013     strcpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "234");
1014     dmDeviceInfo.deviceTypeId = 0;
1015     // set extra null
1016     std::string extra = "test";
1017     // set callback null
1018     std::shared_ptr<AuthenticateCallback> callback = nullptr;
1019     // 2.InitDeviceManager return DM_OK
1020     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
1021     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
1022     ASSERT_EQ(ret, DM_OK);
1023     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1024     ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback);
1025     // 4. check ret is DM_OK
1026     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1027     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1028 }
1029 
1030 /**
1031  * @tc.name: UnAuthenticateDevice_101
1032  * @tc.desc: 1. set packName not null
1033  *              set dmDeviceInfo null
1034  *              set dmAppImageInfo null
1035  *              set extra null
1036  *              set callback null
1037  *           2. InitDeviceManager return DM_OK
1038  *           3. call DeviceManagerImpl::AuthenticateDevice with parameter
1039  *           4. check ret is DM_OK
1040  * deviceTypeId
1041  * @tc.type: FUNC
1042  * @tc.require: AR000GHSJK
1043  */
1044 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0)
1045 {
1046     // 1. set packName not null
1047     std::string packName = "com.ohos.helloworld";
1048     DmDeviceInfo deviceInfo;
1049     deviceInfo.networkId[0] = '1';
1050     deviceInfo.networkId[1] = '2';
1051     deviceInfo.networkId[2] = '\0';
1052     // set callback null
1053     std::shared_ptr<AuthenticateCallback> callback = nullptr;
1054     // 2. InitDeviceManager return DM_OK
1055     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
1056     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
1057     // 3. call DeviceManagerImpl::AuthenticateDevice with parameter
1058     ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
1059     // 4. check ret is ERR_DM_FAILED
1060     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1061     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1062 }
1063 
1064 /**
1065  * @tc.name: SetUserOperation_101
1066  * @tc.desc: 1. set packName not null
1067  *              set action null
1068  *           2. InitDeviceManager return DM_OK
1069  *           3. call DeviceManagerImpl::SetUserOperation with parameter
1070  *           4. check ret is DM_OK
1071  * deviceTypeId
1072  * @tc.type: FUNC
1073  * @tc.require: AR000GHSJK
1074  */
1075 HWTEST_F(DeviceManagerImplTest, SetUserOperation_101, testing::ext::TestSize.Level0)
1076 {
1077     // 1. set packName not null
1078     std::string packName = "com.ohos.test";
1079     // set authParam null
1080     int32_t action = 0;
1081     const std::string param = "extra";
1082     // 2. InitDeviceManager return DM_OK
1083     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1084     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1085     // 3. call DeviceManagerImpl::SetUserOperation with parameter
1086     ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
1087     // 4. check ret is DM_OK
1088     ASSERT_EQ(ret, DM_OK);
1089     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1090 }
1091 
1092 /**
1093  * @tc.name: InitDeviceManager_001
1094  * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1095  *           2. check ret is ERR_DM_INPUT_PARA_INVALID
1096  * deviceTypeId
1097  * @tc.type: FUNC
1098  * @tc.require: AR000GHSJK
1099  */
1100 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_001, testing::ext::TestSize.Level0)
1101 {
1102     // 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt
1103     std::string packName = "";
1104     std::shared_ptr<DmInitCallback> dmInitCallback = nullptr;
1105     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, dmInitCallback);
1106     // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1107     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1108 }
1109 
1110 /**
1111  * @tc.name: InitDeviceManager_002
1112  * @tc.desc: 1. set packName not null
1113  *              set dmInitCallback not null
1114  *           2. call DeviceManagerImpl::InitDeviceManager with parameter
1115  *           3. check ret is DM_OK
1116  * deviceTypeId
1117  * @tc.type: FUNC
1118  * @tc.require: AR000GHSJK
1119  */
1120 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_002, testing::ext::TestSize.Level0)
1121 {
1122     // 1. set packName not null
1123     std::string packName = "com.ohos.test";
1124     // set dmInitCallback not null
1125     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1126     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1127     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1128     // 3. check ret is DM_OK
1129     ASSERT_EQ(ret, DM_OK);
1130 }
1131 
1132 /**
1133  * @tc.name: InitDeviceManager_003
1134  * @tc.desc: 1. set packName not null
1135  *              set dmInitCallback not null
1136  *           2. MOCK IpcClientProxy Init return ERR_DM_INIT_FAILED
1137  *           3. call DeviceManagerImpl::InitDeviceManager with parameter
1138  *           4. check ret is ERR_DM_INIT_FAILED
1139  * deviceTypeId
1140  * @tc.type: FUNC
1141  * @tc.require: AR000GHSJK
1142  */
1143 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_003, testing::ext::TestSize.Level0)
1144 {
1145     // 1. set packName not null
1146     std::string packName = "com.ohos.test";
1147     //    set dmInitCallback not null
1148     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1149     // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED
1150     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1151     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1152     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1153     // 3. call DeviceManagerImpl::InitDeviceManager with parameter
1154     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1155     // 4. check ret is DM_OK
1156     ASSERT_EQ(ret, DM_OK);
1157     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1158 }
1159 
1160 /**
1161  * @tc.name: InitDeviceManager_004
1162  * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1163  *           2. check ret is ERR_DM_INPUT_PARA_INVALID
1164  * deviceTypeId
1165  * @tc.type: FUNC
1166  * @tc.require: AR000GHSJK
1167  */
1168 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_004, testing::ext::TestSize.Level0)
1169 {
1170     // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1171     std::string packName = "com.ohos.test";
1172     std::shared_ptr<DmInitCallbackTest> callback = nullptr;
1173     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1174     // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1175     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1176 }
1177 
1178 /**
1179  * @tc.name: InitDeviceManager_005
1180  * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1181  *           2. check ret is ERR_DM_INPUT_PARA_INVALID
1182  * deviceTypeId
1183  * @tc.type: FUNC
1184  * @tc.require: AR000GHSJK
1185  */
1186 HWTEST_F(DeviceManagerImplTest, InitDeviceManager_005, testing::ext::TestSize.Level0)
1187 {
1188     // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1189     std::string packName = "";
1190     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1191     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1192     // 2. check ret is ERR_DM_INPUT_PARA_INVALID
1193     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1194 }
1195 
1196 /**
1197  * @tc.name: UnInitDeviceManager_001
1198  * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt
1199  *           2. check ret is ERR_DM_INPUT_PARA_INVALID
1200  * deviceTypeId
1201  * @tc.type: FUNC
1202  * @tc.require: AR000GHSJK
1203  */
1204 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_001, testing::ext::TestSize.Level0)
1205 {
1206     // 1. set packName not null
1207     std::string packName = "";
1208     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1209     int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1210     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1211     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1212 }
1213 
1214 /**
1215  * @tc.name: UnInitDeviceManager_002
1216  * @tc.desc: 1. set packName not null
1217  *           2. MOCK IpcClientProxy UnInit return ERR_DM_FAILED
1218  *           3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1219  *           4. check ret is ERR_DM_FAILED
1220  * deviceTypeId
1221  * @tc.type: FUNC
1222  * @tc.require: AR000GHSJK
1223  */
1224 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_002, testing::ext::TestSize.Level0)
1225 {
1226     // 1. set packName not null
1227     std::string packName = "com.ohos.test";
1228     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1229     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1230     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1231     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1232     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
1233     int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1234     // 3. check ret is ERR_DM_FAILED
1235     ASSERT_EQ(ret, ERR_DM_FAILED);
1236     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1237 }
1238 
1239 /**
1240  * @tc.name: UnInitDeviceManager_003
1241  * @tc.desc: 1. set packName not null
1242  *           2. MOCK IpcClientProxy UnInit return DM_OK
1243  *           3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1244  *           4. check ret is DM_OK
1245  * deviceTypeId
1246  * @tc.type: FUNC
1247  * @tc.require: AR000GHSJK
1248  */
1249 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_003, testing::ext::TestSize.Level0)
1250 {
1251     // 1. set packName not null
1252     std::string packName = "com.ohos.test";
1253     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1254     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1255     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1256     ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1257     // 3. check ret is DM_OK
1258     ASSERT_EQ(ret, DM_OK);
1259 }
1260 
1261 /**
1262  * @tc.name: UnInitDeviceManager_004
1263  * @tc.desc: 1. set packName not null
1264  *           2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1265  *           3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1266  *           4. check ret is ERR_DM_FAILED
1267  * deviceTypeId
1268  * @tc.type: FUNC
1269  * @tc.require: AR000GHSJK
1270  */
1271 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_004, testing::ext::TestSize.Level0)
1272 {
1273     // 1. set packNamen not null
1274     std::string packName = "com.ohos.test";
1275     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1276     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1277     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1278     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1279     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1280     int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1281     // 3. check ret is ERR_DM_FAILED
1282     ASSERT_EQ(ret, ERR_DM_FAILED);
1283     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1284 }
1285 
1286 /**
1287  * @tc.name: UnInitDeviceManager_005
1288  * @tc.desc: 1. set packName not null
1289  *           2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED
1290  *           3. call DeviceManagerImpl::UnInitDeviceManager with parameter
1291  *           4. check ret is ERR_DM_FAILED
1292  * deviceTypeId
1293  * @tc.type: FUNC
1294  * @tc.require: AR000GHSJK
1295  */
1296 HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_005, testing::ext::TestSize.Level0)
1297 {
1298     // 1. set packName not null
1299     std::string packName = "com.ohos.test";
1300     // 2. call DeviceManagerImpl::InitDeviceManager with parameter
1301     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1302     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1303     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1304     EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1305     int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName);
1306     // 3. check ret is ERR_DM_FAILED
1307     ASSERT_EQ(ret, ERR_DM_FAILED);
1308     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1309 }
1310 
1311 /**
1312  * @tc.name: GetTrustedDeviceList_001
1313  * @tc.desc: 1. set packName null
1314  *              set extra null
1315  *              set deviceList null
1316  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1317  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1318  * deviceTypeId
1319  * @tc.type: FUNC
1320  * @tc.require: AR000GHSJK
1321  */
1322 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
1323 {
1324     // 1. set packName null
1325     std::string packName = "";
1326     // set extra null
1327     std::string extra = "";
1328     // set deviceList null
1329     std::vector<DmDeviceInfo> deviceList;
1330     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1331     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1332     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1333     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1334 }
1335 
1336 /**
1337  * @tc.name: GetTrustedDeviceList_002
1338  * @tc.desc: 1. set packName not null
1339  *              set extra null
1340  *              set deviceList null
1341  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1342  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1343  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1344  * deviceTypeId
1345  * @tc.type: FUNC
1346  * @tc.require: AR000GHSJK
1347  */
1348 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
1349 {
1350     // 1. set packName not null
1351     std::string packName = "com.ohos.test";
1352     // set extra null
1353     std::string extra = "";
1354     // set deviceList null
1355     std::vector<DmDeviceInfo> deviceList;
1356     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1357     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1358     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1359     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1360     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1361                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1362     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1363     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1364     // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1365     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1366     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1367 }
1368 
1369 /**
1370  * @tc.name: GetTrustedDeviceList_003
1371  * @tc.desc: 1. set packName not null
1372  *              set extra null
1373  *              set deviceList null
1374  *           2. MOCK IpcClientProxy SendRequest return DM_OK
1375  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1376  *           4. check ret is DM_OK
1377  * deviceTypeId
1378  * @tc.type: FUNC
1379  * @tc.require: AR000GHSJK
1380  */
1381 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0)
1382 {
1383     // 1. set packName not null
1384     std::string packName = "com.ohos.test";
1385     // set extra null
1386     std::string extra = "";
1387     // set deviceList null
1388     std::vector<DmDeviceInfo> deviceList;
1389     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1390     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1391     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1392     // 3. check ret is DM_OK
1393     ASSERT_EQ(ret, DM_OK);
1394     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1395 }
1396 
1397 /**
1398  * @tc.name: GetTrustedDeviceList_004
1399  * @tc.desc: 1. set packName not null
1400  *              set extra null
1401  *              set deviceList null
1402  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1403  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1404  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1405  * deviceTypeId
1406  * @tc.type: FUNC
1407  * @tc.require: AR000GHSJK
1408  */
1409 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_004, testing::ext::TestSize.Level0)
1410 {
1411     // 1. set packName not null
1412     std::string packName = "com.ohos.test";
1413     // set extra null
1414     std::string extra = "test";
1415     // set deviceList null
1416     std::vector<DmDeviceInfo> deviceList;
1417     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1418     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1419     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1420     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1421     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1422                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1423     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1424     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1425     // 3. check ret is DEVICEMANAGER_IPC_FAILED
1426     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1427     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1428 }
1429 
1430 /**
1431  * @tc.name: GetTrustedDeviceList_005
1432  * @tc.desc: 1. set packName null
1433  *              set extra null
1434  *              set deviceList null
1435  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1436  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1437  * deviceTypeId
1438  * @tc.type: FUNC
1439  * @tc.require: AR000GHSJK
1440  */
1441 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_005, testing::ext::TestSize.Level0)
1442 {
1443     // 1. set packName null
1444     std::string packName = "";
1445     // set extra null
1446     std::string extra = "test";
1447     // set deviceList null
1448     std::vector<DmDeviceInfo> deviceList;
1449     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1450     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList);
1451     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1452     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1453 }
1454 
1455 /**
1456  * @tc.name: GetTrustedDeviceList_006
1457  * @tc.desc: 1. set packName null
1458  *              set extra null
1459  *              set deviceList null
1460  *              set isRefresh true
1461  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1462  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1463  * deviceTypeId
1464  * @tc.type: FUNC
1465  */
1466 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_006, testing::ext::TestSize.Level0)
1467 {
1468     std::string packName = "";
1469     std::string extra = "";
1470     bool  isRefresh = true;
1471     std::vector<DmDeviceInfo> deviceList;
1472     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1473     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1474 }
1475 
1476 /**
1477  * @tc.name: GetTrustedDeviceList_007
1478  * @tc.desc: 1. set packName not null
1479  *              set extra null
1480  *              set deviceList null
1481  *              set isRefresh true
1482  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1483  *           3. check ret is DM_OK
1484  * deviceTypeId
1485  * @tc.type: FUNC
1486  */
1487 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_007, testing::ext::TestSize.Level0)
1488 {
1489     std::string packName = "com.ohos.test";
1490     std::string extra = "";
1491     bool  isRefresh = true;
1492     std::vector<DmDeviceInfo> deviceList;
1493     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList);
1494     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1495 }
1496 
1497 /**
1498  * @tc.name: GetTrustedDeviceList_008
1499  * @tc.desc: 1. set packName not null
1500  *              set extra null
1501  *              set deviceList null
1502  *              set isRefresh true
1503  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1504  *           3. check ret is DM_OK
1505  * deviceTypeId
1506  * @tc.type: FUNC
1507  */
1508 HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_008, testing::ext::TestSize.Level0)
1509 {
1510     std::string packName = "";
1511     std::map<std::string, std::string> filterOptions;
1512     bool isRefresh = false;
1513     std::vector<DmDeviceInfo> deviceList;
1514     int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
1515     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1516     packName = "packNameTest";
1517     ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList);
1518     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1519 }
1520 
1521 /**
1522  * @tc.name: ImportCredential_001
1523  * @tc.desc: 1. set pkgName not null
1524  *              set reqJsonStr null
1525  *              set returnJsonStr null
1526  *           2. call DeviceManagerImpl::ImportCredential with parameter
1527  *           3. check ret is DM_OK
1528  * deviceTypeId
1529  * @tc.type: FUNC
1530  */
1531 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
1532 {
1533     std::string pkgName = "";
1534     std::string reqJsonStr = "";
1535     std::string returnJsonStr = "";
1536     int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1537     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1538     ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1539     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1540     pkgName = "pkgNameTest";
1541     ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1542     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1543     ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1544     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1545     pkgName = "";
1546     reqJsonStr = "reqJsonStrTest";
1547     ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1548     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1549     ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1550     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1551     pkgName = "pkgNameTest";
1552     ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1553     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1554     ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1555     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1556     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1557     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1558     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1559     ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1560     ASSERT_EQ(ret, DM_OK);
1561     ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1562     ASSERT_EQ(ret, DM_OK);
1563 }
1564 
1565 /**
1566  * @tc.name: RequestCredential_001
1567  * @tc.desc: 1. set pkgName not null
1568  *              set reqJsonStr null
1569  *              set returnJsonStr null
1570  *           2. call DeviceManagerImpl::RequestCredential with parameter
1571  *           3. check ret is DM_OK
1572  * deviceTypeId
1573  * @tc.type: FUNC
1574  */
1575 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
1576 {
1577     std::string pkgName = "";
1578     std::string reqJsonStr = "";
1579     std::string returnJsonStr = "";
1580     int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1581     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1582     ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1583     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1584     pkgName = "pkgNameTest";
1585     ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1586     ASSERT_EQ(ret, DM_OK);
1587     ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1588     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1589     pkgName = "";
1590     reqJsonStr = "reqJsonStrTest";
1591     ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1592     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1593     ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1594     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1595     pkgName = "pkgNameTest";
1596     ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr);
1597     ASSERT_EQ(ret, DM_OK);
1598     ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1599     ASSERT_EQ(ret, DM_OK);
1600 }
1601 
1602 /**
1603  * @tc.name: GenerateEncryptedUuid_001
1604  * @tc.desc: 1. set packName null
1605  *              set extra null
1606  *              set deviceList null
1607  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1608  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1609  * deviceTypeId
1610  * @tc.type: FUNC
1611  */
1612 HWTEST_F(DeviceManagerImplTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0)
1613 {
1614     std::string pkgName = "";
1615     std::string uuid = "";
1616     std::string appId = "";
1617     std::string encryptedUuid = "";
1618     int32_t ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1619     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1620     pkgName = "pkgNameTest";
1621     ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1622     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1623     pkgName = "";
1624     uuid = "uuidTest";
1625     ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1626     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1627     pkgName = "pkgNameTest";
1628     ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1629     ASSERT_EQ(ret, DM_OK);
1630     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1631     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1632     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1633     ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1634     ASSERT_EQ(ret, DM_OK);
1635 }
1636 
1637 /**
1638  * @tc.name: GetNetworkTypeByNetworkId_001
1639  * @tc.desc: 1. set pkgName null
1640  *              set networkId null
1641  *              set networkType null
1642  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1643  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1644  * deviceTypeId
1645  * @tc.type: FUNC
1646  */
1647 HWTEST_F(DeviceManagerImplTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0)
1648 {
1649     std::string pkgName = "";
1650     std::string networkId = "";
1651     int32_t netWorkType = 0;
1652     int32_t ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1653     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1654     pkgName = "pkgNameTest";
1655     ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1656     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1657     pkgName = "";
1658     networkId = "networkIdTest";
1659     ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1660     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1661     pkgName = "pkgNameTest";
1662     ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1663     ASSERT_EQ(ret, DM_OK);
1664     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1665     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1666     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1667     ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType);
1668     ASSERT_EQ(ret, DM_OK);
1669 }
1670 
1671 /**
1672  * @tc.name: ImportAuthCode_001
1673  * @tc.desc: 1. set packName null
1674  *              set authCode null
1675  *           2. call DeviceManagerImpl::ImportAuthCode with parameter
1676  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1677  * deviceTypeId
1678  * @tc.type: FUNC
1679  */
1680 HWTEST_F(DeviceManagerImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
1681 {
1682     std::string pkgName = "";
1683     std::string authCode = "";
1684     int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1685     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1686     pkgName = "pkgNameTest";
1687     ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1688     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1689     pkgName = "";
1690     authCode = "authCodeTest";
1691     ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1692     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1693     pkgName = "pkgNameTest";
1694     ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1695     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1696     authCode = "authoCo";
1697     ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode);
1698     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1699 }
1700 
1701 /**
1702  * @tc.name: RegisterDiscoveryCallback_001
1703  * @tc.desc: 1. set packName null
1704  *              set discoverParam null
1705  *              set filterOptions null
1706  *              set callback null
1707  *           2. call DeviceManagerImpl::RegisterDiscoveryCallback with parameter
1708  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1709  * deviceTypeId
1710  * @tc.type: FUNC
1711  */
1712 HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0)
1713 {
1714     std::string pkgName = "";
1715     std::map<std::string, std::string> discoverParam;
1716     std::map<std::string, std::string> filterOptions;
1717     std::shared_ptr<DiscoveryCallback> callback = nullptr;
1718     int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName,
1719         discoverParam, filterOptions, callback);
1720     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1721     ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
1722     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1723     ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
1724     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1725     ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
1726     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1727     pkgName = "pkgNameTest";
1728     ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, callback);
1729     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1730     ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback);
1731     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1732     callback = std::make_shared<DeviceDiscoveryCallbackTest>();
1733     ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName);
1734     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1735     ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam);
1736     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1737 }
1738 
1739 /**
1740  * @tc.name: StartAdvertising_001
1741  * @tc.desc: 1. set packName null
1742  *              set discoverParam null
1743  *              set filterOptions null
1744  *              set callback null
1745  *           2. call DeviceManagerImpl::StartAdvertising with parameter
1746  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1747  * deviceTypeId
1748  * @tc.type: FUNC
1749  */
1750 HWTEST_F(DeviceManagerImplTest, StartAdvertising_001, testing::ext::TestSize.Level0)
1751 {
1752     std::string pkgName = "";
1753     std::map<std::string, std::string> advertiseParam;
1754     std::shared_ptr<PublishCallback> callback = nullptr;
1755     int32_t ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1756     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1757     ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
1758     pkgName = "pkgNameTest";
1759     ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1760     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1761     ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam);
1762     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1763     callback = std::make_shared<DevicePublishCallbackTest>();
1764     ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback);
1765     ASSERT_EQ(ret, DM_OK);
1766 }
1767 
1768 /**
1769  * @tc.name: BindTarget_001
1770  * @tc.desc: 1. set packName null
1771  *              set targetId null
1772  *              set unbindParam null
1773  *              set callback null
1774  *           2. call DeviceManagerImpl::BindTarget with parameter
1775  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1776  * deviceTypeId
1777  * @tc.type: FUNC
1778  */
1779 HWTEST_F(DeviceManagerImplTest, BindTarget_001, testing::ext::TestSize.Level0)
1780 {
1781     std::string pkgName = "";
1782     PeerTargetId targetId;
1783     std::map<std::string, std::string> unbindParam;
1784     std::shared_ptr<BindTargetCallback> callback = nullptr;
1785     std::shared_ptr<UnbindTargetCallback> uncallback = nullptr;
1786     int32_t ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1787     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1788     ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1789     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1790     targetId.deviceId = "deviceIdTest";
1791     targetId.brMac = "brMacTest";
1792     targetId.bleMac = "bleMacTest";
1793     targetId.wifiIp = "wifiIpTest";
1794     ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1795     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1796     ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1797     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1798     pkgName = "pkgNameTest";
1799     ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback);
1800     ASSERT_EQ(ret, DM_OK);
1801     ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback);
1802     ASSERT_EQ(ret, DM_OK);
1803 }
1804 
1805 /**
1806  * @tc.name: GetLocalDeviceInfo_001
1807  * @tc.desc: 1. set packName null
1808  *              set extra null
1809  *              set deviceList null
1810  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1811  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1812  * deviceTypeId
1813  * @tc.type: FUNC
1814  * @tc.require: AR000GHSJK
1815  */
1816 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
1817 {
1818     // 1. set packName not null
1819     std::string packName = "com.ohos.test";
1820     DmDeviceInfo info;
1821     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1822     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1823     ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1824     ASSERT_EQ(ret, DM_OK);
1825     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1826 }
1827 
1828 /**
1829  * @tc.name: GetLocalDeviceInfo_002
1830  * @tc.desc: 1. set packName not null
1831  *              set extra null
1832  *              set deviceList null
1833  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1834  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1835  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1836  * deviceTypeId
1837  * @tc.type: FUNC
1838  * @tc.require: AR000GHSJK
1839  */
1840 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0)
1841 {
1842     // 1. set packName not null
1843     std::string packName = "com.ohos.test";
1844     // set extra null
1845     DmDeviceInfo info;
1846     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
1847     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1848     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1849     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1850     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1851                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1852     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1853     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1854     // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1855     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1856     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1857 }
1858 
1859 /**
1860  * @tc.name: GetLocalDeviceInfo_003
1861  * @tc.desc: 1. set packName not null
1862  *              set extra null
1863  *              set deviceList null
1864  *           2. MOCK IpcClientProxy SendRequest return DM_OK
1865  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1866  *           4. check ret is DM_OK
1867  * deviceTypeId
1868  * @tc.type: FUNC
1869  * @tc.require: AR000GHSJK
1870  */
1871 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_003, testing::ext::TestSize.Level0)
1872 {
1873     // 1. set packName not null
1874     std::string packName = "com.ohos.test";
1875     // set extra null
1876     DmDeviceInfo info;
1877     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1878     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1879     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1880     ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1881     // 3. check ret is DM_OK
1882     ASSERT_EQ(ret, DM_OK);
1883     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1884 }
1885 
1886 /**
1887  * @tc.name: GetLocalDeviceInfo_004
1888  * @tc.desc: 1. set packName not null
1889  *              set extra null
1890  *              set deviceList null
1891  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1892  *           3. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1893  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
1894  * deviceTypeId
1895  * @tc.type: FUNC
1896  * @tc.require: AR000GHSJK
1897  */
1898 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_004, testing::ext::TestSize.Level0)
1899 {
1900     // 1. set packName not null
1901     std::string packName = "com.ohos.test";
1902     // set extra null
1903     DmDeviceInfo info;
1904     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1905     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1906     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1907     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1908     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1909                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1910     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1911     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1912     // 3. check ret is DEVICEMANAGER_IPC_FAILED
1913     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1914     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1915 }
1916 
1917 /**
1918  * @tc.name: GetLocalDeviceInfo_005
1919  * @tc.desc: 1. set packName null
1920  *              set extra null
1921  *              set deviceList null
1922  *           2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1923  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
1924  * deviceTypeId
1925  * @tc.type: FUNC
1926  * @tc.require: AR000GHSJK
1927  */
1928 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_005, testing::ext::TestSize.Level0)
1929 {
1930     // 1. set packName not null
1931     std::string packName = "";
1932     // set extra null
1933     DmDeviceInfo info;
1934     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
1935     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1936     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1937     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1938     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1939                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
1940     // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter
1941     int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info);
1942     // 3. check ret is DEVICEMANAGER_IPC_FAILED
1943     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1944     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1945 }
1946 
1947 /**
1948  * @tc.name: RegisterDevStateCallback_001
1949  * @tc.desc: 1. set packName null
1950  *              set extra null
1951  *              set callback null
1952  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1953  *           3. check ret is DEVICEMANAGER_INVALID_VALUE
1954  * deviceTypeId
1955  * @tc.type: FUNC
1956  * @tc.require: AR000GHSJK
1957  */
1958 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
1959 {
1960     // 1. set packName null
1961     std::string packName = "";
1962     // set extra null
1963     std::string extra = "";
1964     // set callback nullptr
1965     std::shared_ptr<DeviceStateCallback> callback = nullptr;
1966     //  2. call DeviceManagerImpl::AuthenticateDevice with parameter
1967     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback);
1968     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
1969     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1970 }
1971 
1972 /**
1973  * @tc.name: RegisterDevStateCallback_002
1974  * @tc.desc: 1. set packName not null
1975  *              set extra null
1976  *              set callback not null
1977  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
1978  *           3. check ret is DM_OK
1979  * deviceTypeId
1980  * @tc.type: FUNC
1981  * @tc.require: AR000GHSJK
1982  */
1983 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
1984 {
1985     // 1. set packName null
1986     std::string packName = "com.ohos.test";
1987     // set extra null
1988     std::string extra = "";
1989     // set callback not null
1990     std::shared_ptr<DeviceStateCallback> dsCallback =std::make_shared<DeviceStateCallbackTest>();
1991     std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>();
1992     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1993     //  2. call DeviceManagerImpl::AuthenticateDevice with parameter
1994     ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, dsCallback);
1995     // 3. check ret is DM_OK
1996     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1997     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1998 }
1999 
2000 /**
2001  * @tc.name: RegisterDevStateCallback_003
2002  * @tc.desc: 1. set packName null
2003  *              set extra not null
2004  *              set callback null
2005  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2006  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2007  * deviceTypeId
2008  * @tc.type: FUNC
2009  * @tc.require: AR000GHSJK
2010  */
2011 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0)
2012 {
2013     // 1. set packName null
2014     std::string pkgName = "";
2015     // set extra null
2016     std::string extra = "test";
2017     // set callback nullptr
2018     std::shared_ptr<DeviceStateCallback> callback = nullptr;
2019     //  2. call DeviceManagerImpl::AuthenticateDevice with parameter
2020     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2021     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2022     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2023 }
2024 
2025 /**
2026  * @tc.name: RegisterDevStateCallback_004
2027  * @tc.desc: 1. set packName not null
2028  *              set extra not null
2029  *              set callback not null
2030  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2031  *           3. check ret is DM_OK
2032  * deviceTypeId
2033  * @tc.type: FUNC
2034  * @tc.require: AR000GHSJK
2035  */
2036 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_004, testing::ext::TestSize.Level0)
2037 {
2038     // 1. set packName null
2039     std::string pkgName = "com.ohos.test";
2040     // set extra null
2041     std::string extra = "test";
2042     // set callback nullptr
2043     std::shared_ptr<DeviceStateCallback> callback = nullptr;
2044     //  2. call DeviceManagerImpl::AuthenticateDevice with parameter
2045     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2046     // 3. check ret is DM_OK
2047     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2048 }
2049 
2050 /**
2051  * @tc.name: RegisterDevStateCallback_005
2052  * @tc.desc: 1. set packName not null
2053  *              set extra not null
2054  *              set callback null
2055  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2056  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2057  * deviceTypeId
2058  * @tc.type: FUNC
2059  * @tc.require: AR000GHSJK
2060  */
2061 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::TestSize.Level0)
2062 {
2063     // 1. set packName null
2064     std::string pkgName = "com.ohos.test";
2065     // set extra null
2066     std::string extra = "test1";
2067     // set callback nullptr
2068     std::shared_ptr<DeviceStateCallback> callback = nullptr;
2069     //  2. call DeviceManagerImpl::AuthenticateDevice with parameter
2070     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback);
2071     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2072     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2073 }
2074 
2075 /**
2076  * @tc.name: RegisterDevStateCallback_006
2077  * @tc.desc: 1. set packName not null
2078  *              set extra not null
2079  *              set callback null
2080  *           2. call DeviceManagerImpl::RegisterDevStateCallback with parameter
2081  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2082  * deviceTypeId
2083  * @tc.type: FUNC
2084  * @tc.require: AR000GHSJK
2085  */
2086 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0)
2087 {
2088     std::string pkgName = "";
2089     std::map<std::string, std::string> extraParam;
2090     std::shared_ptr<DeviceStateCallback> callback = nullptr;
2091     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2092     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2093     pkgName = "pkgNameTest";
2094     ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2095     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2096     callback = std::make_shared<DeviceStateCallbackTest>();
2097     ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2098     ASSERT_EQ(ret, DM_OK);
2099     pkgName = "";
2100     ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback);
2101     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2102 }
2103 
2104 /**
2105  * @tc.name: UnRegisterDevStateCallback_001
2106  * @tc.desc: 1. set packName null
2107  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2108  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2109  * deviceTypeId
2110  * @tc.type: FUNC
2111  * @tc.require: AR000GHSJK
2112  */
2113 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
2114 {
2115     // 1. set packName null
2116     std::string packName = "";
2117     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2118     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2119     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2120     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2121 }
2122 
2123 /**
2124  * @tc.name: UnRegisterDevStateCallback_002
2125  * @tc.desc: 1. set packName null
2126  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2127  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2128  * deviceTypeId
2129  * @tc.type: FUNC
2130  * @tc.require: AR000GHSJK
2131  */
2132 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
2133 {
2134     // 1. set packName null
2135     std::string packName = "";
2136     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2137     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2138     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2139     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2140 }
2141 
2142 /**
2143  * @tc.name: UnRegisterDevStateCallback_003
2144  * @tc.desc: 1. set packName null
2145  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2146  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2147  * deviceTypeId
2148  * @tc.type: FUNC
2149  * @tc.require: AR000GHSJK
2150  */
2151 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_003, testing::ext::TestSize.Level0)
2152 {
2153     // 1. set packName null
2154     std::string packName = "";
2155     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2156     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2157     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2158     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2159 }
2160 
2161 /**
2162  * @tc.name: UnRegisterDevStateCallback_004
2163  * @tc.desc: 1. set packName null
2164  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2165  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2166  * deviceTypeId
2167  * @tc.type: FUNC
2168  * @tc.require: AR000GHSJK
2169  */
2170 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_004, testing::ext::TestSize.Level0)
2171 {
2172     // 1. set packName null
2173     std::string packName = "";
2174     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2175     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2176     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2177     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2178 }
2179 
2180 /**
2181  * @tc.name: UnRegisterDevStateCallback_005
2182  * @tc.desc: 1. set packName null
2183  *           2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter
2184  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2185  * deviceTypeId
2186  * @tc.type: FUNC
2187  * @tc.require: AR000GHSJK
2188  */
2189 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_005, testing::ext::TestSize.Level0)
2190 {
2191     // 1. set packName null
2192     std::string packName = "";
2193     // 2. call DeviceManagerImpl::AuthenticateDevice with parameter
2194     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName);
2195     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2196     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2197 }
2198 
2199 /**
2200  * @tc.name: StartDeviceDiscovery_001
2201  * @tc.desc: 1. set packName null
2202  *              set subscribeInfo null
2203  *              set callback null
2204  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2205  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2206  * deviceTypeId
2207  * @tc.type: FUNC
2208  * @tc.require: AR000GHSJK
2209  */
2210 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
2211 {
2212     // 1. set packName null
2213     std::string packName = "";
2214     // set subscribeInfo null
2215     std::string extra = "test";
2216     DmSubscribeInfo subscribeInfo;
2217     // set callback null
2218     std::shared_ptr<DiscoveryCallback> callback = nullptr;
2219     // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2220     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2221     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2222     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2223 }
2224 
2225 /**
2226  * @tc.name: StartDeviceDiscovery_002
2227  * @tc.desc: 1. set packName null
2228  *              set subscribeInfo null
2229  *              set callback null
2230  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2231  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
2232  * deviceTypeId
2233  * @tc.type: FUNC
2234  * @tc.require: AR000GHSJK
2235  */
2236 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
2237 {
2238     // 1. set packName null
2239     std::string packName = "com.ohos.helloworld";
2240     std::string extra = "test";
2241     // set subscribeInfo null
2242     DmSubscribeInfo subscribeInfo;
2243     // set callback null
2244     std::shared_ptr<DiscoveryCallback> callback = nullptr;
2245     // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2246     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2247     // 3. check ret is ERR_DM_INPUT_PARA_INVALID
2248     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2249 }
2250 
2251 /**
2252  * @tc.name: StartDeviceDiscovery_003
2253  * @tc.desc: 1. set packName null
2254  *              set subscribeInfo null
2255  *              set callback null
2256  *           2. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2257  *           3. check ret is DEVICEMANAGER_INVALID_VALUE
2258  * deviceTypeId
2259  * @tc.type: FUNC
2260  * @tc.require: AR000GHSJK
2261  */
2262 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
2263 {
2264     // 1. set packName not null
2265     std::string packName = "com.ohos.test";
2266     // set subscribeInfo is 0
2267     DmSubscribeInfo subscribeInfo;
2268     std::string extra = "test";
2269     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2270     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2271     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2272     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2273     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2274     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2275                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2276     // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
2277     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2278     // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2279     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2280     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2281 }
2282 
2283 /**
2284  * @tc.name: StartDeviceDiscovery_004
2285  * @tc.desc: 1. set packName not null
2286  *              set subscribeInfo null
2287  *              set callback not null
2288  *           2. MOCK IpcClientProxy SendRequest return DM_OK
2289  *           3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2290  *           4. check ret is DM_OK
2291  * deviceTypeId
2292  * @tc.type: FUNC
2293  * @tc.require: AR000GHSJK
2294  */
2295 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
2296 {
2297     // 1. set packName not null
2298     std::string packName = "com.ohos.helloworld";
2299     std::string extra = "test";
2300     // set subscribeInfo null
2301     DmSubscribeInfo subscribeInfo;
2302     // set callback not null
2303     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2304     // 2. MOCK IpcClientProxy SendRequest return DM_OK
2305     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2306     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2307     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2308     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2309                 .Times(1).WillOnce(testing::Return(DM_OK));
2310     // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2311     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2312     // 4. check ret is DM_OK
2313     ASSERT_EQ(ret, DM_OK);
2314     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2315 }
2316 
2317 /**
2318  * @tc.name: StartDeviceDiscovery_005
2319  * @tc.desc: 1. set packName not null
2320  *              set subscribeInfo null
2321  *              set callback not null
2322  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2323  *           3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2324  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
2325  * deviceTypeId
2326  * @tc.type: FUNC
2327  * @tc.require: AR000GHSJK
2328  */
2329 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
2330 {
2331     // 1. set packName not null
2332     std::string packName = "com.ohos.helloworld";
2333     std::string extra = "test";
2334     // set subscribeInfo null
2335     DmSubscribeInfo subscribeInfo;
2336     // set callback not null
2337     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
2338     // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED
2339     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2340     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2341     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2342     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
2343                 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED));
2344     // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
2345     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback);
2346     // 4. check ret is DEVICEMANAGER_IPC_FAILED
2347     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
2348     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
2349 }
2350 
2351 /**
2352  * @tc.name: IsSameAccount_001
2353  * @tc.desc: 1. set udid or bundleName null
2354  *           2. call DeviceManagerImpl::IsSameAccount with parameter
2355  *           3. check ret is false
2356  * @tc.type: FUNC
2357  */
2358 HWTEST_F(DeviceManagerImplTest, IsSameAccount_001, testing::ext::TestSize.Level0)
2359 {
2360     std::string udid = "";
2361     bool ret = DeviceManager::GetInstance().IsSameAccount(udid);
2362     ASSERT_EQ(ret, false);
2363 }
2364 
2365 /**
2366  * @tc.name: IsSameAccount_002
2367  * @tc.desc: 1. set udid and bundleName not null
2368  *           2. call DeviceManagerImpl::IsSameAccount with parameter
2369  *           3. check ret is true
2370  * @tc.type: FUNC
2371  */
2372 HWTEST_F(DeviceManagerImplTest, IsSameAccount_002, testing::ext::TestSize.Level0)
2373 {
2374     std::string udid = "udidTest";
2375     std::string pkgName = "com.ohos.sameaccounttest";
2376     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
2377     DeviceManager::GetInstance().InitDeviceManager(pkgName, initCallback);
2378     bool ret = DeviceManager::GetInstance().IsSameAccount(udid);
2379     ASSERT_EQ(ret, true);
2380 }
2381 
2382 /**
2383  * @tc.name: AddPublishCallback_001
2384  * @tc.desc: 1. set udid and bundleName not null
2385  *           2. call DeviceManagerImpl::AddPublishCallback with parameter
2386  *           3. check ret is true
2387  * @tc.type: FUNC
2388  */
2389 HWTEST_F(DeviceManagerImplTest, AddPublishcCllback_001, testing::ext::TestSize.Level0)
2390 {
2391     std::string pkgName = "com.ohos.test";
2392     int32_t ret = DeviceManagerImpl::GetInstance().AddPublishCallback(pkgName);
2393     ASSERT_NE(ret, 0);
2394     ret = DeviceManagerImpl::GetInstance().RemovePublishCallback(pkgName);
2395     ASSERT_NE(ret, 0);
2396 }
2397 
2398 /**
2399  * @tc.name: RegisterPinHolderCallback_001
2400  * @tc.desc: 1. set udid and bundleName not null
2401  *           2. call DeviceManagerImpl::RegisterPinHolderCallback with parameter
2402  *           3. check ret is true
2403  * @tc.type: FUNC
2404  */
2405 HWTEST_F(DeviceManagerImplTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0)
2406 {
2407     std::string pkgName = "";
2408     std::shared_ptr<PinHolderCallback> callback = nullptr;
2409     int32_t ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
2410     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2411     pkgName = "pkgNameTest";
2412     ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback);
2413     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2414 }
2415 
2416 /**
2417  * @tc.name: CreatePinHolder_001
2418  * @tc.desc: 1. set udid and bundleName not null
2419  *           2. call DeviceManagerImpl::CreatePinHolder with parameter
2420  *           3. check ret is true
2421  * @tc.type: FUNC
2422  */
2423 HWTEST_F(DeviceManagerImplTest, CreatePinHolder_001, testing::ext::TestSize.Level0)
2424 {
2425     std::string pkgName = "";
2426     PeerTargetId targetId;
2427     DmPinType pinType = DmPinType::QR_CODE;
2428     std::string payload = "payload";
2429     int32_t ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2430     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2431     pkgName = "com.ohos.test";
2432     targetId.deviceId = "deviceIdTest";
2433     targetId.brMac = "brMacTest";
2434     targetId.bleMac = "bleMacTest";
2435     targetId.wifiIp = "wifiIpTest";
2436     pinType = static_cast<DmPinType>(6);
2437     ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2438     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2439     pinType = DmPinType::QR_CODE;
2440     payload.resize(DM_STRING_LENGTH_MAX * 2);
2441     ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2442     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2443     payload.resize(10);
2444     ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2445     ASSERT_EQ(ret, DM_OK);
2446     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2447     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2448     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2449     ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2450     ASSERT_EQ(ret, DM_OK);
2451 }
2452 
2453 /**
2454  * @tc.name: DestroyPinHolder_001
2455  * @tc.desc: 1. set udid and bundleName not null
2456  *           2. call DeviceManagerImpl::DestroyPinHolder with parameter
2457  *           3. check ret is true
2458  * @tc.type: FUNC
2459  */
2460 HWTEST_F(DeviceManagerImplTest, DestoryPinHolder_001, testing::ext::TestSize.Level0)
2461 {
2462     std::string pkgName = "";
2463     PeerTargetId targetId;
2464     DmPinType pinType = DmPinType::QR_CODE;
2465     std::string payload = "payload";
2466     int32_t ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2467     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2468     pkgName = "com.ohos.test";
2469     targetId.deviceId = "deviceIdTest";
2470     targetId.brMac = "brMacTest";
2471     targetId.bleMac = "bleMacTest";
2472     targetId.wifiIp = "wifiIpTest";
2473     pinType = static_cast<DmPinType>(6);
2474     ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2475     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2476     pinType = DmPinType::QR_CODE;
2477     payload.resize(DM_STRING_LENGTH_MAX * 2);
2478     ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2479     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2480     payload.resize(10);
2481     ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2482     ASSERT_EQ(ret, DM_OK);
2483     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2484     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2485     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2486     ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2487     ASSERT_EQ(ret, DM_OK);
2488 }
2489 
2490 /**
2491  * @tc.name: DpAclAdd_001
2492  * @tc.desc: 1. set DpAclAdd and Udid not null
2493  *           2. call DeviceManagerImpl::DpAclAdd with parameter
2494  *           3. check ret is true
2495  * @tc.type: FUNC
2496  */
2497 HWTEST_F(DeviceManagerImplTest, DpAclAdd_001, testing::ext::TestSize.Level0)
2498 {
2499     int64_t accessControlId = 0;
2500     std::string udid = "udidTest";
2501     int32_t bindType = PEER_TO_PEER;
2502     int32_t ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2503     ASSERT_EQ(ret, DM_OK);
2504     bindType = IDENTICAL_ACCOUNT;
2505     ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2506     ASSERT_EQ(ret, DM_OK);
2507     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
2508     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
2509     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
2510     ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType);
2511     ASSERT_EQ(ret, DM_OK);
2512 }
2513 
2514 /**
2515  * @tc.name: GetDeviceSecurityLevel_001
2516  * @tc.desc: 1. set DpAclAdd and Udid not null
2517  *           2. call DeviceManagerImpl::GetDeviceSecurityLevel with parameter
2518  *           3. check ret is true
2519  * @tc.type: FUNC
2520  */
2521 HWTEST_F(DeviceManagerImplTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0)
2522 {
2523     int32_t securityLevel = 3;
2524     std::string pkgName = "";
2525     std::string netWorkId = "";
2526     int32_t ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2527     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2528     pkgName = "com.ohos.test";
2529     ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2530     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2531     netWorkId = "netWorkIdTest";
2532     ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2533     ASSERT_EQ(ret, DM_OK);
2534     pkgName = "";
2535     ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel);
2536     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2537 }
2538 } // namespace
2539 } // namespace DistributedHardware
2540 } // namespace OHOS