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  */
HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RequestCredential_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RequestCredential_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RequestCredential_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, ImportCredential_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, ImportCredential_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, ImportCredential_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, CheckAPIAccessPermission_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_003, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_001, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_002, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_105, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_106, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, RequestCredential_101, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, CheckCredential_101, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, ImportCredential_101, testing::ext::TestSize.Level0)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  */
HWTEST_F(DeviceManagerImplTest, DeleteCredential_101, testing::ext::TestSize.Level0)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 }
HWTEST_F(DeviceManagerImplTest, VerifyAuthentication001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, GetFaParam001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RequestCredential001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RequestCredential002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RequestCredential003, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, ImportCredential001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, ImportCredential002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, ImportCredential003, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, DeleteCredential001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, DeleteCredential002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, DeleteCredential003, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy001, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy002, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy003, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy004, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy005, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, SetDnPolicy006, testing::ext::TestSize.Level0)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 
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_301, testing::ext::TestSize.Level0)1179 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_301, testing::ext::TestSize.Level0)
1180 {
1181     std::string packName;
1182     uint64_t tokenId = 123;
1183     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1184     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1185     int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(tokenId, packName);
1186     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1187     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1188 }
1189 
HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_302, testing::ext::TestSize.Level0)1190 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_302, testing::ext::TestSize.Level0)
1191 {
1192     std::string packName = "com.ohos.test";
1193     uint64_t tokenId = 123;
1194     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1195     DeviceManagerImpl::GetInstance().InitDeviceManager(packName, callback);
1196     DeviceManagerImpl::GetInstance().subscribIdMap_[tokenId] = 12345;
1197     DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
1198     DeviceManagerImpl::GetInstance().subscribIdMap_.erase(tokenId);
1199     int32_t ret = DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
1200     ASSERT_EQ(ret, ERR_DM_STOP_DISCOVERY);
1201     DeviceManagerImpl::GetInstance().UnInitDeviceManager(packName);
1202 }
1203 
HWTEST_F(DeviceManagerImplTest, RegisterUiStateCallback_301, testing::ext::TestSize.Level0)1204 HWTEST_F(DeviceManagerImplTest, RegisterUiStateCallback_301, testing::ext::TestSize.Level0)
1205 {
1206     std::string packName;
1207     int32_t ret = DeviceManagerImpl::GetInstance().RegisterUiStateCallback(packName);
1208     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1209 }
1210 
HWTEST_F(DeviceManagerImplTest, UnRegisterUiStateCallback_301, testing::ext::TestSize.Level0)1211 HWTEST_F(DeviceManagerImplTest, UnRegisterUiStateCallback_301, testing::ext::TestSize.Level0)
1212 {
1213     std::string packName;
1214     DeviceManager::GetInstance().CheckNewAPIAccessPermission();
1215     int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterUiStateCallback(packName);
1216     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1217 }
1218 
HWTEST_F(DeviceManagerImplTest, StopAdvertising_301, testing::ext::TestSize.Level0)1219 HWTEST_F(DeviceManagerImplTest, StopAdvertising_301, testing::ext::TestSize.Level0)
1220 {
1221     std::string packName;
1222     std::map<std::string, std::string> advertiseParam;
1223     int32_t ret = DeviceManager::GetInstance().StopAdvertising(packName, advertiseParam);
1224     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1225 }
1226 
HWTEST_F(DeviceManagerImplTest, CheckAccessToTarget_301, testing::ext::TestSize.Level0)1227 HWTEST_F(DeviceManagerImplTest, CheckAccessToTarget_301, testing::ext::TestSize.Level0)
1228 {
1229     uint64_t tokenId = 123;
1230     std::string targetId;
1231     int32_t ret = DeviceManager::GetInstance().CheckAccessToTarget(tokenId, targetId);
1232     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
1233 }
1234 
HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_301, testing::ext::TestSize.Level0)1235 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_301, testing::ext::TestSize.Level0)
1236 {
1237     std::string pkgName;
1238     std::shared_ptr<DevTrustChangeCallback> callback = nullptr;
1239     int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1240     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1241 }
1242 
HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_302, testing::ext::TestSize.Level0)1243 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_302, testing::ext::TestSize.Level0)
1244 {
1245     std::string pkgName = "com.ohos.test";
1246     std::shared_ptr<DevTrustChangeCallback> callback = nullptr;
1247     int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1248     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1249 }
1250 
HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_303, testing::ext::TestSize.Level0)1251 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_303, testing::ext::TestSize.Level0)
1252 {
1253     std::string pkgName = "com.ohos.test";
1254     std::shared_ptr<DevTrustChangeCallback> callback = std::make_shared<DevTrustChangeCallbackTest>();
1255     int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1256     ASSERT_EQ(ret, DM_OK);
1257 }
1258 
HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_304, testing::ext::TestSize.Level0)1259 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_304, testing::ext::TestSize.Level0)
1260 {
1261     std::string pkgName;
1262     std::shared_ptr<DevTrustChangeCallback> callback = std::make_shared<DevTrustChangeCallbackTest>();
1263     int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback);
1264     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1265 }
1266 
HWTEST_F(DeviceManagerImplTest, GetErrCode_301, testing::ext::TestSize.Level0)1267 HWTEST_F(DeviceManagerImplTest, GetErrCode_301, testing::ext::TestSize.Level0)
1268 {
1269     int32_t errCode = ERR_DM_TIME_OUT;
1270     int32_t ret = DeviceManager::GetInstance().GetErrCode(errCode);
1271     ASSERT_EQ(ret, 96929745);
1272 }
1273 
HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)1274 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1275 {
1276     std::string packName = "";
1277     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1278     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1279     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1280 }
1281 
HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)1282 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1283 {
1284     std::string packName = "com.ohos.screenStatustest01";
1285     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = nullptr;
1286     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1287     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1288 }
1289 
HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_003, testing::ext::TestSize.Level0)1290 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_003, testing::ext::TestSize.Level0)
1291 {
1292     std::string packName = "com.ohos.screenStatustest02";
1293     std::shared_ptr<DeviceScreenStatusCallbackTest> callback = std::make_shared<DeviceScreenStatusCallbackTest>();
1294     int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(packName, callback);
1295     ASSERT_EQ(ret, DM_OK);
1296 }
1297 
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)1298 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_001, testing::ext::TestSize.Level0)
1299 {
1300     std::string packName = "com.ohos.screenStatustest03";
1301     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1302     ASSERT_EQ(ret, DM_OK);
1303 }
1304 
HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)1305 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_002, testing::ext::TestSize.Level0)
1306 {
1307     std::string packName = "";
1308     int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(packName);
1309     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1310 }
1311 
HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0)1312 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0)
1313 {
1314     std::string packName = "com.ohos.screenStatustest04";
1315     std::string networkId = "networkIdTest";
1316     int32_t screenStatus = -1;
1317     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1318     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1319     int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1320     ASSERT_EQ(ret, DM_OK);
1321     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1322 }
1323 
HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0)1324 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0)
1325 {
1326     std::string packName = "com.ohos.screenStatustest05";
1327     std::string networkId = "";
1328     int32_t screenStatus = -1;
1329     std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
1330     DeviceManager::GetInstance().InitDeviceManager(packName, callback);
1331     int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
1332     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1333     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1334 }
1335 
HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0)1336 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0)
1337 {
1338     std::string packName = "";
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_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1345     DeviceManager::GetInstance().UnInitDeviceManager(packName);
1346 }
1347 
HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)1348 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1349 {
1350     std::string packName = "";
1351     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1352         std::make_shared<CandidateRestrictStatusCallbackTest>();
1353     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1354     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1355 }
1356 
HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)1357 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1358 {
1359     std::string packName = "com.ohos.candidateRestrict01";
1360     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback = nullptr;
1361     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1362     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1363 }
1364 
HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_003, testing::ext::TestSize.Level0)1365 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_003, testing::ext::TestSize.Level0)
1366 {
1367     std::string packName = "com.ohos.scandidateRestrict02";
1368     std::shared_ptr<CandidateRestrictStatusCallbackTest> callback =
1369         std::make_shared<CandidateRestrictStatusCallbackTest>();
1370     int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(packName, callback);
1371     ASSERT_EQ(ret, DM_OK);
1372 }
1373 
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)1374 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_001, testing::ext::TestSize.Level0)
1375 {
1376     std::string packName = "com.ohos.candidateRestrict03";
1377     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1378     ASSERT_EQ(ret, DM_OK);
1379 }
1380 
HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)1381 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_002, testing::ext::TestSize.Level0)
1382 {
1383     std::string packName = "";
1384     int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(packName);
1385     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1386 }
1387 } // namespace
1388 } // namespace DistributedHardware
1389 } // namespace OHOS