1 /*
2 * Copyright (c) 2022 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 uint64_t tokenId;
34 const char *perms[2];
35 perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
36 perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
37 NativeTokenInfoParams infoInstance = {
38 .dcapsNum = 0,
39 .permsNum = 2,
40 .aclsNum = 0,
41 .dcaps = NULL,
42 .perms = perms,
43 .acls = NULL,
44 .processName = "dsoftbus_service",
45 .aplStr = "system_core",
46 };
47 tokenId = GetAccessTokenId(&infoInstance);
48 SetSelfTokenID(tokenId);
49 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
50 }
51
TearDown()52 void DeviceManagerServiceTest::TearDown()
53 {
54 }
55
SetUpTestCase()56 void DeviceManagerServiceTest::SetUpTestCase()
57 {
58 }
59
TearDownTestCase()60 void DeviceManagerServiceTest::TearDownTestCase()
61 {
62 }
63
64 namespace {
65 /**
66 * @tc.name: Init_001
67 * @tc.desc: Init device manager service and return DM_OK
68 * @tc.type: FUNC
69 * @tc.require: AR000GHSJK
70 */
71 HWTEST_F(DeviceManagerServiceTest, Init_001, testing::ext::TestSize.Level0)
72 {
73 int ret = DeviceManagerService::GetInstance().Init();
74 EXPECT_EQ(ret, DM_OK);
75 }
76
77 /**
78 * @tc.name: StartDeviceDiscovery_001
79 * @tc.desc: Start device discovery and return ERR_DM_NOT_INIT
80 * @tc.type: FUNC
81 * @tc.require: AR000GHSJK
82 */
83 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
84 {
85 std::string pkgName = "com.ohos.test";
86 DmSubscribeInfo subscribeInfo;
87 std::string extra;
88 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
89 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
90 }
91
92 /**
93 * @tc.name: StartDeviceDiscovery_002
94 * @tc.desc: Empty pkgName of StartDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
95 * @tc.type: FUNC
96 * @tc.require: AR000GHSJK
97 */
98 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
99 {
100 std::string pkgName;
101 DmSubscribeInfo subscribeInfo;
102 std::string extra = "test";
103 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
104 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
105 }
106
107 /**
108 * @tc.name: StartDeviceDiscovery_003
109 * @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return
110 * ERR_DM_DISCOVERY_REPEATED
111 * @tc.type: FUNC
112 * @tc.require: AR000GHSJK
113 */
114 HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
115 {
116 std::string pkgName = "com.ohos.test";
117 DmSubscribeInfo subscribeInfo;
118 std::string extra;
119 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
120 pkgName = "1com.ohos.test1";
121 ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
122 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
123 }
124
125 /**
126 * @tc.name: StopDeviceDiscovery_001
127 * @tc.desc: Stop device discovery and return ERR_DM_NOT_INIT
128 * @tc.type: FUNC
129 * @tc.require: AR000GHSJK
130 */
131 HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
132 {
133 std::string pkgName = "com.ohos.test";
134 uint16_t subscribeId = 1;
135 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
136 EXPECT_EQ(ret, ERR_DM_DISCOVERY_FAILED);
137 }
138
139 /**
140 * @tc.name:StopDeviceDiscovery_002
141 * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID
142 * @tc.type: FUNC
143 * @tc.require: AR000GHSJK
144 */
145 HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
146 {
147 std::string pkgName;
148 uint16_t subscribeId = 1;
149 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
150 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
151 }
152
153 /**
154 * @tc.name: PublishDeviceDiscovery_001
155 * @tc.desc: Publish device discovery and return ERR_DM_NOT_INIT
156 * @tc.type: FUNC
157 * @tc.require: I5N1K3
158 */
159 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
160 {
161 std::string pkgName = "com.ohos.test12";
162 DmPublishInfo publishInfo;
163 publishInfo.publishId = 1;
164 publishInfo.mode = DM_DISCOVER_MODE_ACTIVE;
165 publishInfo.freq = DM_HIGH;
166 publishInfo.ranging = 1;
167 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
168 EXPECT_EQ(ret, DM_OK);
169 DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishInfo.publishId);
170 }
171
172 /**
173 * @tc.name: PublishDeviceDiscovery_002
174 * @tc.desc: Empty pkgName of PublishDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
175 * @tc.type: FUNC
176 * @tc.require: I5N1K3
177 */
178 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
179 {
180 std::string pkgName;
181 DmPublishInfo publishInfo;
182 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
183 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
184 }
185
186 /**
187 * @tc.name: PublishDeviceDiscovery_003
188 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return
189 * ERR_DM_DISCOVERY_REPEATED
190 * @tc.type: FUNC
191 * @tc.require: I5N1K3
192 */
193 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
194 {
195 std::string pkgName = "com.ohos.test";
196 DmPublishInfo publishInfo;
197 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
198 pkgName = "1com.ohos.test1";
199 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
200 EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
201 }
202
203 /**
204 * @tc.name: UnPublishDeviceDiscovery_001
205 * @tc.desc: UnPublish device discovery and return ERR_DM_NOT_INIT
206 * @tc.type: FUNC
207 * @tc.require: I5N1K3
208 */
209 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
210 {
211 std::string pkgName = "com.ohos.test";
212 int32_t publishId = 1;
213 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
214 EXPECT_EQ(ret, ERR_DM_PUBLISH_FAILED);
215 }
216
217 /**
218 * @tc.name: UnPublishDeviceDiscovery_002
219 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID
220 * @tc.type: FUNC
221 * @tc.require: I5N1K3
222 */
223 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
224 {
225 std::string pkgName;
226 int32_t publishId = 1;
227 DeviceManagerService::GetInstance().Init();
228 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
229 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
230 }
231
232 /**
233 * @tc.name: GetTrustedDeviceList_001
234 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true and pkgName = null; Return ERR_DM_INPUT_PARA_INVALID
235 * @tc.type: FUNC
236 * @tc.require: AR000GHSJK
237 */
238 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
239 {
240 std::string pkgName;
241 std::string extra = "jdddd";
242 std::vector<DmDeviceInfo> deviceList;
243 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
244 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
245 }
246
247 /**
248 * @tc.name: AuthenticateDevice_001
249 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_INPUT_PARA_INVALID
250 * @tc.type: FUNC
251 * @tc.require: AR000GHSJK
252 */
253 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
254 {
255 std::string pkgName = "com.ohos.test";
256 std::string extra = "jdddd";
257 int32_t authType = 1;
258 std::string deviceId = "2345";
259 int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
260 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
261 }
262
263 /**
264 * @tc.name: AuthenticateDevice_002
265 * @tc.desc: Set intFlag for GAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
266 * @tc.type: FUNC
267 * @tc.require: AR000GHSJK
268 */
269 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
270 {
271 std::string pkgName;
272 std::string extra = "jdddd";
273 int32_t authType = 0;
274 std::string deviceId = " 2345";
275 int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
276 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
277 }
278
279 /**
280 * @tc.name: AuthenticateDevice_003
281 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_INPUT_PARA_INVALID
282 * @tc.type: FUNC
283 * @tc.require: AR000GHSJK
284 */
285 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
286 {
287 std::string pkgName = "com.ohos.test";
288 std::string extra = "jdddd";
289 int32_t authType = 0;
290 std::string deviceId;
291 int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
292 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
293 }
294
295 /**
296 * @tc.name: UnAuthenticateDevice_001
297 * @tc.desc: 将UnAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";Return ERR_DM_FAILED
298 * @tc.type: FUNC
299 * @tc.require: AR000GHSJK
300 */
301 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
302 {
303 std::string pkgName = "com.ohos.test";
304 std::string deviceId = "12345";
305 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
306 EXPECT_EQ(ret, ERR_DM_FAILED);
307 }
308
309 /**
310 * @tc.name: UnAuthenticateDevice_002
311 * @tc.desc: Set intFlag for UnAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
312 * @tc.type: FUNC
313 * @tc.require: AR000GHSJK
314 */
315 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
316 {
317 std::string pkgName;
318 std::string deviceId = "12345";
319 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
320 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
321 }
322
323 /**
324 * @tc.name: UnAuthenticateDevice_003
325 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
326 * value is ERR_DM_INPUT_PARA_INVALID
327 * @tc.type: FUNC
328 * @tc.require: AR000GHSJK
329 */
330 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
331 {
332 std::string pkgName = "com.ohos.test";
333 std::string deviceId;
334 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
335 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
336 }
337
338 /**
339 * @tc.name: VerifyAuthentication_001
340 * @tc.desc: Set intFlag for VerifyAuthentication to false and set authParam = "jdjjjj"，The return value is
341 * ERR_DM_AUTH_NOT_START
342 * @tc.type: FUNC
343 * @tc.require: AR000GHSJK
344 */
345 HWTEST_F(DeviceManagerServiceTest, VerifyAuthentication_001, testing::ext::TestSize.Level0)
346 {
347 std::string authParam = "jdjjjj";
348 int ret = DeviceManagerService::GetInstance().VerifyAuthentication(authParam);
349 EXPECT_EQ(ret, ERR_DM_AUTH_NOT_START);
350 }
351
352 /**
353 * @tc.name: GetUdidByNetworkId_001
354 * @tc.desc: Make success for GetUdidByNetworkId，The return value is
355 * DM_OK
356 * @tc.type: FUNC
357 * @tc.require: AR000GHSJK
358 */
359 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
360 {
361 std::string pkgName = "com.ohos.test";
362 std::string netWorkId = "123";
363 std::string udid = "123";
364 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
365 EXPECT_EQ(ret, DM_OK);
366 }
367
368 /**
369 * @tc.name: GetUdidByNetworkId_002
370 * @tc.desc: Make not init for GetUdidByNetworkId，The return value is
371 * DM_OK
372 * @tc.type: FUNC
373 * @tc.require: AR000GHSJK
374 */
375 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
376 {
377 std::string pkgName = "com.ohos.test";
378 std::string netWorkId = "111";
379 std::string udid = "2222";
380 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
381 EXPECT_EQ(ret, DM_OK);
382 }
383
384 /**
385 * @tc.name: GetUdidByNetworkId_003
386 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is
387 * ERR_DM_INPUT_PARA_INVALID
388 * @tc.type: FUNC
389 * @tc.require: AR000GHSJK
390 */
391 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
392 {
393 std::string pkgName = "";
394 std::string netWorkId = "";
395 std::string udid = "";
396 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
397 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
398 }
399
400 /**
401 * @tc.name: GetUuidByNetworkId_001
402 * @tc.desc: Make success for GetUuidByNetworkId，The return value is
403 * DM_OK
404 * @tc.type: FUNC
405 * @tc.require: AR000GHSJK
406 */
407 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
408 {
409 std::string pkgName = "com.ohos.test";
410 std::string netWorkId = "12";
411 std::string uuid = "12";
412 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
413 EXPECT_EQ(ret, DM_OK);
414 }
415
416 /**
417 * @tc.name: GetUuidByNetworkId_002
418 * @tc.desc: Make not init for GetUuidByNetworkId，The return value is
419 * ERR_DM_NOT_INIT
420 * @tc.type: FUNC
421 * @tc.require: AR000GHSJK
422 */
423 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
424 {
425 std::string pkgName = "com.ohos.test";
426 std::string netWorkId = "12";
427 std::string uuid = "21";
428 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
429 EXPECT_EQ(ret, DM_OK);
430 }
431
432 /**
433 * @tc.name: GetUuidByNetworkId_003
434 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is
435 * ERR_DM_INPUT_PARA_INVALID
436 * @tc.type: FUNC
437 * @tc.require: AR000GHSJK
438 */
439 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
440 {
441 std::string pkgName = "";
442 std::string netWorkId = "";
443 std::string uuid = "";
444 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
445 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
446 }
447
448 /**
449 * @tc.name: GetFaParam_001
450 * @tc.desc: Make success for GetFaParam，The return value is
451 * DM_OK
452 * @tc.type: FUNC
453 * @tc.require: AR000GHSJK
454 */
455 HWTEST_F(DeviceManagerServiceTest, GetFaParam_001, testing::ext::TestSize.Level0)
456 {
457 std::string pkgName = "com.ohos.test";
458 DmAuthParam authParam;
459 int ret = DeviceManagerService::GetInstance().GetFaParam(pkgName, authParam);
460 EXPECT_EQ(ret, DM_OK);
461 }
462
463 /**
464 * @tc.name: GetFaParam_002
465 * @tc.desc: Make pkgName empty for GetFaParam, The return value is
466 * ERR_DM_INPUT_PARA_INVALID
467 * @tc.type: FUNC
468 * @tc.require: AR000GHSJK
469 */
470 HWTEST_F(DeviceManagerServiceTest, GetFaParam_002, testing::ext::TestSize.Level0)
471 {
472 std::string pkgName = "";
473 DmAuthParam authParam;
474 int ret = DeviceManagerService::GetInstance().GetFaParam(pkgName, authParam);
475 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
476 }
477
478 /**
479 * @tc.name: SetUserOperation_001
480 * @tc.desc: Make success for SetUserOperation，The return value is
481 * DM_OK
482 * @tc.type: FUNC
483 * @tc.require: AR000GHSJK
484 */
485 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_001, testing::ext::TestSize.Level0)
486 {
487 std::string pkgName = "com.ohos.test";
488 int32_t action = 0;
489 const std::string param = "extra";
490 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
491 EXPECT_EQ(ret, DM_OK);
492 }
493
494 /**
495 * @tc.name: SetUserOperation_002
496 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
497 * ERR_DM_INPUT_PARA_INVALID
498 * @tc.type: FUNC
499 * @tc.require: AR000GHSJK
500 */
501 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_002, testing::ext::TestSize.Level0)
502 {
503 std::string pkgName = "";
504 int32_t action = 0;
505 const std::string param = "extra";
506 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
507 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
508 }
509
510 /**
511 * @tc.name: RegisterDevStateCallback_001
512 * @tc.desc: Make success for RegisterDevStateCallback，The return value is
513 * DM_OK
514 * @tc.type: FUNC
515 * @tc.require: AR000GHSJK
516 */
517 HWTEST_F(DeviceManagerServiceTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0)
518 {
519 std::string pkgName = "com.ohos.test";
520 std::string extra = "extra";
521 int32_t ret = DeviceManagerService::GetInstance().RegisterDevStateCallback(pkgName, extra);
522 EXPECT_EQ(ret, DM_OK);
523 }
524
525 /**
526 * @tc.name: RegisterDevStateCallback_002
527 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
528 * @tc.type: FUNC
529 * @tc.require: AR000GHSJK
530 */
531 HWTEST_F(DeviceManagerServiceTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0)
532 {
533 std::string pkgName = "";
534 std::string extra = "extraTest";
535 int32_t ret = DeviceManagerService::GetInstance().RegisterDevStateCallback(pkgName, extra);
536 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
537 }
538
539 /**
540 * @tc.name: UnRegisterDevStateCallback_001
541 * @tc.desc: Make success for UnRegisterDevStateCallback，The return value is
542 * DM_OK
543 * @tc.type: FUNC
544 * @tc.require: AR000GHSJK
545 */
546 HWTEST_F(DeviceManagerServiceTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0)
547 {
548 std::string pkgName = "com.ohos.test";
549 std::string extra = "extra";
550 int ret = DeviceManagerService::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
551 EXPECT_EQ(ret, DM_OK);
552 }
553
554 /**
555 * @tc.name: UnRegisterDevStateCallback_002
556 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
557 * @tc.type: FUNC
558 * @tc.require: AR000GHSJK
559 */
560 HWTEST_F(DeviceManagerServiceTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0)
561 {
562 std::string pkgName = "";
563 std::string extra = "extraTest";
564 int32_t ret = DeviceManagerService::GetInstance().UnRegisterDevStateCallback(pkgName, extra);
565 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
566 }
567
568 /**
569 * @tc.name: GetLocalDeviceInfo_001
570 * @tc.desc: The return value is DM_OK
571 * @tc.type: FUNC
572 * @tc.require: AR000GHSJK
573 */
574 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
575 {
576 DmDeviceInfo info;
577 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
578 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
579 EXPECT_EQ(ret, DM_OK);
580 }
581
582 /**
583 * @tc.name: RequestCredential_001
584 * @tc.desc:The return value is ERR_DM_FAILED
585 * @tc.type: FUNC
586 * @tc.require: AR000GHSJK
587 */
588 HWTEST_F(DeviceManagerServiceTest, RequestCredential_001, testing::ext::TestSize.Level0)
589 {
590 const std::string reqJsonStr = "test";
591 std::string returnJsonStr = "returnTest";
592 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
593 EXPECT_EQ(ret, ERR_DM_FAILED);
594 }
595
596 /**
597 * @tc.name: RequestCredential_002
598 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
599 * @tc.type: FUNC
600 * @tc.require: AR000GHSJK
601 */
602 HWTEST_F(DeviceManagerServiceTest, RequestCredential_002, testing::ext::TestSize.Level0)
603 {
604 const std::string reqJsonStr = "";
605 std::string returnJsonStr = "returnTest";
606 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
607 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
608 }
609
610 /**
611 * @tc.name: ImportCredential_001
612 * @tc.desc:The return value is ERR_DM_FAILED
613 * @tc.type: FUNC
614 * @tc.require: AR000GHSJK
615 */
616 HWTEST_F(DeviceManagerServiceTest, ImportCredential_001, testing::ext::TestSize.Level0)
617 {
618 const std::string pkgName = "pkgNameTest";
619 const std::string credentialInfo = "credentialInfoTest";
620 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
621 EXPECT_EQ(ret, ERR_DM_FAILED);
622 }
623
624 /**
625 * @tc.name: ImportCredential_002
626 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
627 * @tc.type: FUNC
628 * @tc.require: AR000GHSJK
629 */
630 HWTEST_F(DeviceManagerServiceTest, ImportCredential_002, testing::ext::TestSize.Level0)
631 {
632 const std::string pkgName = "";
633 const std::string credentialInfo = "";
634 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
635 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
636 }
637
638 /**
639 * @tc.name: DeleteCredential_001
640 * @tc.desc:The return value is ERR_DM_FAILED
641 * @tc.type: FUNC
642 * @tc.require: AR000GHSJK
643 */
644 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_001, testing::ext::TestSize.Level0)
645 {
646 const std::string pkgName = "pkgNameTest";
647 const std::string deleteInfo = "deleteinfotest";
648 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
649 EXPECT_EQ(ret, ERR_DM_FAILED);
650 }
651
652 /**
653 * @tc.name: DeleteCredential_002
654 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
655 * @tc.type: FUNC
656 * @tc.require: AR000GHSJK
657 */
658 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_002, testing::ext::TestSize.Level0)
659 {
660 const std::string pkgName = "";
661 const std::string deleteInfo = "";
662 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
663 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
664 }
665
666 /**
667 * @tc.name: RegisterCredentialCallback_001
668 * @tc.desc: The return value is DM_OK
669 * @tc.type: FUNC
670 * @tc.require: AR000GHSJK
671 */
672 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
673 {
674 const std::string pkgName = "pkgNameTest";
675 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
676 EXPECT_EQ(ret, DM_OK);
677 }
678
679 /**
680 * @tc.name: RegisterCredentialCallback_002
681 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
682 * @tc.type: FUNC
683 * @tc.require: AR000GHSJK
684 */
685 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
686 {
687 const std::string pkgName = "";
688 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
689 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
690 }
691
692 /**
693 * @tc.name: UnRegisterCredentialCallback_001
694 * @tc.desc:The return value is DM_OK
695 * @tc.type: FUNC
696 * @tc.require: AR000GHSJK
697 */
698 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
699 {
700 const std::string pkgName = "pkgNameTest";
701 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
702 EXPECT_EQ(ret, DM_OK);
703 }
704
705 /**
706 * @tc.name: UnRegisterCredentialCallback_002
707 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
708 * @tc.type: FUNC
709 * @tc.require: AR000GHSJK
710 */
711 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
712 {
713 const std::string pkgName = "";
714 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
715 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
716 }
717
718 /**
719 * @tc.name: UninitSoftbusListener_001
720 * @tc.desc: DeviceManagerService::GetInstance().softbusListener_ is nullptr
721 * @tc.type: FUNC
722 * @tc.require: AR000GHSJK
723 */
724 HWTEST_F(DeviceManagerServiceTest, UninitSoftbusListener_001, testing::ext::TestSize.Level0)
725 {
726 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
727 DeviceManagerService::GetInstance().UninitSoftbusListener();
728 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
729 }
730
731 /**
732 * @tc.name: UninitDMServiceListener_001
733 * @tc.desc: DeviceManagerService::GetInstance().listener_ is nullptr
734 * @tc.type: FUNC
735 * @tc.require: AR000GHSJK
736 */
737 HWTEST_F(DeviceManagerServiceTest, UninitDMServiceListener_001, testing::ext::TestSize.Level0)
738 {
739 DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>();
740 DeviceManagerService::GetInstance().UninitDMServiceListener();
741 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
742 }
743
744 /**
745 * @tc.name: IsDMServiceImplSoLoaded_001
746 * @tc.desc: DeviceManagerService::GetInstance().isImplsoLoaded_ is false
747 * @tc.type: FUNC
748 * @tc.require: AR000GHSJK
749 */
750 HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplSoLoaded_001, testing::ext::TestSize.Level0)
751 {
752 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
753 DeviceManagerService::GetInstance().LoadHardwareFwkService();
754 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplSoLoaded();
755 EXPECT_EQ(ret, false);
756 }
757
758 /**
759 * @tc.name: IsDMServiceImplReady_001
760 * @tc.desc: The return value is is true
761 * @tc.type: FUNC
762 * @tc.require: AR000GHSJK
763 */
764 HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplReady_001, testing::ext::TestSize.Level0)
765 {
766 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
767 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplReady();
768 EXPECT_EQ(ret, true);
769 }
770 } // namespace
771 } // namespace DistributedHardware
772 } // namespace OHOS
773