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.h"
17
18 #include "accesstoken_kit.h"
19 #include "dm_constants.h"
20 #include "dm_device_info.h"
21 #include "dm_log.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "softbus_common.h"
25
26 using namespace OHOS::Security::AccessToken;
27 namespace OHOS {
28 namespace DistributedHardware {
29 IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService);
30
SetUp()31 void DeviceManagerServiceTest::SetUp()
32 {
33 const int32_t PERMS_NUM = 3;
34 const int32_t PERMS_INDEX_TWO = 2;
35 uint64_t tokenId;
36 const char *perms[PERMS_NUM];
37 perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
38 perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
39 perms[PERMS_INDEX_TWO] = "ohos.permission.ACCESS_SERVICE_DM";
40 NativeTokenInfoParams infoInstance = {
41 .dcapsNum = 0,
42 .permsNum = PERMS_NUM,
43 .aclsNum = 0,
44 .dcaps = NULL,
45 .perms = perms,
46 .acls = NULL,
47 .processName = "dsoftbus_service",
48 .aplStr = "system_core",
49 };
50 tokenId = GetAccessTokenId(&infoInstance);
51 SetSelfTokenID(tokenId);
52 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
53 }
54
TearDown()55 void DeviceManagerServiceTest::TearDown()
56 {
57 }
58
SetUpTestCase()59 void DeviceManagerServiceTest::SetUpTestCase()
60 {
61 }
62
TearDownTestCase()63 void DeviceManagerServiceTest::TearDownTestCase()
64 {
65 }
66
67 namespace {
68 /**
69 * @tc.name: Init_001
70 * @tc.desc: Init device manager service and return DM_OK
71 * @tc.type: FUNC
72 * @tc.require: AR000GHSJK
73 */
74 HWTEST_F(DeviceManagerServiceTest, Init_001, testing::ext::TestSize.Level0)
75 {
76 int ret = DeviceManagerService::GetInstance().Init();
77 EXPECT_EQ(ret, DM_OK);
78 }
79
80 /**
81 * @tc.name: StartDeviceDiscovery_001
82 * @tc.desc: Start device discovery and return ERR_DM_NOT_INIT
83 * @tc.type: FUNC
84 * @tc.require: AR000GHSJK
85 */
86 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
87 {
88 std::string pkgName = "com.ohos.test";
89 DmSubscribeInfo subscribeInfo;
90 std::string extra;
91 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
92 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
93 }
94
95 /**
96 * @tc.name: StartDeviceDiscovery_002
97 * @tc.desc: Empty pkgName of StartDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
98 * @tc.type: FUNC
99 * @tc.require: AR000GHSJK
100 */
101 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
102 {
103 std::string pkgName;
104 DmSubscribeInfo subscribeInfo;
105 std::string extra = "test";
106 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
107 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
108 }
109
110 /**
111 * @tc.name: StartDeviceDiscovery_003
112 * @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return
113 * ERR_DM_DISCOVERY_REPEATED
114 * @tc.type: FUNC
115 * @tc.require: AR000GHSJK
116 */
117 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
118 {
119 std::string pkgName = "com.ohos.test";
120 DmSubscribeInfo subscribeInfo;
121 std::string extra;
122 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
123 pkgName = "1com.ohos.test1";
124 ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
125 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
126 }
127
128 /**
129 * @tc.name: StopDeviceDiscovery_001
130 * @tc.desc: Stop device discovery and return ERR_DM_NOT_INIT
131 * @tc.type: FUNC
132 * @tc.require: AR000GHSJK
133 */
134 HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
135 {
136 std::string pkgName = "com.ohos.test";
137 uint16_t subscribeId = 1;
138 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
139 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
140 }
141
142 /**
143 * @tc.name:StopDeviceDiscovery_002
144 * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID
145 * @tc.type: FUNC
146 * @tc.require: AR000GHSJK
147 */
148 HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
149 {
150 std::string pkgName;
151 uint16_t subscribeId = 1;
152 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
153 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
154 }
155
156 /**
157 * @tc.name: PublishDeviceDiscovery_001
158 * @tc.desc: Publish device discovery and return ERR_DM_NOT_INIT
159 * @tc.type: FUNC
160 * @tc.require: I5N1K3
161 */
162 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
163 {
164 std::string pkgName = "com.ohos.test12";
165 DmPublishInfo publishInfo;
166 publishInfo.publishId = 1;
167 publishInfo.mode = DM_DISCOVER_MODE_ACTIVE;
168 publishInfo.freq = DM_HIGH;
169 publishInfo.ranging = 1;
170 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
171 EXPECT_EQ(ret, DM_OK);
172 DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishInfo.publishId);
173 }
174
175 /**
176 * @tc.name: PublishDeviceDiscovery_002
177 * @tc.desc: Empty pkgName of PublishDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
178 * @tc.type: FUNC
179 * @tc.require: I5N1K3
180 */
181 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
182 {
183 std::string pkgName;
184 DmPublishInfo publishInfo;
185 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
186 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
187 }
188
189 /**
190 * @tc.name: PublishDeviceDiscovery_003
191 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return
192 * ERR_DM_DISCOVERY_REPEATED
193 * @tc.type: FUNC
194 * @tc.require: I5N1K3
195 */
196 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
197 {
198 std::string pkgName = "com.ohos.test";
199 DmPublishInfo publishInfo;
200 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
201 pkgName = "1com.ohos.test1";
202 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
203 EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
204 }
205
206 /**
207 * @tc.name: UnPublishDeviceDiscovery_001
208 * @tc.desc: UnPublish device discovery and return ERR_DM_NOT_INIT
209 * @tc.type: FUNC
210 * @tc.require: I5N1K3
211 */
212 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
213 {
214 std::string pkgName = "com.ohos.test";
215 int32_t publishId = 1;
216 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
217 EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
218 }
219
220 /**
221 * @tc.name: UnPublishDeviceDiscovery_002
222 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID
223 * @tc.type: FUNC
224 * @tc.require: I5N1K3
225 */
226 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
227 {
228 std::string pkgName;
229 int32_t publishId = 1;
230 DeviceManagerService::GetInstance().Init();
231 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
232 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
233 }
234
235 /**
236 * @tc.name: GetTrustedDeviceList_001
237 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true and pkgName = null; Return ERR_DM_INPUT_PARA_INVALID
238 * @tc.type: FUNC
239 * @tc.require: AR000GHSJK
240 */
241 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
242 {
243 std::string pkgName;
244 std::string extra = "jdddd";
245 std::vector<DmDeviceInfo> deviceList;
246 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
247 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
248 }
249
250 /**
251 * @tc.name: ShiftLNNGear_001
252 * @tc.desc:Set the pkgName to null, callerId not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID
253 * @tc.type: FUNC
254 * @tc.require: AR000GHSJK
255 */
256 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_001, testing::ext::TestSize.Level0)
257 {
258 std::string pkgName;
259 std::string callerId = "com.ohos.test";
260 bool isRefresh = true;
261 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh);
262 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
263 }
264
265 /**
266 * @tc.name: ShiftLNNGear_002
267 * @tc.desc:Set the callerId to null, pkgNamenot not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID
268 * @tc.type: FUNC
269 * @tc.require: AR000GHSJK
270 */
271 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_002, testing::ext::TestSize.Level0)
272 {
273 std::string pkgName = "com.ohos.test";
274 std::string callerId;
275 bool isRefresh = true;
276 std::vector<DmDeviceInfo> deviceList;
277 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh);
278 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
279 }
280
281
282 /**
283 * @tc.name: ShiftLNNGear_003
284 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return DM_OK
285 * @tc.type: FUNC
286 * @tc.require: AR000GHSJK
287 */
288 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_003, testing::ext::TestSize.Level0)
289 {
290 std::string pkgName = "com.ohos.test";
291 std::string callerId = "com.ohos.test";
292 bool isRefresh = true;
293 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh);
294 EXPECT_EQ(ret, DM_OK);
295 }
296
297 /**
298 * @tc.name: ShiftLNNGear_004
299 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to false; Return DM_OK
300 * @tc.type: FUNC
301 * @tc.require: AR000GHSJK
302 */
303 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_004, testing::ext::TestSize.Level0)
304 {
305 std::string pkgName = "com.ohos.test";
306 std::string callerId = "com.ohos.test";
307 bool isRefresh = false;
308 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh);
309 EXPECT_EQ(ret, DM_OK);
310 }
311
312 /**
313 * @tc.name: AuthenticateDevice_001
314 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_INPUT_PARA_INVALID
315 * @tc.type: FUNC
316 * @tc.require: AR000GHSJK
317 */
318 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
319 {
320 std::string pkgName = "com.ohos.test";
321 std::string extra = "jdddd";
322 int32_t authType = 1;
323 std::string deviceId = "2345";
324 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
325 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
326 }
327
328 /**
329 * @tc.name: AuthenticateDevice_002
330 * @tc.desc: Set intFlag for GAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
331 * @tc.type: FUNC
332 * @tc.require: AR000GHSJK
333 */
334 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
335 {
336 std::string pkgName;
337 std::string extra = "jdddd";
338 int32_t authType = 0;
339 std::string deviceId = " 2345";
340 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
341 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
342 }
343
344 /**
345 * @tc.name: AuthenticateDevice_003
346 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_INPUT_PARA_INVALID
347 * @tc.type: FUNC
348 * @tc.require: AR000GHSJK
349 */
350 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
351 {
352 std::string pkgName = "com.ohos.test";
353 std::string extra = "jdddd";
354 int32_t authType = 0;
355 std::string deviceId;
356 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
357 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
358 }
359
360 /**
361 * @tc.name: UnAuthenticateDevice_001
362 * @tc.desc: 将UnAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";Return ERR_DM_FAILED
363 * @tc.type: FUNC
364 * @tc.require: AR000GHSJK
365 */
366 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
367 {
368 std::string pkgName = "com.ohos.test";
369 std::string deviceId = "12345";
370 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
371 EXPECT_EQ(ret, ERR_DM_FAILED);
372 }
373
374 /**
375 * @tc.name: UnAuthenticateDevice_002
376 * @tc.desc: Set intFlag for UnAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
377 * @tc.type: FUNC
378 * @tc.require: AR000GHSJK
379 */
380 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
381 {
382 std::string pkgName;
383 std::string deviceId = "12345";
384 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
385 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
386 }
387
388 /**
389 * @tc.name: UnAuthenticateDevice_003
390 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
391 * value is ERR_DM_INPUT_PARA_INVALID
392 * @tc.type: FUNC
393 * @tc.require: AR000GHSJK
394 */
395 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
396 {
397 std::string pkgName = "com.ohos.test";
398 std::string deviceId;
399 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
400 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
401 }
402
403 /**
404 * @tc.name: VerifyAuthentication_001
405 * @tc.desc: Set intFlag for VerifyAuthentication to false and set authParam = "jdjjjj"，The return value is
406 * ERR_DM_AUTH_NOT_START
407 * @tc.type: FUNC
408 * @tc.require: AR000GHSJK
409 */
410 HWTEST_F(DeviceManagerServiceTest, VerifyAuthentication_001, testing::ext::TestSize.Level0)
411 {
412 std::string authParam = "jdjjjj";
413 int ret = DeviceManagerService::GetInstance().VerifyAuthentication(authParam);
414 EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START);
415 }
416
417 /**
418 * @tc.name: GetUdidByNetworkId_001
419 * @tc.desc: Make success for GetUdidByNetworkId，The return value is
420 * DM_OK
421 * @tc.type: FUNC
422 * @tc.require: AR000GHSJK
423 */
424 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
425 {
426 std::string pkgName = "com.ohos.test";
427 std::string netWorkId = "123";
428 std::string udid = "123";
429 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
430 EXPECT_EQ(ret, DM_OK);
431 }
432
433 /**
434 * @tc.name: GetUdidByNetworkId_002
435 * @tc.desc: Make not init for GetUdidByNetworkId，The return value is
436 * DM_OK
437 * @tc.type: FUNC
438 * @tc.require: AR000GHSJK
439 */
440 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
441 {
442 std::string pkgName = "com.ohos.test";
443 std::string netWorkId = "111";
444 std::string udid = "2222";
445 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
446 EXPECT_EQ(ret, DM_OK);
447 }
448
449 /**
450 * @tc.name: GetUdidByNetworkId_003
451 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is
452 * ERR_DM_INPUT_PARA_INVALID
453 * @tc.type: FUNC
454 * @tc.require: AR000GHSJK
455 */
456 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
457 {
458 std::string pkgName = "";
459 std::string netWorkId = "";
460 std::string udid = "";
461 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
462 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
463 }
464
465 /**
466 * @tc.name: GetUuidByNetworkId_001
467 * @tc.desc: Make success for GetUuidByNetworkId，The return value is
468 * DM_OK
469 * @tc.type: FUNC
470 * @tc.require: AR000GHSJK
471 */
472 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
473 {
474 std::string pkgName = "com.ohos.test";
475 std::string netWorkId = "12";
476 std::string uuid = "12";
477 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
478 EXPECT_EQ(ret, DM_OK);
479 }
480
481 /**
482 * @tc.name: GetUuidByNetworkId_002
483 * @tc.desc: Make not init for GetUuidByNetworkId，The return value is
484 * ERR_DM_NOT_INIT
485 * @tc.type: FUNC
486 * @tc.require: AR000GHSJK
487 */
488 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
489 {
490 std::string pkgName = "com.ohos.test";
491 std::string netWorkId = "12";
492 std::string uuid = "21";
493 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
494 EXPECT_EQ(ret, DM_OK);
495 }
496
497 /**
498 * @tc.name: GetUuidByNetworkId_003
499 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is
500 * ERR_DM_INPUT_PARA_INVALID
501 * @tc.type: FUNC
502 * @tc.require: AR000GHSJK
503 */
504 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
505 {
506 std::string pkgName = "";
507 std::string netWorkId = "";
508 std::string uuid = "";
509 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
510 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
511 }
512
513 /**
514 * @tc.name: GetFaParam_001
515 * @tc.desc: Make success for GetFaParam，The return value is
516 * DM_OK
517 * @tc.type: FUNC
518 * @tc.require: AR000GHSJK
519 */
520 HWTEST_F(DeviceManagerServiceTest, GetFaParam_001, testing::ext::TestSize.Level0)
521 {
522 std::string pkgName = "com.ohos.test";
523 DmAuthParam authParam;
524 int ret = DeviceManagerService::GetInstance().GetFaParam(pkgName, authParam);
525 EXPECT_EQ(ret, DM_OK);
526 }
527
528 /**
529 * @tc.name: GetFaParam_002
530 * @tc.desc: Make pkgName empty for GetFaParam, The return value is
531 * ERR_DM_INPUT_PARA_INVALID
532 * @tc.type: FUNC
533 * @tc.require: AR000GHSJK
534 */
535 HWTEST_F(DeviceManagerServiceTest, GetFaParam_002, testing::ext::TestSize.Level0)
536 {
537 std::string pkgName = "";
538 DmAuthParam authParam;
539 int ret = DeviceManagerService::GetInstance().GetFaParam(pkgName, authParam);
540 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
541 }
542
543 /**
544 * @tc.name: SetUserOperation_001
545 * @tc.desc: Make success for SetUserOperation，The return value is
546 * DM_OK
547 * @tc.type: FUNC
548 * @tc.require: AR000GHSJK
549 */
550 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_001, testing::ext::TestSize.Level0)
551 {
552 std::string pkgName = "com.ohos.test";
553 int32_t action = 0;
554 const std::string param = "extra";
555 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
556 EXPECT_EQ(ret, DM_OK);
557 }
558
559 /**
560 * @tc.name: SetUserOperation_002
561 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
562 * ERR_DM_INPUT_PARA_INVALID
563 * @tc.type: FUNC
564 * @tc.require: AR000GHSJK
565 */
566 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_002, testing::ext::TestSize.Level0)
567 {
568 std::string pkgName = "";
569 int32_t action = 0;
570 const std::string param = "extra";
571 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
572 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
573 }
574
575 /**
576 * @tc.name: RegisterDevStateCallback_001
577 * @tc.desc: Make success for RegisterDevStateCallback，The return value is
578 * DM_OK
579 * @tc.type: FUNC
580 * @tc.require: AR000GHSJK
581 */
582 HWTEST_F(DeviceManagerServiceTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
583 {
584 std::string pkgName = "com.ohos.test";
585 std::string extra = "extra";
586 int32_t ret = DeviceManagerService::GetInstance().RegisterDevStateCallback(pkgName, extra);
587 EXPECT_EQ(ret, DM_OK);
588 }
589
590 /**
591 * @tc.name: RegisterDevStateCallback_002
592 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
593 * @tc.type: FUNC
594 * @tc.require: AR000GHSJK
595 */
596 HWTEST_F(DeviceManagerServiceTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
597 {
598 std::string pkgName = "";
599 std::string extra = "extraTest";
600 int32_t ret = DeviceManagerService::GetInstance().RegisterDevStateCallback(pkgName, extra);
601 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
602 }
603
604 /**
605 * @tc.name: UnRegisterDevStateCallback_001
606 * @tc.desc: Make success for UnRegisterDevStateCallback，The return value is
607 * DM_OK
608 * @tc.type: FUNC
609 * @tc.require: AR000GHSJK
610 */
611 HWTEST_F(DeviceManagerServiceTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
612 {
613 std::string pkgName = "com.ohos.test";
614 std::string extra = "extra";
615 int32_t ret = DeviceManagerService::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
616 EXPECT_EQ(ret, DM_OK);
617 }
618
619 /**
620 * @tc.name: UnRegisterDevStateCallback_002
621 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
622 * @tc.type: FUNC
623 * @tc.require: AR000GHSJK
624 */
625 HWTEST_F(DeviceManagerServiceTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
626 {
627 std::string pkgName = "";
628 std::string extra = "extraTest";
629 int32_t ret = DeviceManagerService::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
630 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
631 }
632
633 /**
634 * @tc.name: GetLocalDeviceInfo_001
635 * @tc.desc: The return value is DM_OK
636 * @tc.type: FUNC
637 * @tc.require: AR000GHSJK
638 */
639 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
640 {
641 DmDeviceInfo info;
642 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
643 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
644 EXPECT_EQ(ret, DM_OK);
645 }
646
647 /**
648 * @tc.name: RequestCredential_001
649 * @tc.desc:The return value is ERR_DM_FAILED
650 * @tc.type: FUNC
651 * @tc.require: AR000GHSJK
652 */
653 HWTEST_F(DeviceManagerServiceTest, RequestCredential_001, testing::ext::TestSize.Level0)
654 {
655 const std::string reqJsonStr = "test";
656 std::string returnJsonStr = "returntest";
657 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
658 EXPECT_EQ(ret, ERR_DM_FAILED);
659 }
660
661 /**
662 * @tc.name: RequestCredential_002
663 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
664 * @tc.type: FUNC
665 * @tc.require: AR000GHSJK
666 */
667 HWTEST_F(DeviceManagerServiceTest, RequestCredential_002, testing::ext::TestSize.Level0)
668 {
669 const std::string reqJsonStr = "";
670 std::string returnJsonStr = "returntest";
671 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
672 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
673 }
674
675 /**
676 * @tc.name: ImportCredential_001
677 * @tc.desc:The return value is ERR_DM_FAILED
678 * @tc.type: FUNC
679 * @tc.require: AR000GHSJK
680 */
681 HWTEST_F(DeviceManagerServiceTest, ImportCredential_001, testing::ext::TestSize.Level0)
682 {
683 const std::string pkgName = "pkgNametest";
684 const std::string credentialInfo = "credentialInfotest";
685 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
686 EXPECT_EQ(ret, ERR_DM_FAILED);
687 }
688
689 /**
690 * @tc.name: ImportCredential_002
691 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
692 * @tc.type: FUNC
693 * @tc.require: AR000GHSJK
694 */
695 HWTEST_F(DeviceManagerServiceTest, ImportCredential_002, testing::ext::TestSize.Level0)
696 {
697 const std::string pkgName = "";
698 const std::string credentialInfo = "";
699 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
700 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
701 }
702
703 /**
704 * @tc.name: DeleteCredential_001
705 * @tc.desc:The return value is ERR_DM_FAILED
706 * @tc.type: FUNC
707 * @tc.require: AR000GHSJK
708 */
709 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_001, testing::ext::TestSize.Level0)
710 {
711 const std::string pkgName = "pkgNametest";
712 const std::string deleteInfo = "deleteInfotest";
713 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
714 EXPECT_EQ(ret, ERR_DM_FAILED);
715 }
716
717 /**
718 * @tc.name: DeleteCredential_002
719 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
720 * @tc.type: FUNC
721 * @tc.require: AR000GHSJK
722 */
723 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_002, testing::ext::TestSize.Level0)
724 {
725 const std::string pkgName = "";
726 const std::string deleteInfo = "";
727 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
728 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
729 }
730
731 /**
732 * @tc.name: RegisterCredentialCallback_001
733 * @tc.desc: The return value is DM_OK
734 * @tc.type: FUNC
735 * @tc.require: AR000GHSJK
736 */
737 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
738 {
739 const std::string pkgName = "pkgNametest";
740 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
741 EXPECT_EQ(ret, DM_OK);
742 }
743
744 /**
745 * @tc.name: RegisterCredentialCallback_002
746 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
747 * @tc.type: FUNC
748 * @tc.require: AR000GHSJK
749 */
750 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
751 {
752 const std::string pkgName = "";
753 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
754 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
755 }
756
757 /**
758 * @tc.name: UnRegisterCredentialCallback_001
759 * @tc.desc:The return value is DM_OK
760 * @tc.type: FUNC
761 * @tc.require: AR000GHSJK
762 */
763 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
764 {
765 const std::string pkgName = "pkgNametest";
766 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
767 EXPECT_EQ(ret, DM_OK);
768 }
769
770 /**
771 * @tc.name: UnRegisterCredentialCallback_002
772 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
773 * @tc.type: FUNC
774 * @tc.require: AR000GHSJK
775 */
776 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
777 {
778 const std::string pkgName = "";
779 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
780 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
781 }
782
783 /**
784 * @tc.name: UninitSoftbusListener_001
785 * @tc.desc: DeviceManagerService::GetInstance().softbusListener_ is nullptr
786 * @tc.type: FUNC
787 * @tc.require: AR000GHSJK
788 */
789 HWTEST_F(DeviceManagerServiceTest, UninitSoftbusListener_001, testing::ext::TestSize.Level0)
790 {
791 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
792 DeviceManagerService::GetInstance().UninitSoftbusListener();
793 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
794 }
795
796 /**
797 * @tc.name: UninitDMServiceListener_001
798 * @tc.desc: DeviceManagerService::GetInstance().listener_ is nullptr
799 * @tc.type: FUNC
800 * @tc.require: AR000GHSJK
801 */
802 HWTEST_F(DeviceManagerServiceTest, UninitDMServiceListener_001, testing::ext::TestSize.Level0)
803 {
804 DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>();
805 DeviceManagerService::GetInstance().UninitDMServiceListener();
806 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
807 }
808
809 /**
810 * @tc.name: IsDMServiceImplSoLoaded_001
811 * @tc.desc: DeviceManagerService::GetInstance().isImplsoLoaded_ is false
812 * @tc.type: FUNC
813 * @tc.require: AR000GHSJK
814 */
815 HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplSoLoaded_001, testing::ext::TestSize.Level0)
816 {
817 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
818 DeviceManagerService::GetInstance().LoadHardwareFwkService();
819 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplSoLoaded();
820 EXPECT_EQ(ret, false);
821 }
822
823 /**
824 * @tc.name: IsDMServiceImplReady_001
825 * @tc.desc: The return value is true
826 * @tc.type: FUNC
827 * @tc.require: AR000GHSJK
828 */
829 HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplReady_001, testing::ext::TestSize.Level0)
830 {
831 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
832 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplReady();
833 EXPECT_EQ(ret, true);
834 }
835
836 /**
837 * @tc.name: GetDeviceInfo_001
838 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
839 * @tc.type: FUNC
840 * @tc.require: AR000GHSJK
841 */
842 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_001, testing::ext::TestSize.Level0)
843 {
844 std::string networkId = "";
845 DmDeviceInfo info;
846 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info);
847 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
848 }
849
850 /**
851 * @tc.name: GetDeviceInfo_002
852 * @tc.desc: The return value is DM_OK
853 * @tc.type: FUNC
854 * @tc.require: AR000GHSJK
855 */
856 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_002, testing::ext::TestSize.Level0)
857 {
858 std::string networkId = "networkIdTest";
859 DmDeviceInfo info;
860 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info);
861 EXPECT_EQ(ret, DM_OK);
862 }
863
864 /**
865 * @tc.name: CheckApiPermission_001
866 * @tc.desc: The return value is DM_OK
867 * @tc.type: FUNC
868 */
869 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_001, testing::ext::TestSize.Level0)
870 {
871 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission();
872 EXPECT_EQ(ret, DM_OK);
873 }
874
875 /**
876 * @tc.name: RegisterDeviceManagerListener_001
877 * @tc.desc: Set pkgName null
878 * @tc.type: FUNC
879 */
880 HWTEST_F(DeviceManagerServiceTest, RegisterDeviceManagerListener_001, testing::ext::TestSize.Level0)
881 {
882 std::string pkgName;
883 DeviceManagerService::GetInstance().RegisterDeviceManagerListener(pkgName);
884 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
885 }
886
887 /**
888 * @tc.name: UnRegisterDeviceManagerListener_001
889 * @tc.desc: Set pkgName null
890 * @tc.type: FUNC
891 */
892 HWTEST_F(DeviceManagerServiceTest, UnRegisterDeviceManagerListener_001, testing::ext::TestSize.Level0)
893 {
894 std::string pkgName;
895 DeviceManagerService::GetInstance().UnRegisterDeviceManagerListener(pkgName);
896 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
897 }
898
899 /**
900 * @tc.name: GetAvailableDeviceList_001
901 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
902 * @tc.type: FUNC
903 */
904 HWTEST_F(DeviceManagerServiceTest, GetAvailableDeviceList_001, testing::ext::TestSize.Level0)
905 {
906 std::string pkgName;
907 std::vector<DmDeviceBasicInfo> deviceBasicInfoList;
908 int32_t ret = DeviceManagerService::GetInstance().GetAvailableDeviceList(pkgName, deviceBasicInfoList);
909 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
910 }
911
912 /**
913 * @tc.name: GetAvailableDeviceList_002
914 * @tc.desc: The return value is DM_OK
915 * @tc.type: FUNC
916 */
917 HWTEST_F(DeviceManagerServiceTest, GetAvailableDeviceList_002, testing::ext::TestSize.Level0)
918 {
919 std::string pkgName = "com.ohos.test";
920 std::vector<DmDeviceBasicInfo> deviceBasicInfoList;
921 int32_t ret = DeviceManagerService::GetInstance().GetAvailableDeviceList(pkgName, deviceBasicInfoList);
922 EXPECT_EQ(ret, DM_OK);
923 }
924
925 /**
926 * @tc.name: GetLocalDeviceNetworkId_001
927 * @tc.desc: The return value is DM_OK
928 * @tc.type: FUNC
929 */
930 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceNetworkId_001, testing::ext::TestSize.Level0)
931 {
932 std::string networkId;
933 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceNetworkId(networkId);
934 EXPECT_EQ(ret, DM_OK);
935 }
936
937 /**
938 * @tc.name: GetLocalDeviceId_001
939 * @tc.desc: The return value is DM_OK
940 * @tc.type: FUNC
941 */
942 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceId_001, testing::ext::TestSize.Level0)
943 {
944 std::string pkgName;
945 std::string deviceId;
946 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceId(pkgName, deviceId);
947 EXPECT_EQ(ret, DM_OK);
948 }
949
950 /**
951 * @tc.name: GetLocalDeviceName_001
952 * @tc.desc: The return value is DM_OK
953 * @tc.type: FUNC
954 */
955 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceName_001, testing::ext::TestSize.Level0)
956 {
957 std::string pkgName;
958 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceName(pkgName);
959 EXPECT_EQ(ret, DM_OK);
960 }
961
962 /**
963 * @tc.name: GetLocalDeviceType_001
964 * @tc.desc: The return value is DM_OK
965 * @tc.type: FUNC
966 */
967 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceType_001, testing::ext::TestSize.Level0)
968 {
969 int32_t deviceType = 1;
970 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceType(deviceType);
971 EXPECT_EQ(ret, DM_OK);
972 }
973
974 /**
975 * @tc.name: StartDeviceDiscovery_004
976 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
977 * @tc.type: FUNC
978 */
979 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
980 {
981 std::string pkgName;
982 uint16_t subscribeId = 1;
983 std::string filterOptions;
984 int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
985 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
986 }
987
988 /**
989 * @tc.name: StartDeviceDiscovery_005
990 * @tc.desc: The return value is DM_OK
991 * @tc.type: FUNC
992 */
993 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
994 {
995 std::string pkgName = "com.ohos.test";
996 uint16_t subscribeId = 1;
997 std::string filterOptions;
998 int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
999 EXPECT_EQ(ret, DM_OK);
1000 }
1001
1002 /**
1003 * @tc.name: BindDevice_001
1004 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(DeviceManagerServiceTest, BindDevice_001, testing::ext::TestSize.Level0)
1008 {
1009 std::string pkgName = "com.ohos.test";
1010 int32_t authType = 1;
1011 std::string deviceId = "1234";
1012 std::string bindParam;
1013 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1014 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1015 }
1016
1017 /**
1018 * @tc.name: BindDevice_002
1019 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(DeviceManagerServiceTest, BindDevice_002, testing::ext::TestSize.Level0)
1023 {
1024 std::string pkgName = "com.ohos.test";
1025 int32_t authType = 1;
1026 std::string deviceId;
1027 std::string bindParam;
1028 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1029 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1030 }
1031
1032 /**
1033 * @tc.name: BindDevice_003
1034 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(DeviceManagerServiceTest, BindDevice_003, testing::ext::TestSize.Level0)
1038 {
1039 std::string pkgName;
1040 int32_t authType = 1;
1041 std::string deviceId = "1234";
1042 std::string bindParam;
1043 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1044 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1045 }
1046
1047 /**
1048 * @tc.name: UnBindDevice_001
1049 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1050 * @tc.type: FUNC
1051 */
1052 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_001, testing::ext::TestSize.Level0)
1053 {
1054 std::string pkgName = "com.ohos.test";
1055 std::string deviceId = "1234";
1056 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1057 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1058 }
1059
1060 /**
1061 * @tc.name: UnBindDevice_002
1062 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1063 * @tc.type: FUNC
1064 */
1065 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_002, testing::ext::TestSize.Level0)
1066 {
1067 std::string pkgName = "com.ohos.test";
1068 std::string deviceId;
1069 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1070 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1071 }
1072
1073 /**
1074 * @tc.name: UnBindDevice_003
1075 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1076 * @tc.type: FUNC
1077 */
1078 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_003, testing::ext::TestSize.Level0)
1079 {
1080 std::string pkgName;
1081 std::string deviceId = "1234";
1082 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1083 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1084 }
1085
1086 } // namespace
1087 } // namespace DistributedHardware
1088 } // namespace OHOS
1089