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