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