1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "UTTest_device_manager_service.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 #include "softbus_error_code.h"
26
27 using namespace OHOS::Security::AccessToken;
28 using namespace testing;
29 using namespace testing::ext;
30 namespace OHOS {
31 namespace DistributedHardware {
32 DM_IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService);
33
SetUp()34 void DeviceManagerServiceTest::SetUp()
35 {
36 const int32_t permsNum = 4;
37 const int32_t indexZero = 0;
38 const int32_t indexOne = 1;
39 const int32_t indexTwo = 2;
40 const int32_t indexThree = 3;
41 uint64_t tokenId;
42 const char *perms[permsNum];
43 perms[indexZero] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
44 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
45 perms[indexTwo] = "ohos.permission.ACCESS_SERVICE_DM";
46 perms[indexThree] = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE";
47 NativeTokenInfoParams infoInstance = {
48 .dcapsNum = 0,
49 .permsNum = permsNum,
50 .aclsNum = 0,
51 .dcaps = NULL,
52 .perms = perms,
53 .acls = NULL,
54 .processName = "dsoftbus_service",
55 .aplStr = "system_core",
56 };
57 tokenId = GetAccessTokenId(&infoInstance);
58 SetSelfTokenID(tokenId);
59 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
60 }
61
TearDown()62 void DeviceManagerServiceTest::TearDown()
63 {
64 }
65
SetUpTestCase()66 void DeviceManagerServiceTest::SetUpTestCase()
67 {
68 DmPermissionManager::dmPermissionManager = permissionManagerMock_;
69 DmSoftbusListener::dmSoftbusListener = softbusListenerMock_;
70 DmKVAdapterManager::dmKVAdapterManager = kVAdapterManagerMock_;
71 DmAppManager::dmAppManager = appManagerMock_;
72 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_;
73 DmSoftbusCache::dmSoftbusCache = softbusCacheMock_;
74 DmCrypto::dmCrypto = cryptoMock_;
75 DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_;
76 DmDMCommTool::dmDMCommTool = dMCommToolMock_;
77 DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_;
78 }
79
TearDownTestCase()80 void DeviceManagerServiceTest::TearDownTestCase()
81 {
82 DmPermissionManager::dmPermissionManager = nullptr;
83 permissionManagerMock_ = nullptr;
84 DmSoftbusListener::dmSoftbusListener = nullptr;
85 softbusListenerMock_ = nullptr;
86 DmKVAdapterManager::dmKVAdapterManager = nullptr;
87 kVAdapterManagerMock_ = nullptr;
88 DmAppManager::dmAppManager = nullptr;
89 appManagerMock_ = nullptr;
90 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = nullptr;
91 deviceManagerServiceImplMock_ = nullptr;
92 DmSoftbusCache::dmSoftbusCache = nullptr;
93 softbusCacheMock_ = nullptr;
94 DmCrypto::dmCrypto = nullptr;
95 cryptoMock_ = nullptr;
96 DmMultipleUserConnector::dmMultipleUserConnector = nullptr;
97 multipleUserConnectorMock_ = nullptr;
98 DmDMCommTool::dmDMCommTool = nullptr;
99 dMCommToolMock_ = nullptr;
100 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
101 deviceProfileConnectorMock_ = nullptr;
102 }
103
104 namespace {
DeletePermission()105 void DeletePermission()
106 {
107 const int32_t permsNum = 1;
108 const int32_t indexZero = 0;
109 uint64_t tokenId;
110 const char *perms[permsNum];
111 perms[indexZero] = "ohos.permission";
112 NativeTokenInfoParams infoInstance = {
113 .dcapsNum = 0,
114 .permsNum = permsNum,
115 .aclsNum = 0,
116 .dcaps = NULL,
117 .perms = perms,
118 .acls = NULL,
119 .processName = "DeviceManagerServiceTest",
120 .aplStr = "system_core",
121 };
122 tokenId = GetAccessTokenId(&infoInstance);
123 SetSelfTokenID(tokenId);
124 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
125 }
126
127 /**
128 * @tc.name: InitDMServiceListener_001
129 * @tc.desc: Init device manager listener and return DM_OK
130 * @tc.type: FUNC
131 * @tc.require: AR000GHSJK
132 */
133 HWTEST_F(DeviceManagerServiceTest, InitDMServiceListener_001, testing::ext::TestSize.Level0)
134 {
135 int ret = DeviceManagerService::GetInstance().InitDMServiceListener();
136 EXPECT_EQ(ret, DM_OK);
137 DeviceManagerService::GetInstance().UninitDMServiceListener();
138 }
139
140 /**
141 * @tc.name: PublishDeviceDiscovery_001
142 * @tc.desc: Publish device discovery and return ERR_DM_NO_PERMISSION
143 * @tc.type: FUNC
144 * @tc.require: I5N1K3
145 */
146 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
147 {
148 DeletePermission();
149 std::string pkgName = "com.ohos.test12";
150 DmPublishInfo publishInfo;
151 publishInfo.publishId = 1;
152 publishInfo.mode = DM_DISCOVER_MODE_ACTIVE;
153 publishInfo.freq = DM_HIGH;
154 publishInfo.ranging = 1;
155 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
156 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
157 DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishInfo.publishId);
158 }
159
160 /**
161 * @tc.name: PublishDeviceDiscovery_002
162 * @tc.desc: Empty pkgName of PublishDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
163 * @tc.type: FUNC
164 * @tc.require: I5N1K3
165 */
166 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
167 {
168 std::string pkgName;
169 DmPublishInfo publishInfo;
170 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
171 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
172 }
173
174 /**
175 * @tc.name: PublishDeviceDiscovery_003
176 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return
177 * SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM
178 * @tc.type: FUNC
179 * @tc.require: I5N1K3
180 */
181 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
182 {
183 std::string pkgName = "com.ohos.test";
184 DmPublishInfo publishInfo;
185 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
186 pkgName = "1com.ohos.test1";
187 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
188 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
189 }
190
191 /**
192 * @tc.name: PublishDeviceDiscovery_004
193 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return
194 * SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM
195 * @tc.type: FUNC
196 * @tc.require: I5N1K3
197 */
198 HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
199 {
200 std::string pkgName = "PublishDeviceDiscovery_004";
201 DmPublishInfo publishInfo;
202 DeviceManagerService::GetInstance().InitDMServiceListener();
203 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
204 pkgName = "1com.ohos.test1";
205 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo);
206 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM || ret == DM_OK);
207 DeviceManagerService::GetInstance().UninitDMServiceListener();
208 }
209
210 /**
211 * @tc.name: UnPublishDeviceDiscovery_001
212 * @tc.desc: UnPublish device discovery and return SOFTBUS_ERR
213 * @tc.type: FUNC
214 * @tc.require: I5N1K3
215 */
216 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0)
217 {
218 std::string pkgName = "com.ohos.test";
219 int32_t publishId = 1;
220 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
221 EXPECT_NE(ret, DM_OK);
222 }
223
224 /**
225 * @tc.name: UnPublishDeviceDiscovery_002
226 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID
227 * @tc.type: FUNC
228 * @tc.require: I5N1K3
229 */
230 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0)
231 {
232 std::string pkgName;
233 int32_t publishId = 1;
234 DeviceManagerService::GetInstance().InitDMServiceListener();
235 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
236 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
237 DeviceManagerService::GetInstance().UninitDMServiceListener();
238 }
239
240 /**
241 * @tc.name: UnPublishDeviceDiscovery_003
242 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID
243 * @tc.type: FUNC
244 * @tc.require: I5N1K3
245 */
246 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0)
247 {
248 std::string pkgName = "com.ohos.test003";
249 int32_t publishId = 1;
250 DeviceManagerService::GetInstance().InitDMServiceListener();
251 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
252 EXPECT_TRUE(ret == SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL || ret == SOFTBUS_ERR ||
253 ret == ERR_DM_INPUT_PARA_INVALID);
254 DeviceManagerService::GetInstance().UninitDMServiceListener();
255 }
256
257 /**
258 * @tc.name: UnPublishDeviceDiscovery_004
259 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID
260 * @tc.type: FUNC
261 * @tc.require: I5N1K3
262 */
263 HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0)
264 {
265 std::string pkgName = "com.ohos.test003";
266 int32_t publishId = 1;
267 int32_t userId = 23;
268 std::string accountId = "hello123";
269 int32_t preUserId = 3;
270 std::vector<std::string> peerUdids;
271 std::string accountName = "openharmony123";
272 std::map<std::string, int32_t> curUserDeviceMap;
273 std::map<std::string, int32_t> preUserDeviceMap;
274 std::multimap<std::string, int32_t> curMultiMap;
275 std::string commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED;
276 EXPECT_CALL(*deviceManagerServiceImplMock_,
277 GetDeviceIdAndBindLevel(_)).WillOnce(Return(curUserDeviceMap)).WillOnce(Return(preUserDeviceMap));
278 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
279 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN;
280 DMAccountInfo dmAccountInfo;
281 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
282 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT;
283 EXPECT_CALL(*multipleUserConnectorMock_, GetAccountInfoByUserId(_)).WillOnce(Return(dmAccountInfo));
284 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_)).WillOnce(Return(curMultiMap));
285 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
286 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
287 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_)).WillOnce(Return(curMultiMap));
288 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
289 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED;
290 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
291 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_))
292 .WillOnce(Return(curMultiMap)).WillOnce(Return(curMultiMap));
293 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, pkgName);
294 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_)).WillOnce(Return(curMultiMap));
295 DeviceManagerService::GetInstance().HandleUserRemoved(preUserId);
296 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
297 DeviceManagerService::GetInstance().SendAccountLogoutBroadCast(peerUdids, accountId, accountName, userId);
298 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
299 DeletePermission();
300 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
301 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
302 }
303
304 /**
305 * @tc.name: GetTrustedDeviceList_001
306 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true and pkgName = null; Return ERR_DM_INPUT_PARA_INVALID
307 * @tc.type: FUNC
308 * @tc.require: AR000GHSJK
309 */
310 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0)
311 {
312 std::string pkgName;
313 std::string extra = "jdddd";
314 std::vector<DmDeviceInfo> deviceList;
315 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
316 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
317 }
318
319 /**
320 * @tc.name: GetTrustedDeviceList_002
321 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true; Return DM_OK
322 * @tc.type: FUNC
323 * @tc.require: AR000GHSJK
324 */
325 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0)
326 {
327 std::string pkgName = "ohos_test";
328 std::string extra = "jdddd";
329 std::vector<DmDeviceInfo> deviceList;
330 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
331 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
332 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
333 }
334
335 /**
336 * @tc.name: GetTrustedDeviceList_003
337 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true; Return DM_OK
338 * @tc.type: FUNC
339 * @tc.require: AR000GHSJK
340 */
341 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0)
342 {
343 std::string pkgName = "ohos_test";
344 std::string extra = "jdddd";
345 std::vector<DmDeviceInfo> deviceList;
346 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
347 DeviceManagerService::GetInstance().InitDMServiceListener();
348 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_)).WillOnce(Return(DM_OK));
349 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
350 EXPECT_EQ(ret, DM_OK);
351 DeviceManagerService::GetInstance().UninitDMServiceListener();
352 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
353 }
354
355 /**
356 * @tc.name: ShiftLNNGear_001
357 * @tc.desc:Set the pkgName to null, callerId not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID
358 * @tc.type: FUNC
359 * @tc.require: AR000GHSJK
360 */
361 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_001, testing::ext::TestSize.Level0)
362 {
363 std::string pkgName;
364 std::string callerId = "com.ohos.test";
365 bool isRefresh = true;
366 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
367 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
368 }
369
370 /**
371 * @tc.name: ShiftLNNGear_002
372 * @tc.desc:Set the callerId to null, pkgNamenot not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID
373 * @tc.type: FUNC
374 * @tc.require: AR000GHSJK
375 */
376 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_002, testing::ext::TestSize.Level0)
377 {
378 std::string pkgName = "com.ohos.test";
379 std::string callerId;
380 bool isRefresh = true;
381 std::vector<DmDeviceInfo> deviceList;
382 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
383 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
384 }
385
386 /**
387 * @tc.name: ShiftLNNGear_003
388 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return DM_OK
389 * @tc.type: FUNC
390 * @tc.require: AR000GHSJK
391 */
392 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_003, testing::ext::TestSize.Level0)
393 {
394 const int32_t permsNum = 1;
395 const int32_t indexZero = 0;
396 uint64_t tokenId;
397 const char *perms[permsNum];
398 perms[indexZero] = "ohos.permission";
399 NativeTokenInfoParams infoInstance = {
400 .dcapsNum = 0,
401 .permsNum = permsNum,
402 .aclsNum = 0,
403 .dcaps = NULL,
404 .perms = perms,
405 .acls = NULL,
406 .processName = "DeviceManagerServiceTest",
407 .aplStr = "system_core",
408 };
409 tokenId = GetAccessTokenId(&infoInstance);
410 SetSelfTokenID(tokenId);
411 std::string pkgName = "com.ohos.test";
412 std::string callerId = "com.ohos.test";
413 bool isRefresh = true;
414 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
415 EXPECT_NE(ret, DM_OK);
416 }
417
418 /**
419 * @tc.name: ShiftLNNGear_004
420 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to false; Return DM_OK
421 * @tc.type: FUNC
422 * @tc.require: AR000GHSJK
423 */
424 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_004, testing::ext::TestSize.Level0)
425 {
426 const int32_t permsNum = 1;
427 const int32_t indexZero = 0;
428 uint64_t tokenId;
429 const char *perms[permsNum];
430 perms[indexZero] = "ohos.permission";
431 NativeTokenInfoParams infoInstance = {
432 .dcapsNum = 0,
433 .permsNum = permsNum,
434 .aclsNum = 0,
435 .dcaps = NULL,
436 .perms = perms,
437 .acls = NULL,
438 .processName = "DeviceManagerServiceTest",
439 .aplStr = "system_core",
440 };
441 tokenId = GetAccessTokenId(&infoInstance);
442 SetSelfTokenID(tokenId);
443 std::string pkgName = "com.ohos.test";
444 std::string callerId = "com.ohos.test";
445 bool isRefresh = false;
446 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
447 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
448 }
449
450 /**
451 * @tc.name: ShiftLNNGear_005
452 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to false; Return DM_OK
453 * @tc.type: FUNC
454 * @tc.require: AR000GHSJK
455 */
456 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_005, testing::ext::TestSize.Level0)
457 {
458 std::string pkgName = "com.ohos.test";
459 std::string callerId = "com.ohos.test";
460 bool isRefresh = false;
461 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
462 EXPECT_EQ(ret, DM_OK);
463 }
464
465 /**
466 * @tc.name: ShiftLNNGear_006
467 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return NOT DM_OK
468 * @tc.type: FUNC
469 * @tc.require: AR000GHSJK
470 */
471 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_006, testing::ext::TestSize.Level0)
472 {
473 std::string pkgName = "ShiftLNNGear_006";
474 std::string callerId = "ShiftLNNGear_006";
475 bool isRefresh = true;
476 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
477 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
478 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
479 }
480
481 /**
482 * @tc.name: ShiftLNNGear_007
483 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return NOT DM_OK
484 * @tc.type: FUNC
485 * @tc.require: AR000GHSJK
486 */
487 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_007, testing::ext::TestSize.Level0)
488 {
489 std::string pkgName = "ShiftLNNGear_007";
490 std::string callerId = "ShiftLNNGear_007";
491 bool isRefresh = true;
492 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
493 EXPECT_CALL(*softbusListenerMock_, ShiftLNNGear(_, _)).WillOnce(Return(ERR_DM_FAILED));
494 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
495 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
496 EXPECT_EQ(ret, ERR_DM_FAILED);
497 }
498
499 /**
500 * @tc.name: AuthenticateDevice_001
501 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_INPUT_PARA_INVALID
502 * @tc.type: FUNC
503 * @tc.require: AR000GHSJK
504 */
505 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
506 {
507 std::string pkgName = "com.ohos.test";
508 std::string extra = "jdddd";
509 int32_t authType = 1;
510 std::string deviceId;
511 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
512 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
513 }
514
515 /**
516 * @tc.name: AuthenticateDevice_002
517 * @tc.desc: Set intFlag for GAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
518 * @tc.type: FUNC
519 * @tc.require: AR000GHSJK
520 */
521 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
522 {
523 std::string pkgName;
524 std::string extra = "jdddd";
525 int32_t authType = 0;
526 std::string deviceId = " 2345";
527 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
528 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
529 }
530
531 /**
532 * @tc.name: AuthenticateDevice_003
533 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_BIND_INPUT_PARA_INVALID
534 * @tc.type: FUNC
535 * @tc.require: AR000GHSJK
536 */
537 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
538 {
539 std::string pkgName = "com.ohos.test";
540 std::string extra = "jdddd";
541 int32_t authType = 0;
542 std::string deviceId = " 2345";
543 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
544 EXPECT_CALL(*softbusListenerMock_,
545 GetTargetInfoFromCache(_, _, _)).WillOnce(Return(ERR_DM_BIND_INPUT_PARA_INVALID));
546 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
547 EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID);
548 }
549
550 /**
551 * @tc.name: AuthenticateDevice_004
552 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_NO_PERMISSION
553 * @tc.type: FUNC
554 * @tc.require: AR000GHSJK
555 */
556 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_004, testing::ext::TestSize.Level0)
557 {
558 std::string pkgName = "com.ohos.test";
559 std::string extra = "jdddd";
560 int32_t authType = 0;
561 std::string deviceId = " 2345";
562 DeletePermission();
563 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
564 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
565 }
566
567 /**
568 * @tc.name: UnAuthenticateDevice_001
569 * @tc.desc: 将UnAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";Return ERR_DM_NO_PERMISSION
570 * @tc.type: FUNC
571 * @tc.require: AR000GHSJK
572 */
573 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
574 {
575 DeletePermission();
576 std::string pkgName = "com.ohos.test";
577 std::string networkId = "12345";
578 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
579 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
580 }
581
582 /**
583 * @tc.name: UnAuthenticateDevice_002
584 * @tc.desc: Set intFlag for UnAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID
585 * @tc.type: FUNC
586 * @tc.require: AR000GHSJK
587 */
588 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
589 {
590 std::string pkgName;
591 std::string networkId = "12345";
592 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
593 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
594 }
595
596 /**
597 * @tc.name: UnAuthenticateDevice_003
598 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
599 * value is ERR_DM_INPUT_PARA_INVALID
600 * @tc.type: FUNC
601 * @tc.require: AR000GHSJK
602 */
603 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
604 {
605 std::string pkgName = "com.ohos.test";
606 std::string networkId;
607 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
608 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
609 }
610
611 /**
612 * @tc.name: UnAuthenticateDevice_004
613 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
614 * value is SOFTBUS_IPC_ERR
615 * @tc.type: FUNC
616 * @tc.require: AR000GHSJK
617 */
618 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
619 {
620 std::string pkgName = "com.ohos.test";
621 std::string networkId = "12345";
622 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
623 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
624 EXPECT_EQ(ret, ERR_DM_FAILED);
625 }
626
627 /**
628 * @tc.name: GetUdidByNetworkId_001
629 * @tc.desc: Make success for GetUdidByNetworkId，The return value is
630 * SOFTBUS_IPC_ERR
631 * @tc.type: FUNC
632 * @tc.require: AR000GHSJK
633 */
634 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0)
635 {
636 std::string pkgName = "com.ohos.test";
637 std::string netWorkId = "123";
638 std::string udid = "123";
639 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(SOFTBUS_IPC_ERR));
640 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
641 EXPECT_EQ(ret, SOFTBUS_IPC_ERR);
642 }
643
644 /**
645 * @tc.name: GetUdidByNetworkId_002
646 * @tc.desc: Make not init for GetUdidByNetworkId，The return value is
647 * ERR_DM_INPUT_PARA_INVALID
648 * @tc.type: FUNC
649 * @tc.require: AR000GHSJK
650 */
651 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0)
652 {
653 std::string pkgName;
654 std::string netWorkId = "111";
655 std::string udid = "2222";
656 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
657 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
658 }
659
660 /**
661 * @tc.name: GetUdidByNetworkId_003
662 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is
663 * ERR_DM_INPUT_PARA_INVALID
664 * @tc.type: FUNC
665 * @tc.require: AR000GHSJK
666 */
667 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0)
668 {
669 std::string pkgName = "pkgName";
670 std::string netWorkId = "";
671 std::string udid = "";
672 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
673 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
674 }
675
676 /**
677 * @tc.name: GetUdidByNetworkId_004
678 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is
679 * ERR_DM_INPUT_PARA_INVALID
680 * @tc.type: FUNC
681 * @tc.require: AR000GHSJK
682 */
683 HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0)
684 {
685 std::string pkgName = "pkgName";
686 std::string netWorkId = "123";
687 std::string udid = "123";
688 DeletePermission();
689 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
690 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
691 }
692
693 /**
694 * @tc.name: GetUuidByNetworkId_001
695 * @tc.desc: Make success for GetUuidByNetworkId，The return value is
696 * SOFTBUS_IPC_ERR
697 * @tc.type: FUNC
698 * @tc.require: AR000GHSJK
699 */
700 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0)
701 {
702 std::string pkgName = "com.ohos.test";
703 std::string netWorkId = "12";
704 std::string uuid = "12";
705 EXPECT_CALL(*softbusListenerMock_, GetUuidByNetworkId(_, _)).WillOnce(Return(SOFTBUS_IPC_ERR));
706 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
707 EXPECT_EQ(ret, SOFTBUS_IPC_ERR);
708 }
709
710 /**
711 * @tc.name: GetUuidByNetworkId_002
712 * @tc.desc: Make not init for GetUuidByNetworkId，The return value is
713 * ERR_DM_INPUT_PARA_INVALID
714 * @tc.type: FUNC
715 * @tc.require: AR000GHSJK
716 */
717 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0)
718 {
719 std::string pkgName;
720 std::string netWorkId = "12";
721 std::string uuid = "21";
722 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
723 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
724 }
725
726 /**
727 * @tc.name: GetUuidByNetworkId_003
728 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is
729 * ERR_DM_INPUT_PARA_INVALID
730 * @tc.type: FUNC
731 * @tc.require: AR000GHSJK
732 */
733 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0)
734 {
735 std::string pkgName = "com.ohos.test";
736 std::string netWorkId = "";
737 std::string uuid = "";
738 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
739 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
740 }
741
742 /**
743 * @tc.name: GetUuidByNetworkId_004
744 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is
745 * ERR_DM_INPUT_PARA_INVALID
746 * @tc.type: FUNC
747 * @tc.require: AR000GHSJK
748 */
749 HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0)
750 {
751 std::string pkgName = "com.ohos.test";
752 std::string netWorkId = "";
753 std::string uuid = "";
754 DeletePermission();
755 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
756 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
757 }
758
759 /**
760 * @tc.name: SetUserOperation_001
761 * @tc.desc: Make success for SetUserOperation，The return value is
762 * ERR_DM_NO_PERMISSION
763 * @tc.type: FUNC
764 * @tc.require: AR000GHSJK
765 */
766 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_001, testing::ext::TestSize.Level0)
767 {
768 DeletePermission();
769 std::string pkgName = "com.ohos.test";
770 int32_t action = 0;
771 const std::string param = "extra";
772 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
773 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
774 }
775
776 /**
777 * @tc.name: SetUserOperation_002
778 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
779 * ERR_DM_INPUT_PARA_INVALID
780 * @tc.type: FUNC
781 * @tc.require: AR000GHSJK
782 */
783 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_002, testing::ext::TestSize.Level0)
784 {
785 std::string pkgName = "";
786 int32_t action = 0;
787 const std::string param = "extra";
788 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
789 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
790 }
791
792 /**
793 * @tc.name: SetUserOperation_003
794 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
795 * ERR_DM_INPUT_PARA_INVALID
796 * @tc.type: FUNC
797 * @tc.require: AR000GHSJK
798 */
799 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_003, testing::ext::TestSize.Level0)
800 {
801 std::string pkgName = "pkgName";
802 int32_t action = 0;
803 const std::string param;
804 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
805 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
806 }
807
808 /**
809 * @tc.name: SetUserOperation_004
810 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
811 * DM_OK
812 * @tc.type: FUNC
813 * @tc.require: AR000GHSJK
814 */
815 HWTEST_F(DeviceManagerServiceTest, SetUserOperation_004, testing::ext::TestSize.Level0)
816 {
817 std::string pkgName = "pkgName";
818 int32_t action = 0;
819 const std::string param = "extra";
820 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
821 EXPECT_EQ(ret, DM_OK);
822 }
823
824 /**
825 * @tc.name: GetLocalDeviceInfo_001
826 * @tc.desc: The return value is DM_OK
827 * @tc.type: FUNC
828 * @tc.require: AR000GHSJK
829 */
830 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0)
831 {
832 DmDeviceInfo info;
833 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
834 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
835 EXPECT_EQ(ret, DM_OK);
836 }
837
838 /**
839 * @tc.name: RequestCredential_001
840 * @tc.desc:The return value is ERR_DM_FAILED
841 * @tc.type: FUNC
842 * @tc.require: AR000GHSJK
843 */
844 HWTEST_F(DeviceManagerServiceTest, RequestCredential_001, testing::ext::TestSize.Level0)
845 {
846 const std::string reqJsonStr = "test";
847 std::string returnJsonStr = "returntest";
848 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
849 EXPECT_EQ(ret, ERR_DM_FAILED);
850 }
851
852 /**
853 * @tc.name: RequestCredential_002
854 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
855 * @tc.type: FUNC
856 * @tc.require: AR000GHSJK
857 */
858 HWTEST_F(DeviceManagerServiceTest, RequestCredential_002, testing::ext::TestSize.Level0)
859 {
860 const std::string reqJsonStr = "";
861 std::string returnJsonStr = "returntest";
862 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
863 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
864 }
865
866 /**
867 * @tc.name: RequestCredential_003
868 * @tc.desc:The return value is ERR_DM_FAILED
869 * @tc.type: FUNC
870 * @tc.require: AR000GHSJK
871 */
872 HWTEST_F(DeviceManagerServiceTest, RequestCredential_003, testing::ext::TestSize.Level0)
873 {
874 const std::string reqJsonStr = "test";
875 std::string returnJsonStr = "returntest";
876 DeletePermission();
877 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
878 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
879 }
880
881 /**
882 * @tc.name: ImportCredential_001
883 * @tc.desc:The return value is ERR_DM_FAILED
884 * @tc.type: FUNC
885 * @tc.require: AR000GHSJK
886 */
887 HWTEST_F(DeviceManagerServiceTest, ImportCredential_001, testing::ext::TestSize.Level0)
888 {
889 const std::string pkgName = "pkgNametest";
890 const std::string credentialInfo = "credentialInfotest";
891 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
892 EXPECT_EQ(ret, ERR_DM_FAILED);
893 }
894
895 /**
896 * @tc.name: ImportCredential_002
897 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
898 * @tc.type: FUNC
899 * @tc.require: AR000GHSJK
900 */
901 HWTEST_F(DeviceManagerServiceTest, ImportCredential_002, testing::ext::TestSize.Level0)
902 {
903 const std::string pkgName = "";
904 const std::string credentialInfo = "";
905 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
906 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
907 }
908
909 /**
910 * @tc.name: ImportCredential_003
911 * @tc.desc:The return value is ERR_DM_FAILED
912 * @tc.type: FUNC
913 * @tc.require: AR000GHSJK
914 */
915 HWTEST_F(DeviceManagerServiceTest, ImportCredential_003, testing::ext::TestSize.Level0)
916 {
917 const std::string pkgName = "pkgNametest";
918 const std::string credentialInfo = "credentialInfotest";
919 DeletePermission();
920 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
921 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
922 }
923
924 /**
925 * @tc.name: DeleteCredential_001
926 * @tc.desc:The return value is ERR_DM_FAILED
927 * @tc.type: FUNC
928 * @tc.require: AR000GHSJK
929 */
930 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_001, testing::ext::TestSize.Level0)
931 {
932 const std::string pkgName = "pkgNametest";
933 const std::string deleteInfo = "deleteInfotest";
934 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
935 EXPECT_EQ(ret, ERR_DM_FAILED);
936 }
937
938 /**
939 * @tc.name: DeleteCredential_002
940 * @tc.desc:The return value is ERR_DM_NO_PERMISSION
941 * @tc.type: FUNC
942 * @tc.require: AR000GHSJK
943 */
944 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_002, testing::ext::TestSize.Level0)
945 {
946 const std::string pkgName = "pkgNametest";
947 const std::string deleteInfo = "deleteInfotest";
948 DeletePermission();
949 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
950 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
951 }
952
953 /**
954 * @tc.name: DeleteCredential_003
955 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
956 * @tc.type: FUNC
957 * @tc.require: AR000GHSJK
958 */
959 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_003, testing::ext::TestSize.Level0)
960 {
961 const std::string pkgName = "";
962 const std::string deleteInfo = "";
963 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
964 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
965 }
966
967 /**
968 * @tc.name: RegisterCredentialCallback_001
969 * @tc.desc: The return value is DM_OK
970 * @tc.type: FUNC
971 * @tc.require: AR000GHSJK
972 */
973 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
974 {
975 const std::string pkgName = "pkgNametest";
976 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
977 EXPECT_EQ(ret, DM_OK);
978 }
979
980 /**
981 * @tc.name: RegisterCredentialCallback_002
982 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
983 * @tc.type: FUNC
984 * @tc.require: AR000GHSJK
985 */
986 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
987 {
988 const std::string pkgName = "";
989 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
990 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
991 }
992
993 /**
994 * @tc.name: RegisterCredentialCallback_003
995 * @tc.desc: The return value is ERR_DM_NO_PERMISSION
996 * @tc.type: FUNC
997 * @tc.require: AR000GHSJK
998 */
999 HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0)
1000 {
1001 const std::string pkgName = "pkgNametest";
1002 DeletePermission();
1003 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
1004 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1005 }
1006
1007 /**
1008 * @tc.name: UnRegisterCredentialCallback_001
1009 * @tc.desc:The return value is DM_OK
1010 * @tc.type: FUNC
1011 * @tc.require: AR000GHSJK
1012 */
1013 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
1014 {
1015 const std::string pkgName = "pkgNametest";
1016 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
1017 EXPECT_EQ(ret, DM_OK);
1018 }
1019
1020 /**
1021 * @tc.name: UnRegisterCredentialCallback_002
1022 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID
1023 * @tc.type: FUNC
1024 * @tc.require: AR000GHSJK
1025 */
1026 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
1027 {
1028 const std::string pkgName = "";
1029 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
1030 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1031 }
1032
1033 /**
1034 * @tc.name: UnRegisterCredentialCallback_003
1035 * @tc.desc:The return value is ERR_DM_NO_PERMISSION
1036 * @tc.type: FUNC
1037 * @tc.require: AR000GHSJK
1038 */
1039 HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0)
1040 {
1041 const std::string pkgName = "pkgNametest";
1042 DeletePermission();
1043 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName);
1044 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1045 }
1046
1047 /**
1048 * @tc.name: UninitSoftbusListener_001
1049 * @tc.desc: DeviceManagerService::GetInstance().softbusListener_ is nullptr
1050 * @tc.type: FUNC
1051 * @tc.require: AR000GHSJK
1052 */
1053 HWTEST_F(DeviceManagerServiceTest, UninitSoftbusListener_001, testing::ext::TestSize.Level0)
1054 {
1055 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1056 DeviceManagerService::GetInstance().UninitSoftbusListener();
1057 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1058 }
1059
1060 /**
1061 * @tc.name: UninitDMServiceListener_001
1062 * @tc.desc: DeviceManagerService::GetInstance().listener_ is nullptr
1063 * @tc.type: FUNC
1064 * @tc.require: AR000GHSJK
1065 */
1066 HWTEST_F(DeviceManagerServiceTest, UninitDMServiceListener_001, testing::ext::TestSize.Level0)
1067 {
1068 DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>();
1069 DeviceManagerService::GetInstance().UninitDMServiceListener();
1070 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
1071 }
1072
1073 /**
1074 * @tc.name: IsDMServiceImplReady_001
1075 * @tc.desc: The return value is true
1076 * @tc.type: FUNC
1077 * @tc.require: AR000GHSJK
1078 */
1079 HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplReady_001, testing::ext::TestSize.Level0)
1080 {
1081 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1082 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplReady();
1083 EXPECT_EQ(ret, true);
1084 }
1085
1086 /**
1087 * @tc.name: GetDeviceInfo_001
1088 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID
1089 * @tc.type: FUNC
1090 * @tc.require: AR000GHSJK
1091 */
1092 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_001, testing::ext::TestSize.Level0)
1093 {
1094 std::string networkId = "";
1095 DmDeviceInfo info;
1096 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info);
1097 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1098 }
1099
1100 /**
1101 * @tc.name: GetDeviceInfo_002
1102 * @tc.desc: The return value is DM_OK
1103 * @tc.type: FUNC
1104 * @tc.require: AR000GHSJK
1105 */
1106 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_002, testing::ext::TestSize.Level0)
1107 {
1108 std::string networkId = "networkIdTest";
1109 DmDeviceInfo info;
1110 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info);
1111 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1112 }
1113
1114 /**
1115 * @tc.name: GetDeviceInfo_004
1116 * @tc.desc: The return value is DM_OK
1117 * @tc.type: FUNC
1118 * @tc.require: AR000GHSJK
1119 */
1120 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_004, testing::ext::TestSize.Level0)
1121 {
1122 std::string networkId = "networkIdTest4";
1123 DmDeviceInfo info;
1124 DeletePermission();
1125 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info);
1126 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1127 }
1128
1129 /**
1130 * @tc.name: CheckApiPermission_001
1131 * @tc.desc: The return value is DM_OK
1132 * @tc.type: FUNC
1133 */
1134 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_001, testing::ext::TestSize.Level0)
1135 {
1136 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(0);
1137 EXPECT_EQ(ret, DM_OK);
1138 }
1139
1140 /**
1141 * @tc.name: RegisterCallerAppId_001
1142 * @tc.desc: Set pkgName null
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(DeviceManagerServiceTest, RegisterCallerAppId_001, testing::ext::TestSize.Level0)
1146 {
1147 std::string pkgName;
1148 DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName);
1149 EXPECT_NE(DeviceManagerService::GetInstance().listener_, nullptr);
1150 }
1151
1152 /**
1153 * @tc.name: RegisterCallerAppId_002
1154 * @tc.desc: Set pkgName null
1155 * @tc.type: FUNC
1156 */
1157 HWTEST_F(DeviceManagerServiceTest, RegisterCallerAppId_002, testing::ext::TestSize.Level0)
1158 {
1159 std::string pkgName;
1160 DeviceManagerService::GetInstance().listener_ = nullptr;
1161 DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName);
1162 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
1163 }
1164
1165 /**
1166 * @tc.name: UnRegisterDeviceManagerListener_001
1167 * @tc.desc: Set pkgName null
1168 * @tc.type: FUNC
1169 */
1170 HWTEST_F(DeviceManagerServiceTest, UnRegisterCallerAppId_001, testing::ext::TestSize.Level0)
1171 {
1172 std::string pkgName;
1173 DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName);
1174 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
1175 }
1176
1177 /**
1178 * @tc.name: UnRegisterDeviceManagerListener_002
1179 * @tc.desc: Set pkgName null
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(DeviceManagerServiceTest, UnRegisterCallerAppId_002, testing::ext::TestSize.Level0)
1183 {
1184 std::string pkgName;
1185 DeviceManagerService::GetInstance().listener_ = nullptr;
1186 DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName);
1187 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
1188 }
1189
1190 HWTEST_F(DeviceManagerServiceTest, BindDevice_001, testing::ext::TestSize.Level0)
1191 {
1192 std::string pkgName;
1193 int32_t authType = 1;
1194 std::string deviceId;
1195 std::string bindParam;
1196 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1197 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1198 }
1199
1200 HWTEST_F(DeviceManagerServiceTest, BindDevice_002, testing::ext::TestSize.Level0)
1201 {
1202 std::string pkgName = "com.ohos.test";
1203 int32_t authType = 1;
1204 std::string deviceId;
1205 std::string bindParam;
1206 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1207 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1208 }
1209
1210 HWTEST_F(DeviceManagerServiceTest, BindDevice_003, testing::ext::TestSize.Level0)
1211 {
1212 std::string pkgName = "com.ohos.test";
1213 int32_t authType = 1;
1214 std::string deviceId = "1234";
1215 std::string bindParam;
1216 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
1217 EXPECT_CALL(*softbusListenerMock_,
1218 GetTargetInfoFromCache(_, _, _)).WillOnce(Return(ERR_DM_BIND_INPUT_PARA_INVALID));
1219 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1220 EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID);
1221 }
1222
1223 HWTEST_F(DeviceManagerServiceTest, BindDevice_004, testing::ext::TestSize.Level0)
1224 {
1225 std::string pkgName = "com.ohos.test";
1226 int32_t authType = 1;
1227 std::string deviceId = "1234";
1228 std::string bindParam;
1229 DeletePermission();
1230 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
1231 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1232 }
1233
1234 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_001, testing::ext::TestSize.Level0)
1235 {
1236 std::string pkgName = "com.ohos.test";
1237 std::string deviceId = "1234";
1238 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1239 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
1240 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(ERR_DM_FAILED));
1241 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1242 EXPECT_EQ(ret, ERR_DM_FAILED);
1243 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1244 }
1245
1246 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_002, testing::ext::TestSize.Level0)
1247 {
1248 std::string pkgName = "com.ohos.test";
1249 std::string deviceId;
1250 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1251 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1252 }
1253
1254 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_003, testing::ext::TestSize.Level0)
1255 {
1256 std::string pkgName;
1257 std::string deviceId = "1234";
1258 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1259 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1260 }
1261
1262 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_004, testing::ext::TestSize.Level0)
1263 {
1264 std::string pkgName = "com.ohos.test";
1265 std::string deviceId = "1234";
1266 DeletePermission();
1267 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
1268 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1269 }
1270
1271 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_005, testing::ext::TestSize.Level0)
1272 {
1273 std::string pkgName = "com.ohos.test";
1274 std::string deviceId = "1234";
1275 std::string extra = "extra";
1276 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1277 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
1278 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(ERR_DM_FAILED));
1279 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
1280 EXPECT_EQ(ret, ERR_DM_FAILED);
1281 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1282 }
1283
1284 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_006, testing::ext::TestSize.Level0)
1285 {
1286 std::string pkgName = "com.ohos.test";
1287 std::string deviceId;
1288 std::string extra = "extra";
1289 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
1290 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1291 }
1292
1293 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_007, testing::ext::TestSize.Level0)
1294 {
1295 std::string pkgName;
1296 std::string deviceId = "1234";
1297 std::string extra = "extra";
1298 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
1299 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1300 }
1301
1302 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_008, testing::ext::TestSize.Level0)
1303 {
1304 std::string pkgName = "com.ohos.test";
1305 std::string deviceId = "1234";
1306 std::string extra = "extra";
1307 DeletePermission();
1308 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
1309 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1310 }
1311
1312 HWTEST_F(DeviceManagerServiceTest, OnSessionOpened_001, testing::ext::TestSize.Level0)
1313 {
1314 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1315 int sessionId = 0;
1316 int result = 0;
1317 void *data = nullptr;
1318 unsigned int dataLen = 0;
1319 int ret = DeviceManagerService::GetInstance().OnSessionOpened(sessionId, result);
1320 DeviceManagerService::GetInstance().OnBytesReceived(sessionId, data, dataLen);
1321 DeviceManagerService::GetInstance().OnSessionClosed(sessionId);
1322 EXPECT_NE(ret, ERR_DM_NOT_INIT);
1323 }
1324
1325 HWTEST_F(DeviceManagerServiceTest, OnPinHolderSessionOpened_001, testing::ext::TestSize.Level0)
1326 {
1327 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1328 int sessionId = 0;
1329 int result = 0;
1330 void *data = nullptr;
1331 unsigned int dataLen = 0;
1332 int ret = DeviceManagerService::GetInstance().OnPinHolderSessionOpened(sessionId, result);
1333 DeviceManagerService::GetInstance().OnPinHolderBytesReceived(sessionId, data, dataLen);
1334 DeviceManagerService::GetInstance().OnPinHolderSessionClosed(sessionId);
1335 EXPECT_NE(ret, DM_OK);
1336 }
1337
1338 HWTEST_F(DeviceManagerServiceTest, MineRequestCredential_001, testing::ext::TestSize.Level0)
1339 {
1340 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1341 std::string pkgName;
1342 std::string returnJsonStr;
1343 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr);
1344 EXPECT_EQ(ret, DM_OK);
1345 }
1346
1347 HWTEST_F(DeviceManagerServiceTest, MineRequestCredential_002, testing::ext::TestSize.Level0)
1348 {
1349 std::string pkgName;
1350 std::string returnJsonStr;
1351 DeletePermission();
1352 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr);
1353 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1354 }
1355
1356 HWTEST_F(DeviceManagerServiceTest, CheckCredential_001, testing::ext::TestSize.Level0)
1357 {
1358 std::string pkgName;
1359 std::string returnJsonStr;
1360 std::string reqJsonStr;
1361 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1362 EXPECT_NE(ret, DM_OK);
1363 }
1364
1365 HWTEST_F(DeviceManagerServiceTest, CheckCredential_002, testing::ext::TestSize.Level0)
1366 {
1367 DeletePermission();
1368 std::string pkgName;
1369 std::string returnJsonStr;
1370 std::string reqJsonStr;
1371 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1372 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1373 }
1374
1375 HWTEST_F(DeviceManagerServiceTest, ImportCredential_004, testing::ext::TestSize.Level0)
1376 {
1377 DeletePermission();
1378 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1379 std::string pkgName;
1380 std::string returnJsonStr;
1381 std::string reqJsonStr;
1382 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1383 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1384 }
1385
1386 HWTEST_F(DeviceManagerServiceTest, ImportCredential_005, testing::ext::TestSize.Level0)
1387 {
1388 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1389 std::string pkgName;
1390 std::string returnJsonStr;
1391 std::string reqJsonStr;
1392 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1393 EXPECT_NE(ret, DM_OK);
1394 }
1395
1396 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_004, testing::ext::TestSize.Level0)
1397 {
1398 DeletePermission();
1399 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1400 std::string pkgName;
1401 std::string returnJsonStr;
1402 std::string reqJsonStr;
1403 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1404 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1405 }
1406
1407 HWTEST_F(DeviceManagerServiceTest, DeleteCredential_005, testing::ext::TestSize.Level0)
1408 {
1409 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1410 std::string pkgName;
1411 std::string returnJsonStr;
1412 std::string reqJsonStr;
1413 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
1414 EXPECT_NE(ret, DM_OK);
1415 }
1416
1417 HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level0)
1418 {
1419 std::string pkgName;
1420 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
1421 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1422 }
1423
1424 HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level0)
1425 {
1426 std::string pkgName = "pkgName";
1427 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
1428 EXPECT_EQ(ret, DM_OK);
1429 }
1430
1431 HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_003, testing::ext::TestSize.Level0)
1432 {
1433 std::string pkgName = "pkgName";
1434 DeletePermission();
1435 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
1436 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1437 }
1438
1439 HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level0)
1440 {
1441 std::string pkgName;
1442 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
1443 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1444 }
1445
1446 HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level0)
1447 {
1448 std::string pkgName = "pkgName";
1449 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
1450 EXPECT_EQ(ret, DM_OK);
1451 }
1452
1453 HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_003, testing::ext::TestSize.Level0)
1454 {
1455 std::string pkgName = "pkgName";
1456 DeletePermission();
1457 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
1458 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1459 }
1460
1461
1462 HWTEST_F(DeviceManagerServiceTest, IsDMImplSoLoaded_001, testing::ext::TestSize.Level0)
1463 {
1464 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1465 bool ret = DeviceManagerService::GetInstance().IsDMImplSoLoaded();
1466 EXPECT_FALSE(ret);
1467 }
1468
1469 HWTEST_F(DeviceManagerServiceTest, DmHiDumper_001, testing::ext::TestSize.Level0)
1470 {
1471 std::vector<std::string> args;
1472 std::string result;
1473 int32_t ret = DeviceManagerService::GetInstance().DmHiDumper(args, result);
1474 EXPECT_EQ(ret, DM_OK);
1475 }
1476
1477 HWTEST_F(DeviceManagerServiceTest, NotifyEvent_001, testing::ext::TestSize.Level0)
1478 {
1479 std::string pkgName;
1480 int32_t eventId = 0;
1481 std::string event;
1482 std::string msg = "";
1483 DeviceManagerService::GetInstance().HandleDeviceNotTrust(msg);
1484 msg = R"(
1485 {
1486 "authType" : 1,
1487 "userId" : "123",
1488 "credentialData" : "cryptosupportData",
1489 "CRYPTOSUPPORT" : "cryptosupportTest",
1490 "credentialType" : 1,
1491 "credentialId" : "104",
1492 "NETWORK_ID" : "108",
1493 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
1494 "serverPk" : "hello",
1495 "pkInfoSignature" : "world",
1496 "pkInfo" : "pkginfo",
1497 "peerDeviceId" : "3515656546"
1498 })";
1499 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(Return(DM_OK));
1500 DeviceManagerService::GetInstance().HandleDeviceNotTrust(msg);
1501 std::string commonEventType = "helloworld";
1502 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1503 DeviceManagerService::GetInstance().ScreenCommonEventCallback(commonEventType);
1504 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
1505 EXPECT_NE(ret, DM_OK);
1506 }
1507
1508 HWTEST_F(DeviceManagerServiceTest, NotifyEvent_002, testing::ext::TestSize.Level0)
1509 {
1510 DeletePermission();
1511 std::string pkgName;
1512 int32_t eventId = 0;
1513 std::string event;
1514 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
1515 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1516 }
1517
1518 HWTEST_F(DeviceManagerServiceTest, NotifyEvent_003, testing::ext::TestSize.Level0)
1519 {
1520 std::string pkgName;
1521 int32_t eventId = DM_NOTIFY_EVENT_ON_PINHOLDER_EVENT;
1522 std::string event;
1523 DeviceManagerService::GetInstance().InitDMServiceListener();
1524 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
1525 EXPECT_EQ(ret, ERR_DM_FAILED);
1526 DeviceManagerService::GetInstance().UninitDMServiceListener();
1527 }
1528
1529 HWTEST_F(DeviceManagerServiceTest, LoadHardwareFwkService_001, testing::ext::TestSize.Level0)
1530 {
1531 DeviceManagerService::GetInstance().LoadHardwareFwkService();
1532 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1533 }
1534
1535 HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_001, testing::ext::TestSize.Level0)
1536 {
1537 std::string pkgName;
1538 std::string networkId;
1539 std::string uuid;
1540 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid);
1541 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1542 }
1543
1544 HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_002, testing::ext::TestSize.Level0)
1545 {
1546 std::string pkgName = "pkgName";
1547 std::string networkId;
1548 std::string uuid;
1549 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid);
1550 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1551 }
1552
1553 HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_003, testing::ext::TestSize.Level0)
1554 {
1555 std::string pkgName = "pkgName";
1556 std::string networkId = "network_id";
1557 std::string uuid = "13345689";
1558 if (DeviceManagerService::GetInstance().softbusListener_ == nullptr) {
1559 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1560 }
1561 EXPECT_CALL(*softbusListenerMock_, GetUuidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
1562 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid);
1563 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1564 EXPECT_EQ(ret, ERR_DM_FAILED);
1565 }
1566
1567 HWTEST_F(DeviceManagerServiceTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0)
1568 {
1569 std::string pkgName;
1570 std::string uuid;
1571 std::string appId;
1572 std::string encryptedUuid;
1573 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1574 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1575 }
1576
1577 HWTEST_F(DeviceManagerServiceTest, GenerateEncryptedUuid_002, testing::ext::TestSize.Level0)
1578 {
1579 std::string pkgName = "pkgName";
1580 std::string uuid;
1581 std::string appId;
1582 std::string encryptedUuid;
1583 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
1584 EXPECT_EQ(ret, DM_OK);
1585 }
1586
1587 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_002, testing::ext::TestSize.Level0)
1588 {
1589 DeletePermission();
1590 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(0);
1591 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1592 }
1593
1594 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_003, testing::ext::TestSize.Level0)
1595 {
1596 DeletePermission();
1597 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(1);
1598 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1599 }
1600
1601 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_004, testing::ext::TestSize.Level0)
1602 {
1603 DeletePermission();
1604 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(2);
1605 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1606 }
1607
1608 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_005, testing::ext::TestSize.Level0)
1609 {
1610 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(1);
1611 EXPECT_EQ(ret, DM_OK);
1612 }
1613
1614 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_006, testing::ext::TestSize.Level0)
1615 {
1616 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(2);
1617 EXPECT_NE(ret, ERR_DM_FAILED);
1618 }
1619
1620 HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_007, testing::ext::TestSize.Level0)
1621 {
1622 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(3);
1623 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1624 }
1625
1626 HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0)
1627 {
1628 DeletePermission();
1629 std::string pkgName;
1630 std::string netWorkId;
1631 int32_t networkType = 0;
1632 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType);
1633 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1634 }
1635
1636 HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_002, testing::ext::TestSize.Level0)
1637 {
1638 std::string pkgName;
1639 std::string netWorkId;
1640 int32_t networkType = 0;
1641 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType);
1642 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1643 }
1644
1645 HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_003, testing::ext::TestSize.Level0)
1646 {
1647 std::string pkgName = "pkgName";
1648 std::string netWorkId = "netWorkId";
1649 int32_t networkType = 0;
1650 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType);
1651 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1652 }
1653
1654 HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_004, testing::ext::TestSize.Level0)
1655 {
1656 std::string pkgName = "pkgName";
1657 std::string netWorkId = "netWorkId";
1658 int32_t networkType = 0;
1659 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1660 EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _)).Times(::testing::AtLeast(2))
1661 .WillOnce(Return(ERR_DM_FAILED));
1662 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType);
1663 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1664 EXPECT_EQ(ret, ERR_DM_FAILED);
1665 }
1666
1667 HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
1668 {
1669 DeletePermission();
1670 std::string pkgName;
1671 std::string authCode;
1672 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
1673 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1674 }
1675
1676 HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_002, testing::ext::TestSize.Level0)
1677 {
1678 std::string pkgName = "pkgName";
1679 std::string authCode = "authCode";
1680 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1681 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(false));
1682 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
1683 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1684 }
1685
1686 HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_001, testing::ext::TestSize.Level0)
1687 {
1688 DeletePermission();
1689 std::string authCode;
1690 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
1691 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1692 }
1693
1694 HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_002, testing::ext::TestSize.Level0)
1695 {
1696 std::string authCode = "authCode";
1697 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1698 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(false));
1699 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
1700 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1701 }
1702
1703 HWTEST_F(DeviceManagerServiceTest, UnloadDMServiceImplSo_001, testing::ext::TestSize.Level0)
1704 {
1705 DeviceManagerService::GetInstance().UnloadDMServiceImplSo();
1706 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1707 }
1708
1709 HWTEST_F(DeviceManagerServiceTest, StartDiscovering_001, testing::ext::TestSize.Level0)
1710 {
1711 DeletePermission();
1712 std::string pkgName;
1713 std::map<std::string, std::string> discoverParam;
1714 std::map<std::string, std::string> filterOptions;
1715 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
1716 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1717 }
1718
1719 HWTEST_F(DeviceManagerServiceTest, StartDiscovering_002, testing::ext::TestSize.Level0)
1720 {
1721 std::string pkgName;
1722 std::map<std::string, std::string> discoverParam;
1723 std::map<std::string, std::string> filterOptions;
1724 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
1725 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1726 }
1727
1728 HWTEST_F(DeviceManagerServiceTest, StartDiscovering_003, testing::ext::TestSize.Level0)
1729 {
1730 std::string pkgName = "pkgName";
1731 std::map<std::string, std::string> discoverParam;
1732 std::map<std::string, std::string> filterOptions;
1733 DeviceManagerService::GetInstance().InitDMServiceListener();
1734 EXPECT_CALL(*softbusListenerMock_, StopRefreshSoftbusLNN(_)).Times(::testing::AtLeast(1))
1735 .WillOnce(Return(SOFTBUS_NETWORK_NOT_INIT));
1736 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
1737 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL);
1738 ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
1739 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
1740 DeviceManagerService::GetInstance().UninitDMServiceListener();
1741 }
1742
1743 HWTEST_F(DeviceManagerServiceTest, StartDiscovering_004, testing::ext::TestSize.Level0)
1744 {
1745 std::string pkgName = "pkgName";
1746 std::map<std::string, std::string> discoverParam;
1747 discoverParam[PARAM_KEY_META_TYPE] = "metaType";
1748 discoverParam[PARAM_KEY_SUBSCRIBE_ID] = "123456";
1749 discoverParam[PARAM_KEY_DISC_MEDIUM] =
1750 std::to_string(static_cast<int32_t>(DmExchangeMedium::DM_AUTO));
1751 discoverParam[PARAM_KEY_DISC_FREQ] =
1752 std::to_string(static_cast<int32_t>(DmExchangeFreq::DM_LOW));
1753 std::map<std::string, std::string> filterOptions;
1754 DeviceManagerService::GetInstance().InitDMServiceListener();
1755 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
1756 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL);
1757 DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
1758 DeviceManagerService::GetInstance().UninitDMServiceListener();
1759 }
1760
1761 HWTEST_F(DeviceManagerServiceTest, StopDiscovering_001, testing::ext::TestSize.Level0)
1762 {
1763 DeletePermission();
1764 std::string pkgName;
1765 std::map<std::string, std::string> discoverParam;
1766 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
1767 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1768 }
1769
1770 HWTEST_F(DeviceManagerServiceTest, StopDiscovering_002, testing::ext::TestSize.Level0)
1771 {
1772 std::string pkgName;
1773 std::map<std::string, std::string> discoverParam;
1774 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
1775 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1776 }
1777
1778 HWTEST_F(DeviceManagerServiceTest, StopDiscovering_003, testing::ext::TestSize.Level0)
1779 {
1780 std::string pkgName = "pkgName";
1781 std::map<std::string, std::string> discoverParam;
1782 DeviceManagerService::GetInstance().InitDMServiceListener();
1783 EXPECT_CALL(*softbusListenerMock_, StopRefreshSoftbusLNN(_)).Times(::testing::AtLeast(1))
1784 .WillOnce(Return(SOFTBUS_NETWORK_NOT_INIT));
1785 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
1786 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
1787 DeviceManagerService::GetInstance().UninitDMServiceListener();
1788 }
1789
1790 HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_001, testing::ext::TestSize.Level0)
1791 {
1792 DeletePermission();
1793 std::string pkgName;
1794 std::map<std::string, std::string> discoverParam;
1795 std::map<std::string, std::string> filterOptions;
1796 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
1797 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1798 }
1799
1800 HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_002, testing::ext::TestSize.Level0)
1801 {
1802 std::string pkgName;
1803 std::map<std::string, std::string> discoverParam;
1804 std::map<std::string, std::string> filterOptions;
1805 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
1806 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1807 }
1808
1809 HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_003, testing::ext::TestSize.Level0)
1810 {
1811 std::string pkgName = "pkgName";
1812 std::map<std::string, std::string> discoverParam;
1813 std::map<std::string, std::string> filterOptions;
1814 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
1815 EXPECT_NE(ret, DM_OK);
1816 }
1817
1818 HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_004, testing::ext::TestSize.Level0)
1819 {
1820 std::string pkgName = "pkgName";
1821 std::map<std::string, std::string> discoverParam;
1822 std::map<std::string, std::string> filterOptions;
1823 DeviceManagerService::GetInstance().InitDMServiceListener();
1824 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
1825 EXPECT_NE(ret, DM_OK);
1826 DeviceManagerService::GetInstance().UninitDMServiceListener();
1827 }
1828
1829 HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_001, testing::ext::TestSize.Level0)
1830 {
1831 DeletePermission();
1832 std::string pkgName;
1833 std::map<std::string, std::string> extraParam;
1834 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
1835 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1836 }
1837
1838 HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_002, testing::ext::TestSize.Level0)
1839 {
1840 std::string pkgName;
1841 std::map<std::string, std::string> extraParam;
1842 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
1843 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1844 }
1845
1846 HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_003, testing::ext::TestSize.Level0)
1847 {
1848 std::string pkgName = "pkgName";
1849 std::map<std::string, std::string> extraParam;
1850 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
1851 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1852 }
1853
1854 HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_004, testing::ext::TestSize.Level0)
1855 {
1856 std::string pkgName = "pkgName";
1857 std::map<std::string, std::string> extraParam;
1858 DeviceManagerService::GetInstance().InitDMServiceListener();
1859 EXPECT_CALL(*softbusListenerMock_, StopRefreshSoftbusLNN(_)).WillOnce(Return(SOFTBUS_NETWORK_NOT_INIT));
1860 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
1861 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
1862 DeviceManagerService::GetInstance().UninitDMServiceListener();
1863 }
1864
1865 HWTEST_F(DeviceManagerServiceTest, StartAdvertising_001, testing::ext::TestSize.Level0)
1866 {
1867 DeletePermission();
1868 std::string pkgName;
1869 std::map<std::string, std::string> advertiseParam;
1870 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam);
1871 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1872 }
1873
1874 HWTEST_F(DeviceManagerServiceTest, StartAdvertising_002, testing::ext::TestSize.Level0)
1875 {
1876 std::string pkgName;
1877 std::map<std::string, std::string> advertiseParam;
1878 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam);
1879 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1880 }
1881
1882 HWTEST_F(DeviceManagerServiceTest, StartAdvertising_003, testing::ext::TestSize.Level0)
1883 {
1884 std::string pkgName = "com.ohos.test";
1885 std::map<std::string, std::string> advertiseParam;
1886 advertiseParam[PARAM_KEY_META_TYPE] = "metaType";
1887 advertiseParam[PARAM_KEY_PUBLISH_ID] = "123456";
1888 advertiseParam[PARAM_KEY_DISC_MODE] =
1889 std::to_string(static_cast<int32_t>(DmDiscoverMode::DM_DISCOVER_MODE_PASSIVE));
1890 DeviceManagerService::GetInstance().InitDMServiceListener();
1891 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam);
1892 EXPECT_NE(ret, ERR_DM_FAILED);
1893 DeviceManagerService::GetInstance().UninitDMServiceListener();
1894 }
1895
1896 HWTEST_F(DeviceManagerServiceTest, StopAdvertising_001, testing::ext::TestSize.Level0)
1897 {
1898 DeletePermission();
1899 std::string pkgName;
1900 std::map<std::string, std::string> advertiseParam;
1901 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
1902 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1903 }
1904
1905 HWTEST_F(DeviceManagerServiceTest, StopAdvertising_002, testing::ext::TestSize.Level0)
1906 {
1907 std::string pkgName;
1908 std::map<std::string, std::string> advertiseParam;
1909 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
1910 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1911 }
1912
1913 HWTEST_F(DeviceManagerServiceTest, StopAdvertising_003, testing::ext::TestSize.Level0)
1914 {
1915 std::string pkgName = "pkgName";
1916 std::map<std::string, std::string> advertiseParam;
1917 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
1918 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1919 }
1920
1921 HWTEST_F(DeviceManagerServiceTest, StopAdvertising_004, testing::ext::TestSize.Level0)
1922 {
1923 std::string pkgName = "StopAdvertising_004";
1924 std::map<std::string, std::string> advertiseParam;
1925 DeviceManagerService::GetInstance().InitDMServiceListener();
1926 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
1927 EXPECT_TRUE(ret == SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL || ret == SOFTBUS_ERR ||
1928 ret == ERR_DM_INPUT_PARA_INVALID);
1929 DeviceManagerService::GetInstance().UninitDMServiceListener();
1930 }
1931
1932 HWTEST_F(DeviceManagerServiceTest, StopAdvertising_005, testing::ext::TestSize.Level0)
1933 {
1934 std::string pkgName = "StopAdvertising_005";
1935 std::map<std::string, std::string> advertiseParam;
1936 std::string key = PARAM_KEY_META_TYPE;
1937 std::string value = "125";
1938 advertiseParam.insert(std::make_pair(key, value));
1939 key = PARAM_KEY_PUBLISH_ID;
1940 value = "128";
1941 advertiseParam.insert(std::make_pair(key, value));
1942 DeviceManagerService::GetInstance().InitDMServiceListener();
1943 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
1944 EXPECT_NE(ret, DM_OK);
1945 DeviceManagerService::GetInstance().UninitDMServiceListener();
1946 }
1947
1948 HWTEST_F(DeviceManagerServiceTest, BindTarget_004, testing::ext::TestSize.Level0)
1949 {
1950 DeletePermission();
1951 std::string pkgName;
1952 PeerTargetId targetId;
1953 std::map<std::string, std::string> bindParam;
1954 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
1955 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1956 }
1957
1958 HWTEST_F(DeviceManagerServiceTest, BindTarget_005, testing::ext::TestSize.Level0)
1959 {
1960 std::string pkgName;
1961 PeerTargetId targetId;
1962 std::map<std::string, std::string> bindParam;
1963 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
1964 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1965 }
1966
1967 HWTEST_F(DeviceManagerServiceTest, BindTarget_006, testing::ext::TestSize.Level0)
1968 {
1969 std::string pkgName = "pkgName";
1970 PeerTargetId targetId;
1971 std::map<std::string, std::string> bindParam;
1972 targetId.wifiIp = "";
1973 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
1974 DeviceManagerService::GetInstance().dmServiceImpl_ = nullptr;
1975 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
1976 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1977 }
1978
1979 HWTEST_F(DeviceManagerServiceTest, UnbindTarget_004, testing::ext::TestSize.Level0)
1980 {
1981 DeletePermission();
1982 std::string pkgName;
1983 PeerTargetId targetId;
1984 std::map<std::string, std::string> unbindParam;
1985 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
1986 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1987 }
1988
1989 HWTEST_F(DeviceManagerServiceTest, UnbindTarget_005, testing::ext::TestSize.Level0)
1990 {
1991 std::string pkgName;
1992 PeerTargetId targetId;
1993 std::map<std::string, std::string> unbindParam;
1994 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
1995 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1996 }
1997
1998 HWTEST_F(DeviceManagerServiceTest, UnbindTarget_006, testing::ext::TestSize.Level0)
1999 {
2000 std::string pkgName = "pkgName";
2001 PeerTargetId targetId;
2002 std::map<std::string, std::string> unbindParam;
2003 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
2004 EXPECT_NE(ret, DM_OK);
2005 }
2006
2007 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0)
2008 {
2009 DeletePermission();
2010 std::string pkgName;
2011 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
2012 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2013 }
2014
2015 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_002, testing::ext::TestSize.Level0)
2016 {
2017 std::string pkgName = "pkgName";
2018 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2019 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false));
2020 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
2021 EXPECT_NE(ret, DM_OK);
2022 }
2023
2024 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_001, testing::ext::TestSize.Level0)
2025 {
2026 DeletePermission();
2027 std::string pkgName;
2028 PeerTargetId targetId;
2029 DmPinType pinType = DmPinType::QR_CODE;
2030 std::string payload;
2031 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2032 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2033 }
2034
2035 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_002, testing::ext::TestSize.Level0)
2036 {
2037 std::string pkgName = "pkgName";
2038 PeerTargetId targetId;
2039 DmPinType pinType = DmPinType::QR_CODE;
2040 std::string payload;
2041 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2042 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false));
2043 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2044 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2045 }
2046
2047 HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_001, testing::ext::TestSize.Level0)
2048 {
2049 DeletePermission();
2050 std::string pkgName;
2051 PeerTargetId targetId;
2052 DmPinType pinType = DmPinType::QR_CODE;
2053 std::string payload;
2054 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2055 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2056 }
2057
2058 HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_002, testing::ext::TestSize.Level0)
2059 {
2060 std::string pkgName = "pkgName";
2061 PeerTargetId targetId;
2062 DmPinType pinType = DmPinType::QR_CODE;
2063 std::string payload;
2064 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2065 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false));
2066 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2067 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2068 }
2069
2070
2071 HWTEST_F(DeviceManagerServiceTest, DpAclAdd_001, testing::ext::TestSize.Level0)
2072 {
2073 DeletePermission();
2074 std::string udid;
2075 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid);
2076 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2077 }
2078
2079 HWTEST_F(DeviceManagerServiceTest, DpAclAdd_002, testing::ext::TestSize.Level0)
2080 {
2081 std::string udid = "udid";
2082 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid);
2083 EXPECT_EQ(ret, DM_OK);
2084 }
2085
2086 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0)
2087 {
2088 std::string pkgName;
2089 std::string networkId;
2090 int32_t securityLevel = -1;
2091 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, networkId, securityLevel);
2092 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2093 }
2094
2095 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_002, testing::ext::TestSize.Level0)
2096 {
2097 std::string pkgName = "com.ohos.test";
2098 std::string invalidNetworkId = "12345";
2099 int32_t securityLevel = -1;
2100 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel);
2101 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
2102 }
2103
2104 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_003, testing::ext::TestSize.Level0)
2105 {
2106 std::string pkgName = "com.ohos.test";
2107 std::string invalidNetworkId = "12345";
2108 int32_t securityLevel = -1;
2109 DeletePermission();
2110 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel);
2111 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2112 }
2113
2114 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_004, testing::ext::TestSize.Level0)
2115 {
2116 std::string pkgName = "com.ohos.test";
2117 std::string invalidNetworkId;
2118 int32_t securityLevel = -1;
2119 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel);
2120 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2121 }
2122
2123 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_005, testing::ext::TestSize.Level0)
2124 {
2125 std::string pkgName = "com.ohos.test";
2126 std::string invalidNetworkId;
2127 int32_t securityLevel = 0;
2128 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2129 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel);
2130 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2131 EXPECT_NE(ret, DM_OK);
2132 }
2133
2134 HWTEST_F(DeviceManagerServiceTest, IsSameAccount_001, testing::ext::TestSize.Level0)
2135 {
2136 std::string udid = "";
2137 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_INPUT_PARA_INVALID));
2138 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
2139 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2140 }
2141
2142 HWTEST_F(DeviceManagerServiceTest, IsSameAccount_002, testing::ext::TestSize.Level0)
2143 {
2144 std::string udid = "udidTest";
2145 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_INPUT_PARA_INVALID));
2146 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
2147 EXPECT_NE(ret, DM_OK);
2148 }
2149
2150 HWTEST_F(DeviceManagerServiceTest, IsSameAccount_003, testing::ext::TestSize.Level0)
2151 {
2152 std::string udid = "udidTest";
2153 DeletePermission();
2154 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
2155 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2156 }
2157
2158 HWTEST_F(DeviceManagerServiceTest, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0)
2159 {
2160 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
2161 DmDeviceInfo devInfo;
2162 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).Times(::testing::AtLeast(2)).WillOnce(Return(DM_OK));
2163 DeviceManagerService::GetInstance().HandleDeviceStatusChange(devState, devInfo);
2164 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
2165 }
2166
2167 HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_001, testing::ext::TestSize.Level0)
2168 {
2169 DmAccessCaller caller;
2170 DmAccessCallee callee;
2171 DeletePermission();
2172 bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
2173 EXPECT_FALSE(ret);
2174 }
2175
2176
2177 HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_001, testing::ext::TestSize.Level0)
2178 {
2179 DmAccessCaller caller;
2180 DmAccessCallee callee;
2181 DeletePermission();
2182 bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
2183 EXPECT_FALSE(ret);
2184 }
2185
2186 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_001, testing::ext::TestSize.Level0)
2187 {
2188 std::string pkgName;
2189 std::map<std::string, std::string> policy;
2190 std::string processName = "collaboration_service";
2191 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
2192 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
2193 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
2194 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy);
2195 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2196 }
2197
2198 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_002, testing::ext::TestSize.Level0)
2199 {
2200 std::string pkgName = "openharmony123";
2201 std::map<std::string, std::string> policy;
2202 DeletePermission();
2203 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy);
2204 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2205 }
2206
2207 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_003, testing::ext::TestSize.Level0)
2208 {
2209 std::string pkgName = "openharmony123";
2210 std::map<std::string, std::string> policy;
2211 std::vector<std::string> peerUdids;
2212 int32_t userId = 1;
2213 uint64_t tokenId = 87;
2214 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, DEVICE);
2215 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, APP);
2216 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, 2);
2217 DeviceManagerService::GetInstance().SendDeviceUnBindBroadCast(peerUdids, userId);
2218 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2219 DeviceManagerService::GetInstance().SendDeviceUnBindBroadCast(peerUdids, userId);
2220 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2221 std::string processName = "collaboration_service";
2222 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
2223 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
2224 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
2225 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy);
2226 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2227 }
2228
2229 HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_003, testing::ext::TestSize.Level0)
2230 {
2231 std::string pkgName = "";
2232 PeerTargetId targetId;
2233 DmPinType pinType = DmPinType::QR_CODE;
2234 std::string payload;
2235 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2236 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false));
2237 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2238 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2239 }
2240
2241 HWTEST_F(DeviceManagerServiceTest, SendAppUnBindBroadCast_001, testing::ext::TestSize.Level0)
2242 {
2243 std::vector<std::string> peerUdids;
2244 int32_t userId = 12;
2245 uint64_t tokenId = 23;
2246 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2247 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId);
2248 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
2249 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2250 }
2251
2252 HWTEST_F(DeviceManagerServiceTest, SendAppUnBindBroadCast_002, testing::ext::TestSize.Level0)
2253 {
2254 std::vector<std::string> peerUdids;
2255 int32_t userId = 12;
2256 uint64_t peerTokenId = 3;
2257 uint64_t tokenId = 23;
2258 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2259 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId, peerTokenId);
2260 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
2261 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2262 }
2263
2264 HWTEST_F(DeviceManagerServiceTest, SendServiceUnBindBroadCast_001, testing::ext::TestSize.Level0)
2265 {
2266 std::vector<std::string> peerUdids;
2267 int32_t userId = 12;
2268 uint64_t tokenId = 23;
2269 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2270 DeviceManagerService::GetInstance().SendServiceUnBindBroadCast(peerUdids, userId, tokenId);
2271 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
2272 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2273 }
2274
2275 HWTEST_F(DeviceManagerServiceTest, ClearDiscoveryCache_001, testing::ext::TestSize.Level0)
2276 {
2277 ProcessInfo processInfo;
2278 processInfo.pkgName = "pkgName001";
2279 DeviceManagerService::GetInstance().InitDMServiceListener();
2280 DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
2281 EXPECT_NE(DeviceManagerService::GetInstance().discoveryMgr_, nullptr);
2282 DeviceManagerService::GetInstance().UninitDMServiceListener();
2283 }
2284
2285 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0)
2286 {
2287 std::string pkgName;
2288 std::string networkId;
2289 int32_t screenStatus = 1;
2290 DeletePermission();
2291 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
2292 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2293 }
2294
2295 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0)
2296 {
2297 std::string pkgName;
2298 std::string networkId;
2299 int32_t screenStatus = 1;
2300 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
2301 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2302 }
2303
2304 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0)
2305 {
2306 std::string pkgName = "pkgname";
2307 std::string networkId = "networkId_003";
2308 int32_t screenStatus = 1;
2309 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2310 EXPECT_CALL(*softbusListenerMock_, GetDeviceScreenStatus(_, _)).WillOnce(Return(ERR_DM_FAILED));
2311 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
2312 EXPECT_EQ(ret, ERR_DM_FAILED);
2313 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2314 }
2315
2316 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_004, testing::ext::TestSize.Level0)
2317 {
2318 std::string pkgName = "pkgname";
2319 std::string networkId = "networkId_003";
2320 int32_t screenStatus = 1;
2321 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
2322 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
2323 }
2324
2325 HWTEST_F(DeviceManagerServiceTest, HandleDeviceScreenStatusChange_001, testing::ext::TestSize.Level0)
2326 {
2327 DmDeviceInfo deviceInfo;
2328 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
2329 DeviceManagerService::GetInstance().IsDMServiceImplReady();
2330 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(Return(DM_OK));
2331 DeviceManagerService::GetInstance().HandleDeviceScreenStatusChange(deviceInfo);
2332 EXPECT_NE(DeviceManagerService::GetInstance().dmServiceImpl_, nullptr);
2333 }
2334
2335 HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_005, testing::ext::TestSize.Level0)
2336 {
2337 std::string pkgName = "pkgName";
2338 std::map<std::string, std::string> discoverParam;
2339 std::map<std::string, std::string> filterOptions;
2340 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
2341 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
2342 }
2343
2344 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0)
2345 {
2346 DmDeviceInfo info;
2347 DeletePermission();
2348 std::string msg = "";
2349 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
2350 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
2351 bool result = DeviceManagerService::GetInstance().IsDMServiceImplReady();
2352 EXPECT_TRUE(result);
2353 msg = R"(
2354 {
2355 "type" : 0,
2356 "userId" : 123,
2357 "accountId" : "28776",
2358 "tokenId" : 16,
2359 "peerUdid" : "104",
2360 "accountName" : "account_xiao"
2361 })";
2362 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
2363 msg = R"(
2364 {
2365 "type" : 1,
2366 "userId" : 128,
2367 "accountId" : "28778",
2368 "tokenId" : 17,
2369 "peerUdid" : "108",
2370 "accountName" : "account_li"
2371 })";
2372 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
2373 msg = R"(
2374 {
2375 "type" : 2,
2376 "userId" : 124,
2377 "accountId" : "28779",
2378 "tokenId" : 18,
2379 "peerUdid" : "110",
2380 "accountName" : "account_wang"
2381 })";
2382 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
2383 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
2384 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
2385 }
2386
2387 HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_001, testing::ext::TestSize.Level0)
2388 {
2389 std::string pkgName;
2390 std::string udid;
2391 std::string networkId = "networkIdTest_001";
2392 DeletePermission();
2393 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId);
2394 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2395 }
2396
2397 HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_002, testing::ext::TestSize.Level0)
2398 {
2399 std::string pkgName;
2400 std::string udid;
2401 std::string networkId = "networkIdTest_002";
2402 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId);
2403 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2404 }
2405
2406 HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_003, testing::ext::TestSize.Level0)
2407 {
2408 std::string pkgName = "pkgName_003";
2409 std::string udid = "sewdwed98897";
2410 std::string networkId = "networkIdTest_003";
2411 EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(2))
2412 .WillOnce(Return(ERR_DM_FAILED));
2413 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId);
2414 EXPECT_EQ(ret, ERR_DM_FAILED);
2415 }
2416
2417 HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_001, testing::ext::TestSize.Level0)
2418 {
2419 std::string pkgName;
2420 DeletePermission();
2421 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
2422 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
2423 }
2424
2425 HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_002, testing::ext::TestSize.Level0)
2426 {
2427 std::string pkgName;
2428 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
2429 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2430 }
2431
2432 HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_003, testing::ext::TestSize.Level0)
2433 {
2434 std::string pkgName = "pkgName_003";
2435 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
2436 DeviceManagerService::GetInstance().IsDMServiceImplReady();
2437 EXPECT_CALL(*deviceManagerServiceImplMock_, StopAuthenticateDevice(_)).WillOnce(Return(DM_OK));
2438 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
2439 EXPECT_EQ(ret, DM_OK);
2440 }
2441
2442 HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_004, testing::ext::TestSize.Level0)
2443 {
2444 std::string pkgName = "";
2445 PeerTargetId targetId;
2446 DmPinType pinType = DmPinType::QR_CODE;
2447 std::string payload;
2448 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2449 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2450 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2451 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2452 }
2453
2454 HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_005, testing::ext::TestSize.Level0)
2455 {
2456 std::string pkgName = "pkgName_005";
2457 PeerTargetId targetId;
2458 DmPinType pinType = DmPinType::QR_CODE;
2459 std::string payload;
2460 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2461 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2462 if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) {
2463 DeviceManagerService::GetInstance().InitDMServiceListener();
2464 }
2465 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
2466 EXPECT_EQ(ret, ERR_DM_FAILED);
2467 }
2468
2469 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_003, testing::ext::TestSize.Level0)
2470 {
2471 std::string pkgName = "";
2472 PeerTargetId targetId;
2473 DmPinType pinType = DmPinType::QR_CODE;
2474 std::string payload;
2475 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2476 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2477 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2478 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2479 }
2480
2481 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_004, testing::ext::TestSize.Level0)
2482 {
2483 std::string pkgName = "pkgName";
2484 PeerTargetId targetId;
2485 DmPinType pinType = DmPinType::QR_CODE;
2486 std::string payload;
2487 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2488 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2489 if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) {
2490 DeviceManagerService::GetInstance().InitDMServiceListener();
2491 }
2492 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
2493 EXPECT_EQ(ret, ERR_DM_FAILED);
2494 }
2495
2496 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_003, testing::ext::TestSize.Level0)
2497 {
2498 std::string pkgName;
2499 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2500 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2501 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
2502 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2503 }
2504
2505 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_004, testing::ext::TestSize.Level0)
2506 {
2507 std::string pkgName = "pkgName";
2508 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2509 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(true));
2510 if (DeviceManagerService::GetInstance().pinHolder_ == nullptr) {
2511 DeviceManagerService::GetInstance().InitDMServiceListener();
2512 }
2513 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
2514 EXPECT_EQ(ret, DM_OK);
2515 }
2516
2517 /**
2518 * @tc.name: ShiftLNNGear_008
2519 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return NOT DM_OK
2520 * @tc.type: FUNC
2521 * @tc.require: AR000GHSJK
2522 */
2523 HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_008, testing::ext::TestSize.Level0)
2524 {
2525 std::string pkgName = "ShiftLNNGear_008";
2526 std::string callerId = "ShiftLNNGear_008";
2527 bool isRefresh = true;
2528 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2529 EXPECT_CALL(*softbusListenerMock_, ShiftLNNGear(_, _)).WillOnce(Return(ERR_DM_FAILED));
2530 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false);
2531 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2532 EXPECT_EQ(ret, ERR_DM_FAILED);
2533 }
2534
2535 HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_003, testing::ext::TestSize.Level0)
2536 {
2537 std::string pkgName = "pkgName";
2538 std::string authCode;
2539 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2540 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
2541 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
2542 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2543 }
2544
2545 HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_004, testing::ext::TestSize.Level0)
2546 {
2547 std::string pkgName = "pkgName";
2548 std::string authCode = "authCode";
2549 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2550 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
2551 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
2552 EXPECT_EQ(ret, DM_OK);
2553 }
2554
2555 HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_003, testing::ext::TestSize.Level0)
2556 {
2557 std::string authCode = "authCode";
2558 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
2559 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
2560 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
2561 EXPECT_EQ(ret, DM_OK);
2562 }
2563
2564 HWTEST_F(DeviceManagerServiceTest, IsSameAccount_004, testing::ext::TestSize.Level0)
2565 {
2566 std::string udid = "udidTest";
2567 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
2568 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
2569 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
2570 }
2571
2572 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_006, testing::ext::TestSize.Level0)
2573 {
2574 std::string pkgName = "com.ohos.test";
2575 std::string invalidNetworkId = "networkId";
2576 int32_t securityLevel = 0;
2577 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2578 EXPECT_CALL(*softbusListenerMock_, GetDeviceSecurityLevel(_, _)).WillOnce(Return(DM_OK));
2579 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel);
2580 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2581 EXPECT_EQ(ret, DM_OK);
2582 }
2583
2584 HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_004, testing::ext::TestSize.Level0)
2585 {
2586 std::string pkgName = "pkgName";
2587 std::string networkId = "network_id";
2588 std::string uuid = "13345689";
2589 if (DeviceManagerService::GetInstance().softbusListener_ == nullptr) {
2590 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
2591 }
2592 EXPECT_CALL(*softbusListenerMock_, GetUuidByNetworkId(_, _)).WillOnce(Return(DM_OK));
2593 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return("appId"));
2594 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid);
2595 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
2596 EXPECT_EQ(ret, DM_OK);
2597 }
2598
2599 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
2600 HWTEST_F(DeviceManagerServiceTest, ConvertUdidHashToAnoyDeviceId_001, testing::ext::TestSize.Level0)
2601 {
2602 std::string udidHash;
2603 std::string result;
2604 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return(""));
2605 int32_t ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
2606 EXPECT_EQ(ret, ERR_DM_FAILED);
2607 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return("appId"));
2608 EXPECT_CALL(*cryptoMock_, ConvertUdidHashToAnoyAndSave(_, _, _)).WillOnce(Return(DM_OK));
2609 ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
2610 EXPECT_EQ(ret, DM_OK);
2611 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return("appId"));
2612 EXPECT_CALL(*cryptoMock_, ConvertUdidHashToAnoyAndSave(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
2613 ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
2614 EXPECT_EQ(ret, ERR_DM_FAILED);
2615 }
2616
2617 HWTEST_F(DeviceManagerServiceTest, GetUdidHashByAnoyDeviceId_001, testing::ext::TestSize.Level0)
2618 {
2619 std::string udidHash;
2620 std::string anoyDeviceId = "anoyDeviceId";
2621 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
2622 int32_t ret = DeviceManagerService::GetInstance().GetUdidHashByAnoyDeviceId(anoyDeviceId, udidHash);
2623 EXPECT_EQ(ret, DM_OK);
2624 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
2625 ret = DeviceManagerService::GetInstance().GetUdidHashByAnoyDeviceId(anoyDeviceId, udidHash);
2626 EXPECT_EQ(ret, ERR_DM_FAILED);
2627 }
2628 #endif
2629 } // namespace
2630 } // namespace DistributedHardware
2631 } // namespace OHOS
2632