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_service_impl.h"
17
18 namespace OHOS {
19 namespace DistributedHardware {
SetUp()20 void DeviceManagerServiceImplTest::SetUp()
21 {
22 }
23
TearDown()24 void DeviceManagerServiceImplTest::TearDown()
25 {
26 }
27
SetUpTestCase()28 void DeviceManagerServiceImplTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void DeviceManagerServiceImplTest::TearDownTestCase()
33 {
34 }
35
36 namespace {
37 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
38 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
39 std::shared_ptr<HiChainConnector> hiChainConnector_ = std::make_shared<HiChainConnector>();
40 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
41
42 /**
43 * @tc.name: Initialize_001
44 * @tc.desc: return DM_OK
45 * @tc.type: FUNC
46 */
47 HWTEST_F(DeviceManagerServiceImplTest, Initialize_001, testing::ext::TestSize.Level0)
48 {
49 auto ideviceManagerServiceListener = std::shared_ptr<IDeviceManagerServiceListener>();
50 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>
51 ();
52 deviceManagerServiceImpl->commonEventManager_ = std::make_shared<DmCommonEventManager>();
53 int ret = deviceManagerServiceImpl->Initialize(ideviceManagerServiceListener);
54 EXPECT_EQ(ret, DM_OK);
55 }
56
57 /**
58 * @tc.name: Initialize_001
59 * @tc.desc: return DM_OK
60 * @tc.type: FUNC
61 */
62 HWTEST_F(DeviceManagerServiceImplTest, Initialize_002, testing::ext::TestSize.Level0)
63 {
64 auto ideviceManagerServiceListener = std::shared_ptr<IDeviceManagerServiceListener>();
65 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>
66 ();
67 deviceManagerServiceImpl->commonEventManager_ = nullptr;
68 int ret = deviceManagerServiceImpl->Initialize(ideviceManagerServiceListener);
69 EXPECT_EQ(ret, DM_OK);
70 }
71
72 /**
73 * @tc.name: PraseNotifyEventJson_001
74 * @tc.desc: return ERR_DM_FAILED
75 * @tc.type: FUNC
76 */
77 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_001, testing::ext::TestSize.Level0)
78 {
79 std::string event = R"({"extra": {"deviceId": "123"})";
80 nlohmann::json jsonObject;
81 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
82 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
83 EXPECT_EQ(ret, ERR_DM_FAILED);
84 }
85
86 /**
87 * @tc.name: PraseNotifyEventJson_002
88 * @tc.desc: return ERR_DM_FAILED
89 * @tc.type: FUNC
90 */
91 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_002, testing::ext::TestSize.Level0)
92 {
93 std::string event = R"({"content": {"deviceid": "123"}})";
94 nlohmann::json jsonObject;
95 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
96 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
97 EXPECT_EQ(ret, ERR_DM_FAILED);
98 }
99
100 /**
101 * @tc.name: PraseNotifyEventJson_003
102 * @tc.desc: return ERR_DM_FAILED
103 * @tc.type: FUNC
104 */
105 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_003, testing::ext::TestSize.Level0)
106 {
107 std::string event = R"({"extra": {"deviceaId": "123"}})";
108 nlohmann::json jsonObject;
109 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
110 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
111 EXPECT_EQ(ret, ERR_DM_FAILED);
112 }
113
114 /**
115 * @tc.name: PraseNotifyEventJson_004
116 * @tc.desc: return ERR_DM_FAILED
117 * @tc.type: FUNC
118 */
119 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_004, testing::ext::TestSize.Level0)
120 {
121 std::string event = R"({"extra": {"deviceId": 123}})";
122 nlohmann::json jsonObject;
123 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
124 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
125 EXPECT_EQ(ret, ERR_DM_FAILED);
126 }
127
128 /**
129 * @tc.name: PraseNotifyEventJson_005
130 * @tc.desc: return ERR_DM_FAILED
131 * @tc.type: FUNC
132 */
133 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_005, testing::ext::TestSize.Level0)
134 {
135 std::string event = R"({"Extra": {"deviceId": "123"}})";
136 nlohmann::json jsonObject;
137 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
138 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
139 EXPECT_EQ(ret, ERR_DM_FAILED);
140 }
141
142 /**
143 * @tc.name: PraseNotifyEventJson_006
144 * @tc.desc: return ERR_DM_FAILED
145 * @tc.type: FUNC
146 */
147 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_006, testing::ext::TestSize.Level0)
148 {
149 std::string event = R"({"extra":"123"}})";
150 nlohmann::json jsonObject;
151 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
152 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
153 EXPECT_EQ(ret, ERR_DM_FAILED);
154 }
155
156 /**
157 * @tc.name: PraseNotifyEventJson_007
158 * @tc.desc: return DM_OK
159 * @tc.type: FUNC
160 */
161 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_007, testing::ext::TestSize.Level0)
162 {
163 std::string event = R"({"extra": {"deviceId": "123"}})";
164 nlohmann::json jsonObject;
165 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
166 int ret = deviceManagerServiceImpl->PraseNotifyEventJson(event, jsonObject);
167 EXPECT_EQ(ret, DM_OK);
168 }
169
170 /**
171 * @tc.name: NotifyEvent_001
172 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
173 * @tc.type: FUNC
174 */
175 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
176 {
177 std::string pkgName = "com.ohos.test";
178 int32_t eventId = DM_NOTIFY_EVENT_START;
179 std::string event = R"({"extra": {"deviceId": "123"}})";
180 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
181 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
182 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
183 }
184
185 /**
186 * @tc.name: NotifyEvent_002
187 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
188 * @tc.type: FUNC
189 */
190 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
191 {
192 std::string pkgName = "com.ohos.test";
193 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
194 std::string event = R"({"extra": {"deviceId": "123"}})";
195 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
196 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
197 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
198 }
199
200 /**
201 * @tc.name: NotifyEvent_003
202 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
203 * @tc.type: FUNC
204 */
205 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
206 {
207 std::string pkgName = "com.ohos.test";
208 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
209 std::string event = R"({"extra": {"deviceId": "123"})";
210 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
211 int ret = deviceManagerServiceImpl->NotifyEvent(pkgName, eventId, event);
212 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
213 }
214
215 /**
216 * @tc.name: RequestCredential_001
217 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
218 * @tc.type: FUNC
219 */
220 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
221 {
222 const std::string reqJsonStr = "";
223 std::string returnJsonStr = "returntest";
224 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
225 int32_t ret = deviceManagerServiceImpl->RequestCredential(reqJsonStr, returnJsonStr);
226 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
227 }
228
229 /**
230 * @tc.name: RequestCredential_002
231 * @tc.desc: return ERR_DM_POINT_NULL
232 * @tc.type: FUNC
233 */
234 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
235 {
236 const std::string reqJsonStr = "test";
237 std::string returnJsonStr = "returntest";
238 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
239 deviceManagerServiceImpl->credentialMgr_ = nullptr;
240 int32_t ret = deviceManagerServiceImpl->RequestCredential(reqJsonStr, returnJsonStr);
241 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
242 }
243
244 /**
245 * @tc.name: ImportCredential_001
246 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
247 * @tc.type: FUNC
248 */
249 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
250 {
251 const std::string pkgName = "";
252 const std::string credentialInfo = "";
253 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
254 int32_t ret = deviceManagerServiceImpl->ImportCredential(pkgName, credentialInfo);
255 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
256 }
257
258 /**
259 * @tc.name: ImportCredential_002
260 * @tc.desc: return ERR_DM_POINT_NULL
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
264 {
265 const std::string pkgName = "pkgNametest";
266 const std::string credentialInfo = "credentialInfotest";
267 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
268 deviceManagerServiceImpl->credentialMgr_ = nullptr;
269 int32_t ret = deviceManagerServiceImpl->ImportCredential(pkgName, credentialInfo);
270 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
271 }
272
273 /**
274 * @tc.name: DeleteCredential_001
275 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
276 * @tc.type: FUNC
277 */
278 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
279 {
280 const std::string pkgName = "";
281 const std::string deleteInfo = "";
282 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
283 int32_t ret = deviceManagerServiceImpl->DeleteCredential(pkgName, deleteInfo);
284 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
285 }
286
287 /**
288 * @tc.name: DeleteCredential_002
289 * @tc.desc: return ERR_DM_POINT_NULL
290 * @tc.type: FUNC
291 */
292 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
293 {
294 const std::string pkgName = "pkgNametest";
295 const std::string deleteInfo = "deleteInfotest";
296 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
297 deviceManagerServiceImpl->credentialMgr_ = nullptr;
298 int32_t ret = deviceManagerServiceImpl->DeleteCredential(pkgName, deleteInfo);
299 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
300 }
301
302 /**
303 * @tc.name: RegisterCredentialCallback_001
304 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
305 * @tc.type: FUNC
306 */
307 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
308 {
309 const std::string pkgName = "";
310 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
311 int32_t ret = deviceManagerServiceImpl->RegisterCredentialCallback(pkgName);
312 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
313 }
314
315 /**
316 * @tc.name: RegisterCredentialCallback_002
317 * @tc.desc: return ERR_DM_POINT_NULL
318 * @tc.type: FUNC
319 */
320 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
321 {
322 const std::string pkgName = "pkgNametest";
323 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
324 deviceManagerServiceImpl->credentialMgr_ = nullptr;
325 int32_t ret = deviceManagerServiceImpl->RegisterCredentialCallback(pkgName);
326 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
327 }
328
329 /**
330 * @tc.name: UnRegisterCredentialCallback_001
331 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
332 * @tc.type: FUNC
333 */
334 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
335 {
336 const std::string pkgName = "";
337 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
338 int32_t ret = deviceManagerServiceImpl->UnRegisterCredentialCallback(pkgName);
339 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
340 }
341
342 /**
343 * @tc.name: UnRegisterCredentialCallback_002
344 * @tc.desc: return ERR_DM_POINT_NULL
345 * @tc.type: FUNC
346 */
347 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
348 {
349 const std::string pkgName = "pkgNametest";
350 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
351 deviceManagerServiceImpl->credentialMgr_ = nullptr;
352 int32_t ret = deviceManagerServiceImpl->UnRegisterCredentialCallback(pkgName);
353 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
354 }
355
356 /**
357 * @tc.name: SetUserOperation_001
358 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
359 * @tc.type: FUNC
360 */
361 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
362 {
363 std::string pkgName = "";
364 int32_t action = 1;
365 const std::string params = "";
366 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
367 int32_t ret = deviceManagerServiceImpl->SetUserOperation(pkgName, action, params);
368 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
369 }
370
371 /**
372 * @tc.name: SetUserOperation_002
373 * @tc.desc: return DM_OK
374 * @tc.type: FUNC
375 */
376 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
377 {
378 std::string pkgName = "com.ohos.test";
379 int32_t action = 1;
380 const std::string params = "paramsTest";
381 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
382 deviceManagerServiceImpl->authMgr_ =
383 std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector_, listener, hiChainAuthConnector);
384 int32_t ret = deviceManagerServiceImpl->SetUserOperation(pkgName, action, params);
385 EXPECT_EQ(ret, DM_OK);
386 }
387
388 /**
389 * @tc.name: StartDeviceDiscovery_001
390 * @tc.desc: return ERR_DM_DISCOVERY_FAILED
391 * @tc.type: FUNC
392 */
393 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
394 {
395 const std::string pkgName = "com.ohos.test";
396 uint16_t subscribeId = 0;
397 std::string filterOptions;
398 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
399 deviceManagerServiceImpl->discoveryMgr_ =
400 std::make_shared<DmDiscoveryManager>(softbusConnector, listener, hiChainConnector_);
401 int32_t ret = deviceManagerServiceImpl->StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
402 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
403 }
404
405 /**
406 * @tc.name: StartDeviceDiscovery_002
407 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
408 * @tc.type: FUNC
409 */
410 HWTEST_F(DeviceManagerServiceImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
411 {
412 const std::string pkgName;
413 uint16_t subscribeId = 0;
414 std::string filterOptions;
415 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
416 int32_t ret = deviceManagerServiceImpl->StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
417 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
418 }
419
420 /**
421 * @tc.name: BindDevice_001
422 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
423 * @tc.type: FUNC
424 */
425 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_001, testing::ext::TestSize.Level0)
426 {
427 std::string pkgName = "com.ohos.test";
428 int32_t authType = 0;
429 std::string udidHash;
430 std::string bindParam;
431 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
432 int32_t ret = deviceManagerServiceImpl->BindDevice(pkgName, authType, udidHash, bindParam);
433 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
434 }
435
436 /**
437 * @tc.name: BindDevice_002
438 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
439 * @tc.type: FUNC
440 */
441 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_002, testing::ext::TestSize.Level0)
442 {
443 std::string pkgName;
444 int32_t authType = 0;
445 std::string udidHash = "udidHash";
446 std::string bindParam;
447 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
448 int32_t ret = deviceManagerServiceImpl->BindDevice(pkgName, authType, udidHash, bindParam);
449 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
450 }
451
452 /**
453 * @tc.name: BindDevice_003
454 * @tc.desc: return DM_OK
455 * @tc.type: FUNC
456 */
457 HWTEST_F(DeviceManagerServiceImplTest, BindDevice_003, testing::ext::TestSize.Level0)
458 {
459 std::string pkgName = "com.ohos.test";
460 int32_t authType = 0;
461 std::string udidHash = "udidHash";
462 std::string bindParam;
463 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
464 deviceManagerServiceImpl->authMgr_ =
465 std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector_, listener, hiChainAuthConnector);
466 int32_t ret = deviceManagerServiceImpl->BindDevice(pkgName, authType, udidHash, bindParam);
467 EXPECT_NE(ret, DM_OK);
468 }
469
470 /**
471 * @tc.name: UnBindDevice_001
472 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
473 * @tc.type: FUNC
474 */
475 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_001, testing::ext::TestSize.Level0)
476 {
477 std::string pkgName = "com.ohos.test";
478 std::string udidHash;
479 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
480 int32_t ret = deviceManagerServiceImpl->UnBindDevice(pkgName, udidHash);
481 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
482 }
483
484 /**
485 * @tc.name: UnBindDevice_002
486 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
487 * @tc.type: FUNC
488 */
489 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_002, testing::ext::TestSize.Level0)
490 {
491 std::string pkgName;
492 std::string udidHash = "udidHash";
493 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
494 int32_t ret = deviceManagerServiceImpl->UnBindDevice(pkgName, udidHash);
495 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
496 }
497
498 /**
499 * @tc.name: UnBindDevice_003
500 * @tc.desc: return DM_OK
501 * @tc.type: FUNC
502 */
503 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_003, testing::ext::TestSize.Level0)
504 {
505 std::string pkgName = "com.ohos.test";
506 std::string udidHash = "udidHash";
507 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
508 deviceManagerServiceImpl->authMgr_ =
509 std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector_, listener, hiChainAuthConnector);
510 int32_t ret = deviceManagerServiceImpl->UnBindDevice(pkgName, udidHash);
511 EXPECT_NE(ret, DM_OK);
512 }
513
514 /**
515 * @tc.name: GetUdidHashByNetWorkId_001
516 * @tc.desc: return ERR_DM_POINT_NULL
517 * @tc.type: FUNC
518 */
519 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_001, testing::ext::TestSize.Level0)
520 {
521 char *networkId = nullptr;
522 std::string deviceId;
523 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
524 deviceManagerServiceImpl->softbusConnector_ = nullptr;
525 int32_t ret = deviceManagerServiceImpl->GetUdidHashByNetWorkId(networkId, deviceId);
526 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
527 }
528
529 /**
530 * @tc.name: GetUdidHashByNetWorkId_002
531 * @tc.desc: return ERR_DM_POINT_NULL
532 * @tc.type: FUNC
533 */
534 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_002, testing::ext::TestSize.Level0)
535 {
536 char *networkId = nullptr;
537 std::string deviceId;
538 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
539 deviceManagerServiceImpl->softbusConnector_ = softbusConnector;
540 deviceManagerServiceImpl->hiChainConnector_ = nullptr;
541 int32_t ret = deviceManagerServiceImpl->GetUdidHashByNetWorkId(networkId, deviceId);
542 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
543 }
544
545 /**
546 * @tc.name: GetUdidHashByNetWorkId_003
547 * @tc.desc: return ERR_DM_FAILED
548 * @tc.type: FUNC
549 */
550 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_003, testing::ext::TestSize.Level0)
551 {
552 const char *networkId = "networkId";
553 std::string deviceId;
554 auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
555 deviceManagerServiceImpl->softbusConnector_ = softbusConnector;
556 deviceManagerServiceImpl->hiChainConnector_ = hiChainConnector_;
557 int32_t ret = deviceManagerServiceImpl->GetUdidHashByNetWorkId(networkId, deviceId);
558 EXPECT_EQ(ret, ERR_DM_FAILED);
559 }
560 } // namespace
561 } // namespace DistributedHardware
562 } // namespace OHOS
563