1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "UTTest_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 {
46 namespace {
47 /**
48  * @tc.name: RequestCredential_001
49  * @tc.desc: 1. set packName null
50  *              set reqJsonStr null
51  *           2. call DeviceManagerImpl::RequestCredential with parameter
52  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
53  * deviceTypeId
54  * @tc.type: FUNC
55  * @tc.require: AR000GHSJK
56  */
57 HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
58 {
59     std::string packName;
60     std::string reqJsonStr;
61     std::string returnJsonStr;
62     int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
63                                                                 returnJsonStr);
64     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
65 }
66 
67 /**
68  * @tc.name: RequestCredential_002
69  * @tc.desc: 1. set packName not null
70  *              set reqJsonStr not null
71  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
72  *           3. call DeviceManagerImpl::RequestCredential with parameter
73  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
74  * deviceTypeId
75  * @tc.type: FUNC
76  * @tc.require: AR000GHSJK
77  */
78 HWTEST_F(DeviceManagerImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
79 {
80     std::string packName = "com.ohos.test";
81     std::string reqJsonStr = R"(
82     {
83         "version":"1.0.0.1",
84         "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
85     }
86     )";
87     std::string returnJsonStr;
88     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
89     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
90     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
91     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
92                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
93     int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
94                                                                 returnJsonStr);
95     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
96     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
97 }
98 
99 /**
100  * @tc.name: RequestCredential_003
101  * @tc.desc: 1. set packName not null
102  *              set reqJsonStr not null
103  *           2. MOCK IpcClientProxy SendRequest return DM_OK
104  *           3. call DeviceManagerImpl::RequestCredential with parameter
105  *           4. check ret is DM_OK
106  * deviceTypeId
107  * @tc.type: FUNC
108  * @tc.require: AR000GHSJK
109  */
110 HWTEST_F(DeviceManagerImplTest, RequestCredential_003, testing::ext::TestSize.Level0)
111 {
112     std::string packName = "com.ohos.test";
113     std::string reqJsonStr = R"(
114     {
115         "version":"1.0.0.1",
116         "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
117     }
118     )";
119     std::string returnJsonStr;
120     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
121     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
122     int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
123                                                                 returnJsonStr);
124     ASSERT_EQ(ret, DM_OK);
125     DeviceManager::GetInstance().UnInitDeviceManager(packName);
126 }
127 
128 /**
129  * @tc.name: RequestCredential_004
130  * @tc.desc: 1. set packName not null
131  *              set reqJsonStr not null
132  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
133  *           3. call DeviceManagerImpl::RequestCredential with parameter
134  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
135  * deviceTypeId
136  * @tc.type: FUNC
137  * @tc.require: AR000GHSJK
138  */
139 HWTEST_F(DeviceManagerImplTest, RequestCredential_004, testing::ext::TestSize.Level0)
140 {
141     std::string packName = "com.ohos.test";
142     std::string reqJsonStr = R"(
143     {
144         "version":"1.0.0.1",
145         "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
146     }
147     )";
148     std::string returnJsonStr;
149     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
150     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
151     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
152     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
153                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
154     int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, reqJsonStr,
155                                                                 returnJsonStr);
156     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
157     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
158 }
159 
160 /**
161  * @tc.name: ImportCredential_001
162  * @tc.desc: 1. set packName null
163  *              set reqJsonStr null
164  *           2. call DeviceManagerImpl::ImportCredential with parameter
165  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
166  * deviceTypeId
167  * @tc.type: FUNC
168  * @tc.require: AR000GHSJK
169  */
170 HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
171 {
172     std::string packName;
173     std::string credentialInfo;
174     int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
175     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
176 }
177 
178 /**
179  * @tc.name: ImportCredential_002
180  * @tc.desc: 1. set packName not null
181  *              set credentialInfo not null
182  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
183  *           3. call DeviceManagerImpl::ImportCredential with parameter
184  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
185  * deviceTypeId
186  * @tc.type: FUNC
187  * @tc.require: AR000GHSJK
188  */
189 HWTEST_F(DeviceManagerImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
190 {
191     std::string packName = "com.ohos.test";
192     std::string credentialInfo = R"(
193     {
194         "processType": 1,
195         "authType": 1,
196         "userId": "123",
197         "credentialData":
198         [
199             {
200                 "credentialType": 1,
201                 "credentialId": "104",
202                 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
203                 "serverPk": "",
204                 "pkInfoSignature": "",
205                 "pkInfo": "",
206                 "peerDeviceId": ""
207             }
208         ]
209     }
210     )";
211     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
212     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
213     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
214     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
215                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
216     int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
217     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
218     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
219 }
220 
221 /**
222  * @tc.name: ImportCredential_003
223  * @tc.desc: 1. set packName not null
224  *              set credentialInfo not null
225  *           2. MOCK IpcClientProxy SendRequest return DM_OK
226  *           3. call DeviceManagerImpl::ImportCredential with parameter
227  *           4. check ret is DM_OK
228  * deviceTypeId
229  * @tc.type: FUNC
230  * @tc.require: AR000GHSJK
231  */
232 HWTEST_F(DeviceManagerImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
233 {
234     std::string packName = "com.ohos.test";
235     std::string credentialInfo = R"(
236     {
237         "processType": 1,
238         "authType": 1,
239         "userId": "123",
240         "credentialData":
241         [
242             {
243                 "credentialType": 1,
244                 "credentialId": "104",
245                 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
246                 "serverPk": "",
247                 "pkInfoSignature": "",
248                 "pkInfo": "",
249                 "peerDeviceId": ""
250             }
251         ]
252     }
253     )";
254     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
255     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
256     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
257     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
258                 .Times(1).WillOnce(testing::Return(DM_OK));
259     int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
260     ASSERT_EQ(ret, DM_OK);
261     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
262 }
263 
264 /**
265  * @tc.name: ImportCredential_004
266  * @tc.desc: 1. set packName not null
267  *              set credentialInfo not null
268  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
269  *           3. call DeviceManagerImpl::ImportCredential with parameter
270  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
271  * deviceTypeId
272  * @tc.type: FUNC
273  * @tc.require: AR000GHSJK
274  */
275 HWTEST_F(DeviceManagerImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
276 {
277     std::string packName = "com.ohos.test";
278     std::string credentialInfo = R"(
279     {
280         "processType": 1,
281         "authType": 1,
282         "userId": "123",
283         "credentialData":
284         [
285             {
286                 "credentialType": 1,
287                 "credentialId": "104",
288                 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
289                 "serverPk": "",
290                 "pkInfoSignature": "",
291                 "pkInfo": "",
292                 "peerDeviceId": ""
293             }
294         ]
295     }
296     )";
297     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
298     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
299     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
300     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
301                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
302     int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo);
303     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
304     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
305 }
306 
307 /**
308  * @tc.name: DeleteCredential_001
309  * @tc.desc: 1. set packName null
310  *              set deleteInfo null
311  *           2. call DeviceManagerImpl::DeleteCredential with parameter
312  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
313  * deviceTypeId
314  * @tc.type: FUNC
315  * @tc.require: AR000GHSJK
316  */
317 HWTEST_F(DeviceManagerImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
318 {
319     std::string packName;
320     std::string deleteInfo;
321     int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
322     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
323 }
324 
325 /**
326  * @tc.name: DeleteCredential_002
327  * @tc.desc: 1. set packName not null
328  *              set deleteInfo not null
329  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED
330  *           3. call DeviceManagerImpl::DeleteCredential with parameter
331  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
332  * deviceTypeId
333  * @tc.type: FUNC
334  * @tc.require: AR000GHSJK
335  */
336 HWTEST_F(DeviceManagerImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
337 {
338     std::string packName = "com.ohos.test";
339     std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
340     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
341     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
342     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
343     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
344                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
345     int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
346     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
347     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
348 }
349 
350 /**
351  * @tc.name: DeleteCredential_003
352  * @tc.desc: 1. set packName not null
353  *              set deleteInfo not null
354  *           2. MOCK IpcClientProxy SendRequest return DM_OK
355  *           3. call DeviceManagerImpl::DeleteCredential with parameter
356  *           4. check ret is DM_OK
357  * deviceTypeId
358  * @tc.type: FUNC
359  * @tc.require: AR000GHSJK
360  */
361 HWTEST_F(DeviceManagerImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
362 {
363     std::string packName = "com.ohos.test";
364     std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
365     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
366     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
367     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
368     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
369                 .Times(1).WillOnce(testing::Return(DM_OK));
370     int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
371     ASSERT_EQ(ret, DM_OK);
372     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
373 }
374 
375 /**
376  * @tc.name: DeleteCredential_004
377  * @tc.desc: 1. set packName not null
378  *              set credentialInfo not null
379  *           2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED
380  *           3. call DeviceManagerImpl::DeleteCredential with parameter
381  *           4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
382  * deviceTypeId
383  * @tc.type: FUNC
384  * @tc.require: AR000GHSJK
385  */
386 HWTEST_F(DeviceManagerImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
387 {
388     std::string packName = "com.ohos.test";
389     std::string deleteInfo = R"({"processType":1,"authType":1,"userId":"123"})";
390     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
391     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
392     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
393     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
394                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
395     int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, deleteInfo);
396     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
397     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
398 }
399 
400 /**
401  * @tc.name: RegisterCredentialCallback_001
402  * @tc.desc: 1. set packName null
403  *              set callback null
404  *           3. call DeviceManagerImpl::RegisterCredentialCallback with parameter
405  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
406  * deviceTypeId
407  * @tc.type: FUNC
408  * @tc.require: AR000GHSJK
409  */
410 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
411 {
412     std::string packName = "";
413     std::shared_ptr<CredentialCallbackTest> callback = nullptr;
414     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
415     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
416 }
417 
418 /**
419  * @tc.name: RegisterCredentialCallback_002
420  * @tc.desc: 1. set packName not null
421  *              set callback not null
422  *           2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
423  *           3. check ret is DM_OK
424  * deviceTypeId
425  * @tc.type: FUNC
426  * @tc.require: AR000GHSJK
427  */
428 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
429 {
430     std::string packName = "com.ohos.test";
431     std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
432     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
433     DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
434     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
435     ASSERT_EQ(ret, DM_OK);
436     DeviceManager::GetInstance().UnInitDeviceManager(packName);
437 }
438 
439 /**
440  * @tc.name: RegisterCredentialCallback_003
441  * @tc.desc: 1. set packName not null
442  *              set callback null
443  *           2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
444  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
445  * deviceTypeId
446  * @tc.type: FUNC
447  * @tc.require: AR000GHSJK
448  */
449 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)
450 {
451     std::string packName = "com.ohos.test";
452     std::shared_ptr<CredentialCallbackTest> callback = nullptr;
453     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
454     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
455 }
456 
457 /**
458  * @tc.name: RegisterCredentialCallback_004
459  * @tc.desc: 1. set packName null
460  *              set callback not null
461  *           2. call DeviceManagerImpl::RegisterCredentialCallback with parameter
462  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
463  * deviceTypeId
464  * @tc.type: FUNC
465  * @tc.require: AR000GHSJK
466  */
467 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_004, testing::ext::TestSize.Level0)
468 {
469     std::string packName = "";
470     std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
471     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(packName, callback);
472     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
473 }
474 
475 /**
476  * @tc.name: UnRegisterCredentialCallback_001
477  * @tc.desc: 1. set packName null
478  *           2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
479  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
480  * deviceTypeId
481  * @tc.type: FUNC
482  * @tc.require: AR000GHSJK
483  */
484 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
485 {
486     std::string packName = "";
487     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
488     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
489 }
490 
491 /**
492  * @tc.name: UnRegisterCredentialCallback_002
493  * @tc.desc: 1. set packName not null
494  *           2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
495  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
496  * deviceTypeId
497  * @tc.type: FUNC
498  * @tc.require: AR000GHSJK
499  */
500 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
501 {
502     std::string packName = "com.ohos.test";
503     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
504     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
505     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
506     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
507                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
508     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
509     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
510     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
511 }
512 
513 /**
514  * @tc.name: UnRegisterCredentialCallback_003
515  * @tc.desc: 1. set packName not null
516  *              set callback null
517  *           2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
518  *           3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
519  * deviceTypeId
520  * @tc.type: FUNC
521  * @tc.require: AR000GHSJK
522  */
523 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)
524 {
525     // 1. set packName null
526     std::string packName = "com.ohos.test";
527     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
528     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
529     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
530     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
531                 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
532     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
533     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
534     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
535 }
536 
537 /**
538  * @tc.name: UnRegisterCredentialCallback_004
539  * @tc.desc: 1. set packName not null
540  *           2. call DeviceManagerImpl::UnRegisterCredentialCallback with parameter
541  *           3. check ret is DM_OK
542  * deviceTypeId
543  * @tc.type: FUNC
544  * @tc.require: AR000GHSJK
545  */
546 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_004, testing::ext::TestSize.Level0)
547 {
548     std::string packName = "com.ohos.test";
549     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
550     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
551     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(packName);
552     ASSERT_EQ(ret, DM_OK);
553     DeviceManager::GetInstance().UnInitDeviceManager(packName);
554 }
555 
556 /**
557  * @tc.name: OnDmServiceDied_001
558  * @tc.desc: 1. mock IpcClientProxy
559  *           2. call DeviceManagerImpl::OnDmServiceDied
560  *           3. check ret is DM_OK
561  * deviceTypeId
562  * @tc.type: FUNC
563  * @tc.require: AR000GHSJK
564  */
565 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)
566 {
567     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
568     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
569     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
570     int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
571     ASSERT_EQ(ret, DM_OK);
572     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
573 }
574 
575 /**
576  * @tc.name: OnDmServiceDied_001
577  * @tc.desc: 1. mock IpcClientProxy
578  *           2. call DeviceManagerImpl::OnDmServiceDied
579  *           3. check ret is DM_OK
580  * deviceTypeId
581  * @tc.type: FUNC
582  * @tc.require: AR000GHSJK
583  */
584 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)
585 {
586     // 1. mock IpcClientProxy
587     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
588     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
589     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
590     EXPECT_CALL(*mockInstance, OnDmServiceDied()).Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
591     // 2. call DeviceManagerImpl::OnDmServiceDied
592     int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied();
593     // 3. check ret is DM_OK
594     ASSERT_EQ(ret, ERR_DM_FAILED);
595     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
596 }
597 
598 /**
599  * @tc.name: NotifyEvent_001
600  * @tc.desc: 1. mock IpcClientProxy
601  *           2. call DeviceManagerImpl::NotifyEvent
602  *           3. check ret is DM_OK
603  * deviceTypeId
604  * @tc.type: FUNC
605  */
606 HWTEST_F(DeviceManagerImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
607 {
608     std::string packName = "com.ohos.test";
609     int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
610     std::string event = R"({"extra": {"deviceId": "123"})";
611     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
612     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
613     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
614     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
615                 .Times(1).WillOnce(testing::Return(DM_OK));
616     int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
617     ASSERT_EQ(ret, DM_OK);
618     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
619 }
620 
621 /**
622  * @tc.name: NotifyEvent_002
623  * @tc.desc: 1. mock IpcClientProxy
624  *           2. call DeviceManagerImpl::NotifyEvent
625  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
626  * deviceTypeId
627  * @tc.type: FUNC
628  */
629 HWTEST_F(DeviceManagerImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
630 {
631     std::string packName = "";
632     int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
633     std::string event = R"({"extra": {"deviceId": "123"})";
634     int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
635     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
636 }
637 
638 /**
639  * @tc.name: NotifyEvent_003
640  * @tc.desc: 1. mock IpcClientProxy
641  *           2. call DeviceManagerImpl::NotifyEvent
642  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
643  * deviceTypeId
644  * @tc.type: FUNC
645  */
646 HWTEST_F(DeviceManagerImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
647 {
648     std::string packName = "com.ohos.test";
649     int32_t eventId = DM_NOTIFY_EVENT_START;
650     std::string event = R"({"extra": {"deviceId": "123"})";
651     int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
652     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
653 }
654 
655 /**
656  * @tc.name: NotifyEvent_004
657  * @tc.desc: 1. mock IpcClientProxy
658  *           2. call DeviceManagerImpl::NotifyEvent
659  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
660  * deviceTypeId
661  * @tc.type: FUNC
662  */
663 HWTEST_F(DeviceManagerImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)
664 {
665     std::string packName = "com.ohos.test";
666     int32_t eventId = DM_NOTIFY_EVENT_BUTT;
667     std::string event = R"({"extra": {"deviceId": "123"})";
668     int32_t ret = DeviceManager::GetInstance().NotifyEvent(packName, eventId, event);
669     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
670 }
671 
672 /**
673  * @tc.name: CheckAPIAccessPermission_001
674  * @tc.desc: 1. InitDeviceManager
675  *           2. call DeviceManagerImpl::CheckAPIAccessPermission
676  *           3. check ret is DM_OK
677  *           4. UnInitDeviceManager
678  * deviceTypeId
679  * @tc.type: FUNC
680  */
681 HWTEST_F(DeviceManagerImplTest, CheckAPIAccessPermission_001, testing::ext::TestSize.Level0)
682 {
683     std::string packName = "com.ohos.test";
684     std::shared_ptr<CredentialCallbackTest> callback = std::make_shared<CredentialCallbackTest>();
685     std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>();
686     DeviceManager::GetInstance().InitDeviceManager(packName, initCallback);
687     int32_t ret = DeviceManager::GetInstance().CheckAPIAccessPermission();
688     ASSERT_EQ(ret, DM_OK);
689     DeviceManager::GetInstance().UnInitDeviceManager(packName);
690 }
691 
692 /**
693  * @tc.name: RegisterDevStatusCallback_001
694  * @tc.desc: 1. InitDeviceManager
695  *           2. call DeviceManagerImpl::RegisterDevStatusCallback
696  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
697  * deviceTypeId
698  * @tc.type: FUNC
699  */
700 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
701 {
702     std::string pkgName;
703     std::string extra;
704     std::shared_ptr<DeviceStatusCallback> callback = nullptr;
705     int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(pkgName, extra, callback);
706     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
707 }
708 
709 /**
710  * @tc.name: RegisterDevStatusCallback_002
711  * @tc.desc: 1. InitDeviceManager
712  *           2. call DeviceManagerImpl::RegisterDevStatusCallback
713  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
714  * deviceTypeId
715  * @tc.type: FUNC
716  */
717 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
718 {
719     std::string packName = "com.ohos.test";
720     std::string extra;
721     std::shared_ptr<DeviceStatusCallback> callback = nullptr;
722     int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
723     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
724 }
725 
726 /**
727  * @tc.name: RegisterDevStatusCallback_003
728  * @tc.desc: 1. InitDeviceManager
729  *           2. call DeviceManagerImpl::RegisterDevStatusCallback
730  *           3. check ret is DM_OK
731  * deviceTypeId
732  * @tc.type: FUNC
733  */
734 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_003, testing::ext::TestSize.Level0)
735 {
736     std::string packName = "com.ohos.test";
737     std::string extra;
738     std::shared_ptr<DeviceStatusCallback> callback = std::make_shared<DeviceStatusCallbackTest>();
739     int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(packName, extra, callback);
740     ASSERT_EQ(ret, DM_OK);
741 }
742 
743 /**
744  * @tc.name: UnRegisterDevStatusCallback_001
745  * @tc.desc: 1. InitDeviceManager
746  *           2. call DeviceManagerImpl::UnRegisterDevStatusCallback
747  *           3. check ret is ERR_DM_INPUT_PARA_INVALID
748  * deviceTypeId
749  * @tc.type: FUNC
750  */
751 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_001, testing::ext::TestSize.Level0)
752 {
753     std::string packName;
754     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
755     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
756 }
757 
758 /**
759  * @tc.name: UnRegisterDevStatusCallback_002
760  * @tc.desc: 1. InitDeviceManager
761  *           2. call DeviceManagerImpl::UnRegisterDevStatusCallback
762  *           3. check ret is DM_OK
763  * deviceTypeId
764  * @tc.type: FUNC
765  */
766 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_002, testing::ext::TestSize.Level0)
767 {
768     std::string packName = "com.ohos.test";
769     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(packName);
770     ASSERT_EQ(ret, DM_OK);
771 }
772 
773 /**
774  * @tc.name: StartDeviceDiscovery_104
775  * @tc.desc: 1. set packName null
776  *              set subscribeId 0
777  *              set filterOptions null
778  *              set callback not null
779  *           2. InitDeviceManager return DM_OK
780  *           3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
781  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
782  * deviceTypeId
783  * @tc.type: FUNC
784  * @tc.require: AR000GHSJK
785  */
786 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)
787 {
788     std::string packName;
789     uint16_t subscribeId = 0;
790     std::string filterOptions;
791     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
792     DmDeviceBasicInfo deviceBasicInfo;
793     callback->OnDeviceFound(subscribeId, deviceBasicInfo);
794     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
795     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
796     ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
797     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
798     DeviceManager::GetInstance().UnInitDeviceManager(packName);
799 }
800 
801 /**
802  * @tc.name: StartDeviceDiscovery_105
803  * @tc.desc: 1. set packName not null
804  *              set subscribeId 0
805  *              set filterOptions null
806  *              set callback not null
807  *           2. InitDeviceManager return DM_OK
808  *           3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
809  *           4. check ret is ERR_DM_INPUT_PARA_INVALID
810  * deviceTypeId
811  * @tc.type: FUNC
812  * @tc.require: AR000GHSJK
813  */
814 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_105, testing::ext::TestSize.Level0)
815 {
816     std::string packName = "com.ohos.test";
817     uint16_t subscribeId = 0;
818     std::string filterOptions;
819     std::shared_ptr<DiscoveryCallback> callback = nullptr;
820     int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
821     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
822 }
823 
824 /**
825  * @tc.name: StartDeviceDiscovery_106
826  * @tc.desc: 1. set packName not null
827  *              set subscribeId 0
828  *              set filterOptions not null
829  *              set callback not null
830  *           2. InitDeviceManager return DM_OK
831  *           3. call DeviceManagerImpl::StartDeviceDiscovery with parameter
832  *           4. check ret is DM_OK
833  * deviceTypeId
834  * @tc.type: FUNC
835  * @tc.require: AR000GHSJK
836  */
837 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_106, testing::ext::TestSize.Level0)
838 {
839     std::string packName = "com.ohos.test";
840     uint16_t subscribeId = -1;
841     std::string filterOptions = "filterOptions";
842     DeviceManagerImpl::GetInstance().subscribIdMap_.clear();
843     std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
844     std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
845     int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
846     ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
847     ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
848     DeviceManager::GetInstance().UnInitDeviceManager(packName);
849 }
850 
851 /**
852  * @tc.name: RequestCredential_101
853  * @tc.desc: 1. set packName not null
854  *              set reqJsonStr not null
855  *           2. MOCK IpcClientProxy SendRequest return DM_OK
856  *           3. call DeviceManagerImpl::RequestCredential with parameter
857  *           4. check ret is DM_OK
858  * deviceTypeId
859  * @tc.type: FUNC
860  * @tc.require: AR000GHSJK
861  */
862 HWTEST_F(DeviceManagerImplTest, RequestCredential_101, testing::ext::TestSize.Level0)
863 {
864     std::string packName = "com.ohos.test";
865     std::string returnJsonStr;
866     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
867     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
868     int32_t ret = DeviceManager::GetInstance().RequestCredential(packName, returnJsonStr);
869     DeviceManager::GetInstance().UnInitDeviceManager(packName);
870     ASSERT_EQ(ret, DM_OK);
871 }
872 
873 /**
874  * @tc.name: CheckCredential_101
875  * @tc.desc: 1. set packName not null
876  *              set credentialInfo not null
877  *           2. MOCK IpcClientProxy SendRequest return DM_OK
878  *           3. call DeviceManagerImpl::ImportCredential with parameter
879  *           4. check ret is DM_OK
880  * deviceTypeId
881  * @tc.type: FUNC
882  * @tc.require: AR000GHSJK
883  */
884 HWTEST_F(DeviceManagerImplTest, CheckCredential_101, testing::ext::TestSize.Level0)
885 {
886     std::string packName = "com.ohos.test";
887     std::string credentialInfo = "{\n}";
888     std::string returnJsonStr;
889     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
890     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
891     int32_t ret = DeviceManager::GetInstance().CheckCredential(packName, credentialInfo, returnJsonStr);
892     DeviceManager::GetInstance().UnInitDeviceManager(packName);
893     ASSERT_EQ(ret, DM_OK);
894 }
895 
896 /**
897  * @tc.name: ImportCredential_101
898  * @tc.desc: 1. set packName not null
899  *              set credentialInfo not null
900  *           2. MOCK IpcClientProxy SendRequest return DM_OK
901  *           3. call DeviceManagerImpl::ImportCredential with parameter
902  *           4. check ret is DM_OK
903  * deviceTypeId
904  * @tc.type: FUNC
905  * @tc.require: AR000GHSJK
906  */
907 HWTEST_F(DeviceManagerImplTest, ImportCredential_101, testing::ext::TestSize.Level0)
908 {
909     std::string packName = "com.ohos.test";
910     std::string credentialInfo = R"(
911     {
912         "processType": 1,
913         "authType": 1,
914         "userId": "123",
915         "credentialData":
916         [
917             {
918                 "credentialType": 1,
919                 "credentialId": "104",
920                 "authCode": "10F9F0576E61730193D2052B7F771887124A68F1607EFCF7796C1491F834CD92",
921                 "serverPk": "",
922                 "pkInfoSignature": "",
923                 "pkInfo": "",
924                 "peerDeviceId": ""
925             }
926         ]
927     }
928     )";
929     std::string returnJsonStr;
930     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
931     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
932     int32_t ret = DeviceManager::GetInstance().ImportCredential(packName, credentialInfo, returnJsonStr);
933     DeviceManager::GetInstance().UnInitDeviceManager(packName);
934     ASSERT_EQ(ret, DM_OK);
935 }
936 
937 /**
938  * @tc.name: DeleteCredential_101
939  * @tc.desc: 1. set packName not null
940  *              set deleteInfo not null
941  *           2. MOCK IpcClientProxy SendRequest return DM_OK
942  *           3. call DeviceManagerImpl::DeleteCredential with parameter
943  *           4. check ret is DM_OK
944  * deviceTypeId
945  * @tc.type: FUNC
946  * @tc.require: AR000GHSJK
947  */
948 HWTEST_F(DeviceManagerImplTest, DeleteCredential_101, testing::ext::TestSize.Level0)
949 {
950     std::string packName = "com.ohos.test";
951     std::string credentialInfo = R"({"isDeleteAll":true})";
952     std::string returnJsonStr;
953     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
954     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
955     int32_t ret = DeviceManager::GetInstance().DeleteCredential(packName, credentialInfo, returnJsonStr);
956     DeviceManager::GetInstance().UnInitDeviceManager(packName);
957     ASSERT_EQ(ret, DM_OK);
958 }
959 HWTEST_F(DeviceManagerImplTest, VerifyAuthentication001, testing::ext::TestSize.Level0)
960 {
961     std::string pkgName;
962     std::string authPara;
963     std::shared_ptr<VerifyAuthCallback> callback = nullptr;
964     int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(pkgName, authPara, callback);
965     ASSERT_EQ(ret, DM_OK);
966 }
967 
968 HWTEST_F(DeviceManagerImplTest, GetFaParam001, testing::ext::TestSize.Level0)
969 {
970     std::string pkgName;
971     DmAuthParam dmFaParam;
972     int32_t ret = DeviceManager::GetInstance().GetFaParam(pkgName, dmFaParam);
973     ASSERT_EQ(ret, DM_OK);
974 }
975 
976 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback001, testing::ext::TestSize.Level0)
977 {
978     std::string pkgName;
979     std::string extra;
980     int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra);
981     ASSERT_EQ(ret, DM_OK);
982 }
983 
984 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback001, testing::ext::TestSize.Level0)
985 {
986     std::string pkgName;
987     std::string extra;
988     int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
989     ASSERT_EQ(ret, DM_OK);
990 }
991 
992 HWTEST_F(DeviceManagerImplTest, RequestCredential001, testing::ext::TestSize.Level0)
993 {
994     std::string pkgName;
995     std::string reqJsonStr;
996     std::string returnJsonStr;
997     int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
998     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
999 }
1000 
1001 HWTEST_F(DeviceManagerImplTest, RequestCredential002, testing::ext::TestSize.Level0)
1002 {
1003     std::string pkgName = "pkgName";
1004     std::string reqJsonStr;
1005     std::string returnJsonStr;
1006     int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
1007     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1008 }
1009 
1010 HWTEST_F(DeviceManagerImplTest, RequestCredential003, testing::ext::TestSize.Level0)
1011 {
1012     std::string pkgName = "pkgName";
1013     std::string reqJsonStr = "reqJsonStr";
1014     std::string returnJsonStr;
1015     int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr);
1016     EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1017 }
1018 
1019 HWTEST_F(DeviceManagerImplTest, ImportCredential001, testing::ext::TestSize.Level0)
1020 {
1021     std::string pkgName;
1022     std::string credentialInfo;
1023     int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
1024     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1025 }
1026 
1027 HWTEST_F(DeviceManagerImplTest, ImportCredential002, testing::ext::TestSize.Level0)
1028 {
1029     std::string pkgName = "pkgName";
1030     std::string credentialInfo;
1031     int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
1032     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1033 }
1034 
1035 HWTEST_F(DeviceManagerImplTest, ImportCredential003, testing::ext::TestSize.Level0)
1036 {
1037     std::string pkgName = "pkgName";
1038     std::string credentialInfo = "credentialInfo";
1039     int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo);
1040     EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1041 }
1042 
1043 HWTEST_F(DeviceManagerImplTest, DeleteCredential001, testing::ext::TestSize.Level0)
1044 {
1045     std::string pkgName;
1046     std::string deleteInfo;
1047     int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1048     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1049 }
1050 
1051 HWTEST_F(DeviceManagerImplTest, DeleteCredential002, testing::ext::TestSize.Level0)
1052 {
1053     std::string pkgName = "pkgName";
1054     std::string deleteInfo;
1055     int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1056     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1057 }
1058 
1059 HWTEST_F(DeviceManagerImplTest, DeleteCredential003, testing::ext::TestSize.Level0)
1060 {
1061     std::string pkgName = "pkgName";
1062     std::string deleteInfo = "deleteInfo";
1063     int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo);
1064     EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1065 }
1066 
1067 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback001, testing::ext::TestSize.Level0)
1068 {
1069     std::string pkgName;
1070     std::shared_ptr<CredentialCallback> callback = nullptr;
1071     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback);
1072     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1073 }
1074 
1075 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback002, testing::ext::TestSize.Level0)
1076 {
1077     std::string pkgName = "pkgName";
1078     std::shared_ptr<CredentialCallback> callback = nullptr;
1079     int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback);
1080     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1081 }
1082 
1083 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback001, testing::ext::TestSize.Level0)
1084 {
1085     std::string pkgName;
1086     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName);
1087     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1088 }
1089 
1090 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback002, testing::ext::TestSize.Level0)
1091 {
1092     DeviceManagerImpl::GetInstance().ipcClientProxy_->ipcClientManager_ = nullptr;
1093     std::string pkgName = "pkgName";
1094     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName);
1095     EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1096     DeviceManagerImpl::GetInstance().ipcClientProxy_->ipcClientManager_ = std::make_shared<IpcClientManager>();
1097 }
1098 
1099 HWTEST_F(DeviceManagerImplTest, SetDnPolicy001, testing::ext::TestSize.Level0)
1100 {
1101     std::string packName = "com.ohos.test";
1102     std::map<std::string, std::string> policy;
1103     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1104     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1105     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1106     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1107     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1108     bool bRet = false;
1109     if (ret == DM_OK || ret == ERR_DM_UNSUPPORTED_METHOD) {
1110         bRet = true;
1111     }
1112     ASSERT_EQ(bRet, true);
1113     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1114 }
1115 
1116 HWTEST_F(DeviceManagerImplTest, SetDnPolicy002, testing::ext::TestSize.Level0)
1117 {
1118     std::string packName = "com.ohos.test";
1119     std::map<std::string, std::string> policy;
1120     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1121     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1122     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1123     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1124     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1125     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1126 }
1127 
1128 HWTEST_F(DeviceManagerImplTest, SetDnPolicy003, testing::ext::TestSize.Level0)
1129 {
1130     std::string packName = "com.ohos.test";
1131     std::map<std::string, std::string> policy;
1132     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1133     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1134     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1135     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1136     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1137 }
1138 
1139 HWTEST_F(DeviceManagerImplTest, SetDnPolicy004, testing::ext::TestSize.Level0)
1140 {
1141     std::string packName;
1142     std::map<std::string, std::string> policy;
1143     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1144     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1145     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1146     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1147     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1148 }
1149 
1150 HWTEST_F(DeviceManagerImplTest, SetDnPolicy005, testing::ext::TestSize.Level0)
1151 {
1152     std::string packName;
1153     std::map<std::string, std::string> policy;
1154     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1155     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1156     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1157     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1158     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1159     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1160     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1161 }
1162 
1163 HWTEST_F(DeviceManagerImplTest, SetDnPolicy006, testing::ext::TestSize.Level0)
1164 {
1165     std::string packName = "com.ohos.test";
1166     std::map<std::string, std::string> policy;
1167     policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
1168     policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
1169     std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
1170     std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
1171     DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
1172     EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
1173                 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED));
1174     int32_t ret = DeviceManager::GetInstance().SetDnPolicy(packName, policy);
1175     ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
1176     DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
1177 }
1178 
1179 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1180 {
1181     std::string packName = "";
1182     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1183     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1184     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1185 }
1186 
1187 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1188 {
1189     std::string packName = "com.ohos.screenStatustest01";
1190     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = nullptr;
1191     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1192     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1193 }
1194 
1195 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_003, testing::ext::TestSize.Level0)
1196 {
1197     std::string packName = "com.ohos.screenStatustest02";
1198     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1199     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1200     ASSERT_EQ(ret, DM_OK);
1201 }
1202 
1203 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1204 {
1205     std::string packName = "com.ohos.screenStatustest03";
1206     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1207     ASSERT_EQ(ret, DM_OK);
1208 }
1209 
1210 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1211 {
1212     std::string packName = "";
1213     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1214     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1215 }
1216 
1217 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0)
1218 {
1219     std::string packName = "com.ohos.screenStatustest04";
1220     std::string networkId = "networkIdTest";
1221     int32_t screenStatus = -1;
1222     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1223     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1224     int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1225     ASSERT_EQ(ret, DM_OK);
1226     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1227 }
1228 
1229 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0)
1230 {
1231     std::string packName = "com.ohos.screenStatustest05";
1232     std::string networkId = "";
1233     int32_t screenStatus = -1;
1234     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1235     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1236     int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1237     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1238     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1239 }
1240 
1241 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0)
1242 {
1243     std::string packName = "";
1244     std::string networkId = "networkIdTest";
1245     int32_t screenStatus = -1;
1246     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1247     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1248     int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1249     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1250     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1251 }
1252 
1253 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1254 {
1255     std::string packName = "";
1256     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1257         std::make_shared<CandidateRestrictStatusCallbackTest>();
1258     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1259     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1260 }
1261 
1262 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1263 {
1264     std::string packName = "com.ohos.candidateRestrict01";
1265     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback = nullptr;
1266     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1267     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1268 }
1269 
1270 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_003, testing::ext::TestSize.Level0)
1271 {
1272     std::string packName = "com.ohos.scandidateRestrict02";
1273     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1274         std::make_shared<CandidateRestrictStatusCallbackTest>();
1275     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1276     ASSERT_EQ(ret, DM_OK);
1277 }
1278 
1279 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1280 {
1281     std::string packName = "com.ohos.candidateRestrict03";
1282     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1283     ASSERT_EQ(ret, DM_OK);
1284 }
1285 
1286 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1287 {
1288     std::string packName = "";
1289     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1290     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1291 }
1292 } // namespace
1293 } // namespace DistributedHardware
1294 } // namespace OHOS