1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "UTTest_device_manager_service_impl.h"
17 #include "softbus_error_code.h"
18 
19 namespace OHOS {
20 namespace DistributedHardware {
SetUp()21 void DeviceManagerServiceImplTest::SetUp()
22 {
23     if (deviceManagerServiceImpl_ == nullptr) {
24         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
25     }
26     deviceManagerServiceImpl_->Initialize(listener_);
27 }
28 
TearDown()29 void DeviceManagerServiceImplTest::TearDown()
30 {
31 }
32 
SetUpTestCase()33 void DeviceManagerServiceImplTest::SetUpTestCase()
34 {
35 }
36 
TearDownTestCase()37 void DeviceManagerServiceImplTest::TearDownTestCase()
38 {
39 }
40 
41 namespace {
42 
CheckSoftbusRes(int32_t ret)43 bool CheckSoftbusRes(int32_t ret)
44 {
45     return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR
46         || ret == SOFTBUS_IPC_ERR;
47 }
48 
49 /**
50  * @tc.name: Initialize_001
51  * @tc.desc: return DM_OK
52  * @tc.type: FUNC
53  */
54 HWTEST_F(DeviceManagerServiceImplTest, Initialize_001, testing::ext::TestSize.Level0)
55 {
56     if (deviceManagerServiceImpl_ == nullptr) {
57         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
58     }
59     deviceManagerServiceImpl_->commonEventManager_ = std::make_shared<DmCommonEventManager>();
60     int ret = deviceManagerServiceImpl_->Initialize(listener_);
61     EXPECT_EQ(ret, DM_OK);
62 }
63 
64 /**
65  * @tc.name: Initialize_002
66  * @tc.desc: return DM_OK
67  * @tc.type: FUNC
68  */
69 HWTEST_F(DeviceManagerServiceImplTest, Initialize_002, testing::ext::TestSize.Level0)
70 {
71     if (deviceManagerServiceImpl_ == nullptr) {
72         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
73     }
74     deviceManagerServiceImpl_->commonEventManager_ = nullptr;
75     int ret = deviceManagerServiceImpl_->Initialize(listener_);
76     EXPECT_EQ(ret, DM_OK);
77 }
78 
79 /**
80  * @tc.name: Initialize_003
81  * @tc.desc: return DM_OK
82  * @tc.type: FUNC
83  */
84 HWTEST_F(DeviceManagerServiceImplTest, Initialize_003, testing::ext::TestSize.Level0)
85 {
86     if (deviceManagerServiceImpl_ == nullptr) {
87         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
88     }
89     deviceManagerServiceImpl_->softbusConnector_ = nullptr;
90     deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
91     deviceManagerServiceImpl_->mineHiChainConnector_ = nullptr;
92     deviceManagerServiceImpl_->discoveryMgr_ = nullptr;
93     deviceManagerServiceImpl_->publishMgr_ = nullptr;
94     deviceManagerServiceImpl_->hiChainAuthConnector_ = nullptr;
95     deviceManagerServiceImpl_->deviceStateMgr_ = nullptr;
96     deviceManagerServiceImpl_->authMgr_ = nullptr;
97     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
98     int ret = deviceManagerServiceImpl_->Initialize(listener_);
99     EXPECT_EQ(ret, DM_OK);
100 }
101 
102 /**
103  * @tc.name: PraseNotifyEventJson_001
104  * @tc.desc: return ERR_DM_FAILED
105  * @tc.type: FUNC
106  */
107 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_001, testing::ext::TestSize.Level0)
108 {
109     std::string event = R"({"extra": {"deviceId": "123"})";
110     nlohmann::json jsonObject;
111     if (deviceManagerServiceImpl_ == nullptr) {
112         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
113     }
114     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
115     EXPECT_EQ(ret, ERR_DM_FAILED);
116 }
117 
118 /**
119  * @tc.name: PraseNotifyEventJson_002
120  * @tc.desc: return ERR_DM_FAILED
121  * @tc.type: FUNC
122  */
123 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_002, testing::ext::TestSize.Level0)
124 {
125     std::string event = R"({"content": {"deviceid": "123"}})";
126     nlohmann::json jsonObject;
127     if (deviceManagerServiceImpl_ == nullptr) {
128         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
129     }
130     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
131     EXPECT_EQ(ret, ERR_DM_FAILED);
132 }
133 
134 /**
135  * @tc.name: PraseNotifyEventJson_003
136  * @tc.desc: return ERR_DM_FAILED
137  * @tc.type: FUNC
138  */
139 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_003, testing::ext::TestSize.Level0)
140 {
141     std::string event = R"({"extra": {"deviceaId": "123"}})";
142     nlohmann::json jsonObject;
143     if (deviceManagerServiceImpl_ == nullptr) {
144         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
145     }
146     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
147     EXPECT_EQ(ret, ERR_DM_FAILED);
148 }
149 
150 /**
151  * @tc.name: PraseNotifyEventJson_004
152  * @tc.desc: return ERR_DM_FAILED
153  * @tc.type: FUNC
154  */
155 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_004, testing::ext::TestSize.Level0)
156 {
157     std::string event = R"({"extra": {"deviceId": 123}})";
158     nlohmann::json jsonObject;
159     if (deviceManagerServiceImpl_ == nullptr) {
160         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
161     }
162     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
163     EXPECT_EQ(ret, ERR_DM_FAILED);
164 }
165 
166 /**
167  * @tc.name: PraseNotifyEventJson_005
168  * @tc.desc: return ERR_DM_FAILED
169  * @tc.type: FUNC
170  */
171 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_005, testing::ext::TestSize.Level0)
172 {
173     std::string event = R"({"Extra": {"deviceId": "123"}})";
174     nlohmann::json jsonObject;
175     if (deviceManagerServiceImpl_ == nullptr) {
176         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
177     }
178     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
179     EXPECT_EQ(ret, ERR_DM_FAILED);
180 }
181 
182 /**
183  * @tc.name: PraseNotifyEventJson_006
184  * @tc.desc: return ERR_DM_FAILED
185  * @tc.type: FUNC
186  */
187 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_006, testing::ext::TestSize.Level0)
188 {
189     std::string event = R"({"extra":"123"}})";
190     nlohmann::json jsonObject;
191     if (deviceManagerServiceImpl_ == nullptr) {
192         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
193     }
194     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
195     EXPECT_EQ(ret, ERR_DM_FAILED);
196 }
197 
198 /**
199  * @tc.name: PraseNotifyEventJson_007
200  * @tc.desc: return DM_OK
201  * @tc.type: FUNC
202  */
203 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_007, testing::ext::TestSize.Level0)
204 {
205     std::string event = R"({"extra": {"deviceId": "123"}})";
206     nlohmann::json jsonObject;
207     if (deviceManagerServiceImpl_ == nullptr) {
208         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
209     }
210     int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
211     EXPECT_EQ(ret, DM_OK);
212 }
213 
214 /**
215  * @tc.name: NotifyEvent_001
216  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
217  * @tc.type: FUNC
218  */
219 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
220 {
221     std::string pkgName = "com.ohos.test";
222     int32_t eventId = DM_NOTIFY_EVENT_START;
223     std::string event = R"({"extra": {"deviceId": "123"}})";
224     if (deviceManagerServiceImpl_ == nullptr) {
225         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
226     }
227     int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
228     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
229 }
230 
231 /**
232  * @tc.name: NotifyEvent_002
233  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
234  * @tc.type: FUNC
235  */
236 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
237 {
238     std::string pkgName = "com.ohos.test";
239     int32_t eventId = DM_NOTIFY_EVENT_BUTT;
240     std::string event = R"({"extra": {"deviceId": "123"}})";
241     if (deviceManagerServiceImpl_ == nullptr) {
242         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
243     }
244     int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
245     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
246 }
247 
248 /**
249  * @tc.name: NotifyEvent_003
250  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
251  * @tc.type: FUNC
252  */
253 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
254 {
255     std::string pkgName = "com.ohos.test";
256     int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
257     std::string event = R"({"extra": {"deviceId": "123"})";
258     if (deviceManagerServiceImpl_ == nullptr) {
259         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
260     }
261     int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
262     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
263 }
264 
265 /**
266  * @tc.name: RequestCredential_001
267  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
268  * @tc.type: FUNC
269  */
270 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
271 {
272     const std::string reqJsonStr = "";
273     std::string returnJsonStr = "returntest";
274     if (deviceManagerServiceImpl_ == nullptr) {
275         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
276     }
277     int32_t ret = deviceManagerServiceImpl_->RequestCredential(reqJsonStr, returnJsonStr);
278     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
279 }
280 
281 /**
282  * @tc.name: RequestCredential_002
283  * @tc.desc: return ERR_DM_POINT_NULL
284  * @tc.type: FUNC
285  */
286 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
287 {
288     const std::string reqJsonStr = "test";
289     std::string returnJsonStr = "returntest";
290     if (deviceManagerServiceImpl_ == nullptr) {
291         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
292     }
293     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
294     int32_t ret = deviceManagerServiceImpl_->RequestCredential(reqJsonStr, returnJsonStr);
295     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
296 }
297 
298 /**
299  * @tc.name: ImportCredential_001
300  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
301  * @tc.type: FUNC
302  */
303 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
304 {
305     const std::string pkgName = "";
306     const std::string credentialInfo = "";
307     if (deviceManagerServiceImpl_ == nullptr) {
308         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
309     }
310     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
311     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
312 }
313 
314 /**
315  * @tc.name: ImportCredential_002
316  * @tc.desc: return ERR_DM_POINT_NULL
317  * @tc.type: FUNC
318  */
319 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
320 {
321     const std::string pkgName = "pkgNametest";
322     const std::string credentialInfo = "credentialInfotest";
323     if (deviceManagerServiceImpl_ == nullptr) {
324         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
325     }
326     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
327     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
328     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
329 }
330 
331 /**
332  * @tc.name: ImportCredential_003
333  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
334  * @tc.type: FUNC
335  */
336 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
337 {
338     const std::string pkgName;
339     const std::string credentialInfo = "credentialInfotest";
340     if (deviceManagerServiceImpl_ == nullptr) {
341         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
342     }
343     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
344     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
345 }
346 
347 /**
348  * @tc.name: ImportCredential_004
349  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
350  * @tc.type: FUNC
351  */
352 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
353 {
354     const std::string pkgName = "pkgNametest";
355     const std::string credentialInfo;
356     if (deviceManagerServiceImpl_ == nullptr) {
357         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
358     }
359     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
360     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
361 }
362 
363 /**
364  * @tc.name: ImportCredential_005
365  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
366  * @tc.type: FUNC
367  */
368 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_005, testing::ext::TestSize.Level0)
369 {
370     const std::string pkgName = "pkgNametest";
371     std::string reqJsonStr;
372     std::string returnJsonStr;
373     if (deviceManagerServiceImpl_ == nullptr) {
374         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
375     }
376     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, reqJsonStr, returnJsonStr);
377     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
378 }
379 
380 /**
381  * @tc.name: ImportCredential_006
382  * @tc.desc: return ERR_DM_HICHAIN_CREDENTIAL_IMPORT_FAILED
383  * @tc.type: FUNC
384  */
385 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_006, testing::ext::TestSize.Level0)
386 {
387     const std::string pkgName = "pkgNametest";
388     std::string reqJsonStr = "reqJsonStr";
389     std::string returnJsonStr;
390     if (deviceManagerServiceImpl_ == nullptr) {
391         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
392     }
393     int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, reqJsonStr, returnJsonStr);
394     EXPECT_EQ(ret, ERR_DM_HICHAIN_CREDENTIAL_IMPORT_FAILED);
395 }
396 
397 /**
398  * @tc.name: DeleteCredential_001
399  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
400  * @tc.type: FUNC
401  */
402 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
403 {
404     const std::string pkgName = "";
405     const std::string deleteInfo = "";
406     if (deviceManagerServiceImpl_ == nullptr) {
407         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
408     }
409     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
410     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
411 }
412 
413 /**
414  * @tc.name: DeleteCredential_002
415  * @tc.desc: return ERR_DM_POINT_NULL
416  * @tc.type: FUNC
417  */
418 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
419 {
420     const std::string pkgName = "pkgNametest";
421     const std::string deleteInfo = "deleteInfotest";
422     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
423     if (deviceManagerServiceImpl_ == nullptr) {
424         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
425     }
426     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
427     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
428 }
429 
430 /**
431  * @tc.name: DeleteCredential_003
432  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
433  * @tc.type: FUNC
434  */
435 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
436 {
437     const std::string pkgName;
438     const std::string deleteInfo = "deleteInfotest";
439     if (deviceManagerServiceImpl_ == nullptr) {
440         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
441     }
442     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
443     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
444 }
445 
446 /**
447  * @tc.name: DeleteCredential_004
448  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
449  * @tc.type: FUNC
450  */
451 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
452 {
453     const std::string pkgName = "pkgNametest";
454     const std::string deleteInfo;
455     if (deviceManagerServiceImpl_ == nullptr) {
456         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
457     }
458     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
459     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
460 }
461 
462 /**
463  * @tc.name: DeleteCredential_005
464  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
465  * @tc.type: FUNC
466  */
467 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_005, testing::ext::TestSize.Level0)
468 {
469     const std::string pkgName = "pkgNametest";
470     std::string reqJsonStr;
471     std::string returnJsonStr;
472     if (deviceManagerServiceImpl_ == nullptr) {
473         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
474     }
475     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
476     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
477 }
478 
479 /**
480  * @tc.name: DeleteCredential_006
481  * @tc.desc: return DM_OK
482  * @tc.type: FUNC
483  */
484 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_006, testing::ext::TestSize.Level0)
485 {
486     const std::string pkgName = "pkgNametest";
487     std::string reqJsonStr = "reqJsonStr";
488     std::string returnJsonStr;
489     if (deviceManagerServiceImpl_ == nullptr) {
490         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
491     }
492     int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
493     EXPECT_EQ(ret, DM_OK);
494 }
495 
496 /**
497  * @tc.name: RegisterCredentialCallback_001
498  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
499  * @tc.type: FUNC
500  */
501 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
502 {
503     const std::string pkgName = "";
504     if (deviceManagerServiceImpl_ == nullptr) {
505         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
506     }
507     int32_t ret = deviceManagerServiceImpl_->RegisterCredentialCallback(pkgName);
508     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
509 }
510 
511 /**
512  * @tc.name: RegisterCredentialCallback_002
513  * @tc.desc: return ERR_DM_POINT_NULL
514  * @tc.type: FUNC
515  */
516 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
517 {
518     const std::string pkgName = "pkgNametest";
519     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
520     if (deviceManagerServiceImpl_ == nullptr) {
521         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
522     }
523     int32_t ret = deviceManagerServiceImpl_->RegisterCredentialCallback(pkgName);
524     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
525 }
526 
527 /**
528  * @tc.name: UnRegisterCredentialCallback_001
529  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
530  * @tc.type: FUNC
531  */
532 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
533 {
534     const std::string pkgName = "";
535     int32_t ret = deviceManagerServiceImpl_->UnRegisterCredentialCallback(pkgName);
536     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
537 }
538 
539 /**
540  * @tc.name: UnRegisterCredentialCallback_002
541  * @tc.desc: return ERR_DM_POINT_NULL
542  * @tc.type: FUNC
543  */
544 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
545 {
546     const std::string pkgName = "pkgNametest";
547     if (deviceManagerServiceImpl_ == nullptr) {
548         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
549     }
550     deviceManagerServiceImpl_->credentialMgr_ = nullptr;
551     int32_t ret = deviceManagerServiceImpl_->UnRegisterCredentialCallback(pkgName);
552     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
553 }
554 
555 /**
556  * @tc.name: RegisterUiStateCallback_001
557  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
558  * @tc.type: FUNC
559  */
560 HWTEST_F(DeviceManagerServiceImplTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level0)
561 {
562     const std::string pkgName = "";
563     if (deviceManagerServiceImpl_ == nullptr) {
564         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
565     }
566     int32_t ret = deviceManagerServiceImpl_->RegisterUiStateCallback(pkgName);
567     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
568 }
569 
570 /**
571  * @tc.name: RegisterUiStateCallback_002
572  * @tc.desc: return ERR_DM_POINT_NULL
573  * @tc.type: FUNC
574  */
575 HWTEST_F(DeviceManagerServiceImplTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level0)
576 {
577     const std::string pkgName = "pkgNametest";
578     if (deviceManagerServiceImpl_ == nullptr) {
579         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
580     }
581     deviceManagerServiceImpl_->authMgr_ = nullptr;
582     int32_t ret = deviceManagerServiceImpl_->RegisterUiStateCallback(pkgName);
583     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
584 }
585 
586 /**
587  * @tc.name: UnRegisterUiStateCallback_001
588  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
589  * @tc.type: FUNC
590  */
591 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level0)
592 {
593     const std::string pkgName = "";
594     if (deviceManagerServiceImpl_ == nullptr) {
595         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
596     }
597     int32_t ret = deviceManagerServiceImpl_->UnRegisterUiStateCallback(pkgName);
598     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
599 }
600 
601 /**
602  * @tc.name: UnRegisterUiStateCallback_002
603  * @tc.desc: return ERR_DM_POINT_NULL
604  * @tc.type: FUNC
605  */
606 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level0)
607 {
608     const std::string pkgName = "pkgNametest";
609     if (deviceManagerServiceImpl_ == nullptr) {
610         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
611     }
612     deviceManagerServiceImpl_->authMgr_ = nullptr;
613     int32_t ret = deviceManagerServiceImpl_->UnRegisterUiStateCallback(pkgName);
614     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
615 }
616 
617 /**
618  * @tc.name: SetUserOperation_001
619  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
620  * @tc.type: FUNC
621  */
622 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
623 {
624     std::string pkgName = "";
625     int32_t action = 1;
626     const std::string params = "params";
627     if (deviceManagerServiceImpl_ == nullptr) {
628         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
629     }
630     int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
631     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
632 }
633 
634 /**
635  * @tc.name: SetUserOperation_002
636  * @tc.desc: return DM_OK
637  * @tc.type: FUNC
638  */
639 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
640 {
641     std::string pkgName = "com.ohos.test";
642     int32_t action = 1;
643     const std::string params = "paramsTest";
644     if (deviceManagerServiceImpl_ == nullptr) {
645         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
646     }
647     int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
648     EXPECT_EQ(ret, DM_OK);
649 }
650 
651 /**
652  * @tc.name: SetUserOperation_003
653  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
654  * @tc.type: FUNC
655  */
656 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)
657 {
658     std::string pkgName;
659     int32_t action = 1;
660     const std::string params;
661     if (deviceManagerServiceImpl_ == nullptr) {
662         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
663     }
664     int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
665     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
666 }
667 
668 /**
669  * @tc.name: SetUserOperation_004
670  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
671  * @tc.type: FUNC
672  */
673 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)
674 {
675     std::string pkgName = "com.ohos.test";
676     int32_t action = 1;
677     const std::string params;
678     if (deviceManagerServiceImpl_ == nullptr) {
679         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
680     }
681     int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
682     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
683 }
684 
685 /**
686  * @tc.name: SetUserOperation_005
687  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
688  * @tc.type: FUNC
689  */
690 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)
691 {
692     std::string pkgName = "com.ohos.test";
693     int32_t action = 1;
694     const std::string params;
695     if (deviceManagerServiceImpl_ == nullptr) {
696         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
697     }
698     deviceManagerServiceImpl_->authMgr_ = nullptr;
699     int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
700     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
701 }
702 
703 /**
704  * @tc.name: HandleOffline_001
705  * @tc.type: FUNC
706  */
707 HWTEST_F(DeviceManagerServiceImplTest, HandleOffline_001, testing::ext::TestSize.Level0)
708 {
709     DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
710     DmDeviceInfo devInfo;
711     if (deviceManagerServiceImpl_ == nullptr) {
712         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
713     }
714     deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
715     EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
716 }
717 
718 /**
719  * @tc.name: HandleOnline_001
720  * @tc.type: FUNC
721  */
722 HWTEST_F(DeviceManagerServiceImplTest, HandleOnline_001, testing::ext::TestSize.Level0)
723 {
724     DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
725     DmDeviceInfo devInfo;
726     if (deviceManagerServiceImpl_ == nullptr) {
727         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
728     }
729     deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
730     EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
731 }
732 
733 /**
734  * @tc.name: HandleDeviceStatusChange_001
735  * @tc.type: FUNC
736  */
737 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0)
738 {
739     DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
740     DmDeviceInfo devInfo;
741     if (deviceManagerServiceImpl_ == nullptr) {
742         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
743     }
744     deviceManagerServiceImpl_->deviceStateMgr_ = nullptr;
745     deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
746     EXPECT_EQ(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
747 }
748 
749 /**
750  * @tc.name: HandleDeviceStatusChange_002
751  * @tc.type: FUNC
752  */
753 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_002, testing::ext::TestSize.Level0)
754 {
755     DmDeviceState devState = DmDeviceState::DEVICE_STATE_ONLINE;
756     DmDeviceInfo devInfo;
757     if (deviceManagerServiceImpl_ == nullptr) {
758         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
759     }
760     deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
761     EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
762 }
763 
764 /**
765  * @tc.name: HandleDeviceStatusChange_003
766  * @tc.type: FUNC
767  */
768 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_003, testing::ext::TestSize.Level0)
769 {
770     DmDeviceState devState = DmDeviceState::DEVICE_STATE_OFFLINE;
771     DmDeviceInfo devInfo;
772     if (deviceManagerServiceImpl_ == nullptr) {
773         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
774     }
775     deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
776     EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
777 }
778 
779 /**
780  * @tc.name: HandleDeviceStatusChange_004
781  * @tc.type: FUNC
782  */
783 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_004, testing::ext::TestSize.Level0)
784 {
785     DmDeviceState devState = DmDeviceState::DEVICE_INFO_CHANGED;
786     DmDeviceInfo devInfo;
787     if (deviceManagerServiceImpl_ == nullptr) {
788         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
789     }
790     deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
791     EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
792 }
793 
794 /**
795  * @tc.name: StartDeviceDiscovery_001
796  * @tc.desc: return SOFTBUS_IPC_ERR
797  * @tc.type: FUNC
798  */
799 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
800 {
801     const std::string pkgName = "com.ohos.test";
802     uint16_t subscribeId = 0;
803     std::string filterOptions;
804     int32_t ret = deviceManagerServiceImpl_->StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
805     EXPECT_TRUE(CheckSoftbusRes(ret));
806 }
807 
808 /**
809  * @tc.name: StartDeviceDiscovery_002
810  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
811  * @tc.type: FUNC
812  */
813 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
814 {
815     const std::string pkgName;
816     uint16_t subscribeId = 0;
817     std::string filterOptions;
818     if (deviceManagerServiceImpl_ == nullptr) {
819         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
820     }
821     int32_t ret = deviceManagerServiceImpl_->StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
822     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
823 }
824 
825 /**
826  * @tc.name: StartDeviceDiscovery_003
827  * @tc.desc: return SOFTBUS_INVALID_PARAM
828  * @tc.type: FUNC
829  */
830 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
831 {
832     const std::string pkgName = "com.ohos.test";
833     DmSubscribeInfo subscribeInfo;
834     std::string extra;
835     if (deviceManagerServiceImpl_ == nullptr) {
836         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
837     }
838     int32_t ret = deviceManagerServiceImpl_->StartDeviceDiscovery(pkgName, subscribeInfo, extra);
839     EXPECT_TRUE(CheckSoftbusRes(ret));
840 }
841 
842 /**
843  * @tc.name: StartDeviceDiscovery_004
844  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
845  * @tc.type: FUNC
846  */
847 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
848 {
849     const std::string pkgName;
850     DmSubscribeInfo subscribeInfo;
851     std::string extra;
852     if (deviceManagerServiceImpl_ == nullptr) {
853         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
854     }
855     int32_t ret = deviceManagerServiceImpl_->StartDeviceDiscovery(pkgName, subscribeInfo, extra);
856     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
857 }
858 
859 /**
860  * @tc.name: StopDeviceDiscovery_001
861  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
862  * @tc.type: FUNC
863  */
864 HWTEST_F(DeviceManagerServiceImplTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
865 {
866     std::string pkgName;
867     uint16_t subscribeId = 1;
868     if (deviceManagerServiceImpl_ == nullptr) {
869         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
870     }
871     int32_t ret = deviceManagerServiceImpl_->StopDeviceDiscovery(pkgName, subscribeId);
872     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
873 }
874 
875 /**
876  * @tc.name: StopDeviceDiscovery_002
877  * @tc.desc: return SOFTBUS_IPC_ERR
878  * @tc.type: FUNC
879  */
880 HWTEST_F(DeviceManagerServiceImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
881 {
882     std::string pkgName = "com.ohos.test";
883     uint16_t subscribeId = 1;
884     if (deviceManagerServiceImpl_ == nullptr) {
885         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
886     }
887     int32_t ret = deviceManagerServiceImpl_->StopDeviceDiscovery(pkgName, subscribeId);
888     EXPECT_TRUE(CheckSoftbusRes(ret));
889 }
890 
891 /**
892  * @tc.name: PublishDeviceDiscovery_001
893  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
894  * @tc.type: FUNC
895  */
896 HWTEST_F(DeviceManagerServiceImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
897 {
898     std::string pkgName;
899     DmPublishInfo publishInfo;
900     if (deviceManagerServiceImpl_ == nullptr) {
901         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
902     }
903     int32_t ret = deviceManagerServiceImpl_->PublishDeviceDiscovery(pkgName, publishInfo);
904     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
905 }
906 
907 /**
908  * @tc.name: PublishDeviceDiscovery_002
909  * @tc.desc: return SOFTBUS_INVALID_PARAM
910  * @tc.type: FUNC
911  */
912 HWTEST_F(DeviceManagerServiceImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
913 {
914     std::string pkgName = "com.ohos.test";
915     DmPublishInfo publishInfo;
916     if (deviceManagerServiceImpl_ == nullptr) {
917         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
918     }
919     int32_t ret = deviceManagerServiceImpl_->PublishDeviceDiscovery(pkgName, publishInfo);
920     EXPECT_TRUE(CheckSoftbusRes(ret));
921 }
922 
923 /**
924  * @tc.name: UnPublishDeviceDiscovery_001
925  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
926  * @tc.type: FUNC
927  */
928 HWTEST_F(DeviceManagerServiceImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
929 {
930     std::string pkgName;
931     int32_t publishId = 1;
932     if (deviceManagerServiceImpl_ == nullptr) {
933         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
934     }
935     int32_t ret = deviceManagerServiceImpl_->UnPublishDeviceDiscovery(pkgName, publishId);
936     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
937 }
938 
939 /**
940  * @tc.name: UnPublishDeviceDiscovery_002
941  * @tc.desc: return SOFTBUS_IPC_ERR
942  * @tc.type: FUNC
943  */
944 HWTEST_F(DeviceManagerServiceImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
945 {
946     std::string pkgName = "com.ohos.test";
947     int32_t publishId = 1;
948     if (deviceManagerServiceImpl_ == nullptr) {
949         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
950     }
951     int32_t ret = deviceManagerServiceImpl_->UnPublishDeviceDiscovery(pkgName, publishId);
952     EXPECT_TRUE(CheckSoftbusRes(ret));
953 }
954 
955 /**
956  * @tc.name: AuthenticateDevice_001
957  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
958  * @tc.type: FUNC
959  */
960 HWTEST_F(DeviceManagerServiceImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
961 {
962     std::string pkgName;
963     int32_t authType = 1;
964     std::string deviceId = "deviceId";
965     std::string extra;
966     if (deviceManagerServiceImpl_ == nullptr) {
967         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
968     }
969     int32_t ret = deviceManagerServiceImpl_->AuthenticateDevice(pkgName, authType, deviceId, extra);
970     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
971 }
972 
973 /**
974  * @tc.name: AuthenticateDevice_002
975  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
976  * @tc.type: FUNC
977  */
978 HWTEST_F(DeviceManagerServiceImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
979 {
980     std::string pkgName = "com.ohos.test";
981     int32_t authType = 1;
982     std::string deviceId;
983     std::string extra;
984     if (deviceManagerServiceImpl_ == nullptr) {
985         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
986     }
987     int32_t ret = deviceManagerServiceImpl_->AuthenticateDevice(pkgName, authType, deviceId, extra);
988     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
989 }
990 
991 /**
992  * @tc.name: AuthenticateDevice_003
993  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
994  * @tc.type: FUNC
995  */
996 HWTEST_F(DeviceManagerServiceImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
997 {
998     std::string pkgName;
999     int32_t authType = 1;
1000     std::string deviceId;
1001     std::string extra;
1002     if (deviceManagerServiceImpl_ == nullptr) {
1003         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1004     }
1005     int32_t ret = deviceManagerServiceImpl_->AuthenticateDevice(pkgName, authType, deviceId, extra);
1006     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1007 }
1008 
1009 /**
1010  * @tc.name: AuthenticateDevice_004
1011  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1012  * @tc.type: FUNC
1013  */
1014 HWTEST_F(DeviceManagerServiceImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
1015 {
1016     std::string pkgName = "com.ohos.test";
1017     int32_t authType = 1;
1018     std::string deviceId = "deviceId";
1019     std::string extra;
1020     if (deviceManagerServiceImpl_ == nullptr) {
1021         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1022     }
1023     int32_t ret = deviceManagerServiceImpl_->AuthenticateDevice(pkgName, authType, deviceId, extra);
1024     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1025 }
1026 
1027 /**
1028  * @tc.name: UnAuthenticateDevice_001
1029  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1030  * @tc.type: FUNC
1031  */
1032 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
1033 {
1034     std::string pkgName;
1035     std::string networkId = "networkId";
1036     if (deviceManagerServiceImpl_ == nullptr) {
1037         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1038     }
1039     int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, networkId);
1040     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1041 }
1042 
1043 /**
1044  * @tc.name: UnAuthenticateDevice_002
1045  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1046  * @tc.type: FUNC
1047  */
1048 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
1049 {
1050     std::string pkgName = "com.ohos.test";
1051     std::string networkId;
1052     if (deviceManagerServiceImpl_ == nullptr) {
1053         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1054     }
1055     int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, networkId);
1056     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1057 }
1058 
1059 /**
1060  * @tc.name: UnAuthenticateDevice_003
1061  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1062  * @tc.type: FUNC
1063  */
1064 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
1065 {
1066     std::string pkgName;
1067     std::string networkId;
1068     if (deviceManagerServiceImpl_ == nullptr) {
1069         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1070     }
1071     int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, networkId);
1072     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1073 }
1074 
1075 /**
1076  * @tc.name: UnAuthenticateDevice_004
1077  * @tc.desc: return SOFTBUS_IPC_ERR
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
1081 {
1082     std::string pkgName = "com.ohos.test";
1083     std::string networkId = "networkId";
1084     if (deviceManagerServiceImpl_ == nullptr) {
1085         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1086     }
1087     int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, networkId);
1088     EXPECT_TRUE(CheckSoftbusRes(ret));
1089 }
1090 
1091 /**
1092  * @tc.name: BindDevice_001
1093  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1094  * @tc.type: FUNC
1095  */
1096 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_001, testing::ext::TestSize.Level0)
1097 {
1098     std::string pkgName = "com.ohos.test";
1099     int32_t authType = 0;
1100     std::string udidHash;
1101     std::string bindParam;
1102     if (deviceManagerServiceImpl_ == nullptr) {
1103         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1104     }
1105     int32_t ret = deviceManagerServiceImpl_->BindDevice(pkgName, authType, udidHash, bindParam);
1106     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1107 }
1108 
1109 /**
1110  * @tc.name: BindDevice_002
1111  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1112  * @tc.type: FUNC
1113  */
1114 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_002, testing::ext::TestSize.Level0)
1115 {
1116     std::string pkgName;
1117     int32_t authType = 0;
1118     std::string udidHash = "udidHash";
1119     std::string bindParam;
1120     if (deviceManagerServiceImpl_ == nullptr) {
1121         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1122     }
1123     int32_t ret = deviceManagerServiceImpl_->BindDevice(pkgName, authType, udidHash, bindParam);
1124     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1125 }
1126 
1127 /**
1128  * @tc.name: BindDevice_003
1129  * @tc.desc: return DM_OK
1130  * @tc.type: FUNC
1131  */
1132 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_003, testing::ext::TestSize.Level0)
1133 {
1134     std::string pkgName = "com.ohos.test";
1135     int32_t authType = 0;
1136     std::string udidHash = "udidHash";
1137     std::string bindParam;
1138     if (deviceManagerServiceImpl_ == nullptr) {
1139         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1140     }
1141     int32_t ret = deviceManagerServiceImpl_->BindDevice(pkgName, authType, udidHash, bindParam);
1142     EXPECT_NE(ret, DM_OK);
1143 }
1144 
1145 /**
1146  * @tc.name: UnBindDevice_001
1147  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1148  * @tc.type: FUNC
1149  */
1150 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_001, testing::ext::TestSize.Level0)
1151 {
1152     std::string pkgName = "com.ohos.test";
1153     std::string udidHash;
1154     if (deviceManagerServiceImpl_ == nullptr) {
1155         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1156     }
1157     int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udidHash);
1158     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1159 }
1160 
1161 /**
1162  * @tc.name: UnBindDevice_002
1163  * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
1164  * @tc.type: FUNC
1165  */
1166 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_002, testing::ext::TestSize.Level0)
1167 {
1168     std::string pkgName;
1169     std::string udidHash = "udidHash";
1170     if (deviceManagerServiceImpl_ == nullptr) {
1171         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1172     }
1173     int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udidHash);
1174     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1175 }
1176 
1177 /**
1178  * @tc.name: UnBindDevice_003
1179  * @tc.desc: return DM_OK
1180  * @tc.type: FUNC
1181  */
1182 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_003, testing::ext::TestSize.Level0)
1183 {
1184     std::string pkgName = "com.ohos.test";
1185     std::string udidHash = "udidHash";
1186     if (deviceManagerServiceImpl_ == nullptr) {
1187         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1188     }
1189     int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udidHash);
1190     EXPECT_NE(ret, DM_OK);
1191 }
1192 
1193 /**
1194  * @tc.name: GetUdidHashByNetWorkId_001
1195  * @tc.desc: return ERR_DM_POINT_NULL
1196  * @tc.type: FUNC
1197  */
1198 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_001, testing::ext::TestSize.Level0)
1199 {
1200     char *networkId = nullptr;
1201     std::string deviceId;
1202     if (deviceManagerServiceImpl_ == nullptr) {
1203         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1204     }
1205     deviceManagerServiceImpl_->softbusConnector_ = nullptr;
1206     int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
1207     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1208 }
1209 
1210 /**
1211  * @tc.name: GetUdidHashByNetWorkId_002
1212  * @tc.desc: return ERR_DM_POINT_NULL
1213  * @tc.type: FUNC
1214  */
1215 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_002, testing::ext::TestSize.Level0)
1216 {
1217     char *networkId = nullptr;
1218     std::string deviceId;
1219     if (deviceManagerServiceImpl_ == nullptr) {
1220         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1221     }
1222     deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
1223     int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
1224     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1225 }
1226 
1227 /**
1228  * @tc.name: GetUdidHashByNetWorkId_003
1229  * @tc.desc: return SOFTBUS_IPC_ERR
1230  * @tc.type: FUNC
1231  */
1232 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_003, testing::ext::TestSize.Level0)
1233 {
1234     const char *networkId = "networkId";
1235     std::string deviceId;
1236     if (deviceManagerServiceImpl_ == nullptr) {
1237         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1238     }
1239     int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
1240     EXPECT_TRUE(CheckSoftbusRes(ret));
1241 }
1242 
1243 /**
1244  * @tc.name: Release_001
1245  * @tc.type: FUNC
1246  */
1247 HWTEST_F(DeviceManagerServiceImplTest, Release_001, testing::ext::TestSize.Level0)
1248 {
1249     if (deviceManagerServiceImpl_ == nullptr) {
1250         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1251     }
1252     deviceManagerServiceImpl_->Release();
1253     EXPECT_EQ(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1254 }
1255 
1256 /**
1257  * @tc.name: OnSessionOpened_001
1258  * @tc.type: FUNC
1259  */
1260 HWTEST_F(DeviceManagerServiceImplTest, OnSessionOpened_001, testing::ext::TestSize.Level0)
1261 {
1262     int sessionId = 1;
1263     int result = 1;
1264     std::string data = "15631023";
1265     if (deviceManagerServiceImpl_ == nullptr) {
1266         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1267     }
1268     int ret = deviceManagerServiceImpl_->OnSessionOpened(sessionId, result);
1269     deviceManagerServiceImpl_->OnBytesReceived(sessionId, data.c_str(), data.size());
1270     deviceManagerServiceImpl_->OnSessionClosed(sessionId);
1271     EXPECT_EQ(ret, DM_OK);
1272 }
1273 
1274 /**
1275  * @tc.name: MineRequestCredential_001
1276  * @tc.type: FUNC
1277  */
1278 HWTEST_F(DeviceManagerServiceImplTest, MineRequestCredential_001, testing::ext::TestSize.Level0)
1279 {
1280     std::string pkgName = "com.ohos.test";
1281     std::string returnJsonStr;
1282     if (deviceManagerServiceImpl_ == nullptr) {
1283         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1284     }
1285     int32_t ret = deviceManagerServiceImpl_->MineRequestCredential(pkgName, returnJsonStr);
1286     EXPECT_EQ(ret, DM_OK);
1287 }
1288 
1289 /**
1290  * @tc.name: CheckCredential_001
1291  * @tc.type: FUNC
1292  */
1293 HWTEST_F(DeviceManagerServiceImplTest, CheckCredential_001, testing::ext::TestSize.Level0)
1294 {
1295     std::string pkgName = "com.ohos.test";
1296     const std::string reqJsonStr;
1297     std::string returnJsonStr;
1298     if (deviceManagerServiceImpl_ == nullptr) {
1299         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1300     }
1301     int32_t ret = deviceManagerServiceImpl_->CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1302     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1303 }
1304 
1305 /**
1306  * @tc.name: CheckCredential_002
1307  * @tc.type: FUNC
1308  */
1309 HWTEST_F(DeviceManagerServiceImplTest, CheckCredential_002, testing::ext::TestSize.Level0)
1310 {
1311     std::string pkgName = "com.ohos.test";
1312     const std::string reqJsonStr = "reqJsonStr";
1313     std::string returnJsonStr;
1314     if (deviceManagerServiceImpl_ == nullptr) {
1315         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1316     }
1317     int32_t ret = deviceManagerServiceImpl_->CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1318     EXPECT_EQ(ret, DM_OK);
1319 }
1320 
1321 /**
1322  * @tc.name: GetGroupType_001
1323  * @tc.type: FUNC
1324  */
1325 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_001, testing::ext::TestSize.Level0)
1326 {
1327     std::vector<DmDeviceInfo> deviceList;
1328     if (deviceManagerServiceImpl_ == nullptr) {
1329         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1330     }
1331     deviceManagerServiceImpl_->softbusConnector_ = nullptr;
1332     int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1333     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1334 }
1335 
1336 /**
1337  * @tc.name: GetGroupType_002
1338  * @tc.type: FUNC
1339  */
1340 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_002, testing::ext::TestSize.Level0)
1341 {
1342     std::vector<DmDeviceInfo> deviceList;
1343     if (deviceManagerServiceImpl_ == nullptr) {
1344         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1345     }
1346     deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
1347     int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1348     EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1349 }
1350 
1351 /**
1352  * @tc.name: GetGroupType_003
1353  * @tc.type: FUNC
1354  */
1355 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_003, testing::ext::TestSize.Level0)
1356 {
1357     DmDeviceInfo deviceInfo = {
1358         .deviceId = "123456789101112131415",
1359         .deviceName = "deviceName",
1360         .deviceTypeId = 1
1361     };
1362     std::vector<DmDeviceInfo> deviceList;
1363     deviceList.push_back(deviceInfo);
1364     if (deviceManagerServiceImpl_ == nullptr) {
1365         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1366     }
1367     int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1368     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1369 }
1370 
1371 /**
1372  * @tc.name: ImportAuthCode_001
1373  * @tc.type: FUNC
1374  */
1375 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
1376 {
1377     std::string pkgName;
1378     std::string authCode = "authCode";
1379     if (deviceManagerServiceImpl_ == nullptr) {
1380         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1381     }
1382     int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1383     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1384 }
1385 
1386 /**
1387  * @tc.name: ImportAuthCode_002
1388  * @tc.type: FUNC
1389  */
1390 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_002, testing::ext::TestSize.Level0)
1391 {
1392     std::string pkgName = "com.ohos.test";
1393     std::string authCode;
1394     if (deviceManagerServiceImpl_ == nullptr) {
1395         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1396     }
1397     int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1398     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1399 }
1400 
1401 /**
1402  * @tc.name: ImportAuthCode_003
1403  * @tc.type: FUNC
1404  */
1405 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_003, testing::ext::TestSize.Level0)
1406 {
1407     std::string pkgName = "com.ohos.test";
1408     std::string authCode = "authCode";
1409     if (deviceManagerServiceImpl_ == nullptr) {
1410         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1411     }
1412     int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1413     EXPECT_EQ(ret, DM_OK);
1414 }
1415 
1416 /**
1417  * @tc.name: ExportAuthCode_001
1418  * @tc.type: FUNC
1419  */
1420 HWTEST_F(DeviceManagerServiceImplTest, ExportAuthCode_001, testing::ext::TestSize.Level0)
1421 {
1422     std::string authCode = "authCode";
1423     if (deviceManagerServiceImpl_ == nullptr) {
1424         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1425     }
1426     int32_t ret = deviceManagerServiceImpl_->ExportAuthCode(authCode);
1427     EXPECT_EQ(ret, DM_OK);
1428 }
1429 
1430 /**
1431  * @tc.name: BindTarget_001
1432  * @tc.type: FUNC
1433  */
1434 HWTEST_F(DeviceManagerServiceImplTest, BindTarget_001, testing::ext::TestSize.Level0)
1435 {
1436     std::string pkgName;
1437     PeerTargetId targetId;
1438     std::map<std::string, std::string> bindParam;
1439     if (deviceManagerServiceImpl_ == nullptr) {
1440         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1441     }
1442     int32_t ret = deviceManagerServiceImpl_->BindTarget(pkgName, targetId, bindParam);
1443     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1444 }
1445 
1446 /**
1447  * @tc.name: PutIdenticalAccountToAcl_001
1448  * @tc.type: FUNC
1449  */
1450 HWTEST_F(DeviceManagerServiceImplTest, PutIdenticalAccountToAcl_001, testing::ext::TestSize.Level0)
1451 {
1452     std::string requestDeviceId;
1453     std::string trustDeviceId;
1454     if (deviceManagerServiceImpl_ == nullptr) {
1455         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1456     }
1457     deviceManagerServiceImpl_->PutIdenticalAccountToAcl(requestDeviceId, trustDeviceId);
1458     EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1459 }
1460 
1461 /**
1462  * @tc.name: DpAclAdd_001
1463  * @tc.type: FUNC
1464  */
1465 HWTEST_F(DeviceManagerServiceImplTest, DpAclAdd_001, testing::ext::TestSize.Level0)
1466 {
1467     std::string udid = "2342154";
1468     if (deviceManagerServiceImpl_ == nullptr) {
1469         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1470     }
1471     int32_t ret = deviceManagerServiceImpl_->DpAclAdd(udid);
1472     EXPECT_EQ(ret, DM_OK);
1473 }
1474 
1475 /**
1476  * @tc.name: IsSameAccount_001
1477  * @tc.type: FUNC
1478  */
1479 HWTEST_F(DeviceManagerServiceImplTest, IsSameAccount_001, testing::ext::TestSize.Level0)
1480 {
1481     std::string udid;
1482     if (deviceManagerServiceImpl_ == nullptr) {
1483         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1484     }
1485     int32_t ret = deviceManagerServiceImpl_->IsSameAccount(udid);
1486     EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1487 }
1488 
1489 /**
1490  * @tc.name: IsSameAccount_002
1491  * @tc.type: FUNC
1492  */
1493 HWTEST_F(DeviceManagerServiceImplTest, IsSameAccount_002, testing::ext::TestSize.Level0)
1494 {
1495     std::string udid = "2342154";
1496     if (deviceManagerServiceImpl_ == nullptr) {
1497         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1498     }
1499     int32_t ret = deviceManagerServiceImpl_->IsSameAccount(udid);
1500     EXPECT_EQ(ret, ERR_DM_FAILED);
1501 }
1502 
1503 /**
1504  * @tc.name: GetAppTrustDeviceIdList_003
1505  * @tc.type: FUNC
1506  */
1507 HWTEST_F(DeviceManagerServiceImplTest, GetAppTrustDeviceIdList_003, testing::ext::TestSize.Level0)
1508 {
1509     std::string pkgname = "pkgname";
1510     if (deviceManagerServiceImpl_ == nullptr) {
1511         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1512     }
1513     auto ret = deviceManagerServiceImpl_->GetAppTrustDeviceIdList(pkgname);
1514     EXPECT_EQ(ret.empty(), true);
1515 }
1516 
1517 /**
1518  * @tc.name: OnUnbindSessionCloseed_001
1519  * @tc.type: FUNC
1520  */
1521 HWTEST_F(DeviceManagerServiceImplTest, OnUnbindSessionCloseed_001, testing::ext::TestSize.Level0)
1522 {
1523     int32_t socket = 1;
1524     if (deviceManagerServiceImpl_ == nullptr) {
1525         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1526     }
1527     deviceManagerServiceImpl_->OnUnbindSessionCloseed(socket);
1528     EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1529 }
1530 
1531 /**
1532  * @tc.name: OnUnbindBytesReceived_001
1533  * @tc.type: FUNC
1534  */
1535 HWTEST_F(DeviceManagerServiceImplTest, OnUnbindBytesReceived_001, testing::ext::TestSize.Level0)
1536 {
1537     int32_t socket = 1;
1538     std::string data = "15135135";
1539     if (deviceManagerServiceImpl_ == nullptr) {
1540         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1541     }
1542     deviceManagerServiceImpl_->OnUnbindBytesReceived(socket, data.c_str(), data.size());
1543     EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1544 }
1545 
1546 /**
1547  * @tc.name: LoadHardwareFwkService_001
1548  * @tc.type: FUNC
1549  */
1550 HWTEST_F(DeviceManagerServiceImplTest, LoadHardwareFwkService_001, testing::ext::TestSize.Level0)
1551 {
1552     if (deviceManagerServiceImpl_ == nullptr) {
1553         deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1554     }
1555     deviceManagerServiceImpl_->LoadHardwareFwkService();
1556     EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1557 }
1558 
1559 HWTEST_F(DeviceManagerServiceImplTest, CredentialAuthStatus_101, testing::ext::TestSize.Level0)
1560 {
1561     std::string proofInfo;
1562     uint16_t deviceTypeId = 0x00;
1563     int32_t errcode = -1;
1564     deviceManagerServiceImpl_->HandleCredentialAuthStatus(proofInfo, deviceTypeId, errcode);
1565     EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
1566 }
1567 } // namespace
1568 } // namespace DistributedHardware
1569 } // namespace OHOS
1570