1 /*
2 * Copyright (c) 2024-2025 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 #include <cstring>
27 #include <utility>
28
29 using namespace OHOS::Security::AccessToken;
30 using namespace testing;
31 using namespace testing::ext;
32 namespace OHOS {
33 namespace DistributedHardware {
34 namespace {
35 constexpr const char* PARAM_KEY_TARGET_ID = "TARGET_ID";
36 constexpr int32_t NUM_5 = 5;
DeletePermission()37 void DeletePermission()
38 {
39 const int32_t permsNum = 1;
40 const int32_t indexZero = 0;
41 uint64_t tokenId;
42 const char *perms[permsNum];
43 perms[indexZero] = "ohos.permission";
44 NativeTokenInfoParams infoInstance = {
45 .dcapsNum = 0,
46 .permsNum = permsNum,
47 .aclsNum = 0,
48 .dcaps = NULL,
49 .perms = perms,
50 .acls = NULL,
51 .processName = "DeviceManagerServiceTest",
52 .aplStr = "system_core",
53 };
54 tokenId = GetAccessTokenId(&infoInstance);
55 SetSelfTokenID(tokenId);
56 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
57 }
58
SetSetDnPolicyPermission()59 void SetSetDnPolicyPermission()
60 {
61 const int32_t permsNum = 1;
62 const int32_t indexZero = 0;
63 uint64_t tokenId;
64 const char *perms[permsNum];
65 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
66 NativeTokenInfoParams infoInstance = {
67 .dcapsNum = 0,
68 .permsNum = permsNum,
69 .aclsNum = 0,
70 .dcaps = NULL,
71 .perms = perms,
72 .acls = NULL,
73 .processName = "collaboration_service",
74 .aplStr = "system_core",
75 };
76 tokenId = GetAccessTokenId(&infoInstance);
77 SetSelfTokenID(tokenId);
78 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
79 }
80
81
82 /**
83 * @tc.name: GetTrustedDeviceList_201
84 * @tc.type: FUNC
85 */
86 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_201, testing::ext::TestSize.Level1)
87 {
88 std::string pkgName = "pkgName";
89 EXPECT_CALL(*appManagerMock_, GetAppId()).Times(::testing::AtLeast(1)).WillOnce(Return("appId"));
90 DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>();
91 DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName);
92 DeletePermission();
93 const std::string extra;
94 std::vector<DmDeviceInfo> deviceList;
95 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
96 int32_t ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
97 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
98 }
99
100 /**
101 * @tc.name: GetDeviceInfo_201
102 * @tc.type: FUNC
103 */
104 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_201, testing::ext::TestSize.Level1)
105 {
106 DeletePermission();
107 std::string networkId = "123";
108 DmDeviceInfo deviceIndo;
109 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceIndo);
110 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
111 ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(deviceIndo);
112 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
113 }
114
115 /**
116 * @tc.name: RegisterUiStateCallback_001
117 * @tc.type: FUNC
118 */
119 HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_201, testing::ext::TestSize.Level1)
120 {
121 DeletePermission();
122 std::string pkgName = "pkgName";
123 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
124 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
125 }
126
127 /**
128 * @tc.name: UnRegisterUiStateCallback_001
129 * @tc.type: FUNC
130 */
131 HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_201, testing::ext::TestSize.Level1)
132 {
133 DeletePermission();
134 std::string pkgName = "pkgName";
135 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
136 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
137 }
138
139 /**
140 * @tc.name: IsDMImplSoLoaded_001
141 * @tc.type: FUNC
142 */
143 HWTEST_F(DeviceManagerServiceTest, IsDMImplSoLoaded_201, testing::ext::TestSize.Level1)
144 {
145 std::string pkgName = "pkgName";
146 std::map<std::string, std::string> advertiseParam;
147 advertiseParam[PARAM_KEY_META_TYPE] = "1";
148 DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
149 std::map<std::string, std::string> advertiseParam2;
150 advertiseParam[PARAM_KEY_PUBLISH_ID] = "12";
151 DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam2);
152 PeerTargetId targetId;
153 targetId.deviceId = "123";
154 std::map<std::string, std::string> bindParam;
155 bindParam[PARAM_KEY_META_TYPE] = "1";
156 DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
157 targetId.wifiIp = "192.168.1.1";
158 std::map<std::string, std::string> bindParam2;
159 DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam2);
160 targetId.deviceId = "123";
161 std::map<std::string, std::string> unbindParam;
162 unbindParam[PARAM_KEY_META_TYPE] = "1";
163 DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
164 DeviceManagerService::GetInstance().IsDMServiceImplReady();
165 bool ret = DeviceManagerService::GetInstance().IsDMImplSoLoaded();
166 EXPECT_EQ(ret, true);
167 }
168
169 /**
170 * @tc.name: RegisterPinHolderCallback_201
171 * @tc.type: FUNC
172 */
173 HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_201, testing::ext::TestSize.Level1)
174 {
175 std::string pkgName = "CollaborationFwk";
176 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
177 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
178 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).WillOnce(Return(false));
179 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
180 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
181 }
182
183 /**
184 * @tc.name: CreatePinHolder_201
185 * @tc.type: FUNC
186 */
187 HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_201, testing::ext::TestSize.Level1)
188 {
189 std::string pkgName = "CollaborationFwk";
190 PeerTargetId targetId;
191 DmPinType pinType = NUMBER_PIN_CODE;
192 std::string payload;
193 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
194 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
195 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnPinHolder(_)).Times(::testing::AtLeast(1)).
196 WillOnce(Return(false));
197 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
198 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
199 }
200
201 /**
202 * @tc.name: GetDeviceSecurityLevel_201
203 * @tc.type: FUNC
204 */
205 HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_201, testing::ext::TestSize.Level1)
206 {
207 std::string pkgName = "pkgName";
208 std::string networkId = "123";
209 int32_t securityLevel;
210 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
211 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
212 EXPECT_CALL(*softbusListenerMock_, GetDeviceSecurityLevel(_, _)).WillOnce(Return(ERR_DM_FAILED));
213 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, networkId, securityLevel);
214 EXPECT_EQ(ret, ERR_DM_FAILED);
215 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
216 }
217
218 /**
219 * @tc.name: CheckAccessControl_001
220 * @tc.type: FUNC
221 */
222 HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_201, testing::ext::TestSize.Level1)
223 {
224 DmAccessCaller caller;
225 DmAccessCallee callee;
226 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
227 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK)).WillOnce(Return(DM_OK));
228 EXPECT_CALL(*deviceManagerServiceImplMock_, CheckAccessControl(_, _, _, _)).WillOnce(Return(true));
229 bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
230 EXPECT_EQ(ret, true);
231 }
232
233 /**
234 * @tc.name: CheckAccessControl_002
235 * @tc.type: FUNC
236 */
237 HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_202, testing::ext::TestSize.Level1)
238 {
239 DmAccessCaller caller;
240 DmAccessCallee callee;
241 DeletePermission();
242 bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
243 EXPECT_EQ(ret, false);
244 }
245
246 /**
247 * @tc.name: CheckIsSameAccount_201
248 * @tc.type: FUNC
249 */
250 HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_201, testing::ext::TestSize.Level1)
251 {
252 DmAccessCaller caller;
253 DmAccessCallee callee;
254 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
255 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK)).WillOnce(Return(DM_OK));
256 EXPECT_CALL(*deviceManagerServiceImplMock_, CheckIsSameAccount(_, _, _, _)).WillOnce(Return(true));
257 bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
258 EXPECT_EQ(ret, true);
259 }
260
261 /**
262 * @tc.name: CheckIsSameAccount_202
263 * @tc.type: FUNC
264 */
265 HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_202, testing::ext::TestSize.Level1)
266 {
267 DmAccessCaller caller;
268 DmAccessCallee callee;
269 DeletePermission();
270 bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
271 EXPECT_EQ(ret, false);
272 }
273
274 /**
275 * @tc.name: InitAccountInfo_201
276 * @tc.type: FUNC
277 */
278 HWTEST_F(DeviceManagerServiceTest, InitAccountInfo_201, testing::ext::TestSize.Level1)
279 {
280 int32_t userId = 100;
281 std::string commonEventType = "usual.event.USER_SWITCHED";
282 std::map<std::string, int32_t> curUserDeviceMap;
283 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, 101);
284 commonEventType = "common.event.HWID_LOGIN";
285 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, 101);
286 commonEventType = "usual.event.USER_SWITCHED";
287 int32_t currentUserId = -1;
288 int32_t beforeUserId = 0;
289 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, currentUserId, beforeUserId);
290 commonEventType = "common.event.HWID_LOGOUT";
291 currentUserId = 1;
292 beforeUserId = 1;
293 DMAccountInfo dmAccountInfo;
294 dmAccountInfo.accountId = "accountId";
295 dmAccountInfo.accountName = "accountName";
296 EXPECT_CALL(*multipleUserConnectorMock_, GetAccountInfoByUserId(_)).WillOnce(Return(dmAccountInfo));
297 DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, currentUserId, beforeUserId);
298 int32_t ret = DeviceManagerService::GetInstance().InitAccountInfo();
299 EXPECT_EQ(ret, DM_OK);
300 }
301
302 /**
303 * @tc.name: InitScreenLockEvent_001
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DeviceManagerServiceTest, InitScreenLockEvent_201, testing::ext::TestSize.Level1)
307 {
308 int32_t ret = DeviceManagerService::GetInstance().InitScreenLockEvent();
309 EXPECT_EQ(ret, DM_OK);
310 }
311
312 /**
313 * @tc.name: SubscribeAccountCommonEvent_201
314 * @tc.type: FUNC
315 */
316 HWTEST_F(DeviceManagerServiceTest, SubscribeAccountCommonEvent_201, testing::ext::TestSize.Level1)
317 {
318 DeviceManagerService::GetInstance().SubscribeAccountCommonEvent();
319 DeviceManagerService::GetInstance().SubscribeScreenLockEvent();
320 std::string commonEventType = "usual.event.USER_SWITCHED";
321 DeviceManagerService::GetInstance().ScreenCommonEventCallback(commonEventType);
322 EXPECT_NE(DeviceManagerService::GetInstance().accountCommonEventManager_, nullptr);
323 }
324
325 /**
326 * @tc.name: SetDnPolicy_201
327 * @tc.type: FUNC
328 */
329 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_201, testing::ext::TestSize.Level1)
330 {
331 SetSetDnPolicyPermission();
332 std::string packName = "com.ohos.test";
333 std::map<std::string, std::string> policy;
334 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
335 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
336 std::string processName = "collaboration_service";
337 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
338 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
339 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
340 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
341 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
342 bool bRet = false;
343 if (ret == DM_OK || ret == ERR_DM_UNSUPPORTED_METHOD || ret == SOFTBUS_IPC_ERR) {
344 bRet = true;
345 }
346 ASSERT_EQ(bRet, true);
347 }
348
349 /**
350 * @tc.name: SetDnPolicy_202
351 * @tc.type: FUNC
352 */
353 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_202, testing::ext::TestSize.Level1)
354 {
355 SetSetDnPolicyPermission();
356 std::string packName;
357 std::map<std::string, std::string> policy;
358 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
359 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
360 std::string processName = "collaboration_service";
361 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
362 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
363 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
364 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
365 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
366 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
367 }
368
369 /**
370 * @tc.name: SetDnPolicy_203
371 * @tc.type: FUNC
372 */
373 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_203, testing::ext::TestSize.Level1)
374 {
375 std::string packName = "com.ohos.test";
376 SetSetDnPolicyPermission();
377 std::map<std::string, std::string> policy;
378 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
379 std::string processName = "collaboration_service";
380 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
381 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
382 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
383 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
384 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
385 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
386 }
387
388 /**
389 * @tc.name: SetDnPolicy_204
390 * @tc.type: FUNC
391 */
392 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_204, testing::ext::TestSize.Level1)
393 {
394 SetSetDnPolicyPermission();
395 std::string packName = "com.ohos.test";
396 std::map<std::string, std::string> policy;
397 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
398 std::string processName = "collaboration_service";
399 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
400 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
401 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
402 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
403 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
404 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
405 }
406
407 /**
408 * @tc.name: SetDnPolicy_205
409 * @tc.type: FUNC
410 */
411 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_205, testing::ext::TestSize.Level1)
412 {
413 SetSetDnPolicyPermission();
414 std::string packName = "com.ohos.test";
415 std::map<std::string, std::string> policy;
416 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "a100";
417 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
418 std::string processName = "collaboration_service";
419 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
420 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
421 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
422 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
423 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
424 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
425 }
426
427 /**
428 * @tc.name: SetDnPolicy_206
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_206, testing::ext::TestSize.Level1)
432 {
433 SetSetDnPolicyPermission();
434 std::string packName = "com.ohos.test";
435 std::map<std::string, std::string> policy;
436 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100a";
437 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
438 std::string processName = "collaboration_service";
439 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
440 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
441 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
442 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
443 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
444 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
445 }
446
447 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_201, testing::ext::TestSize.Level1)
448 {
449 std::string pkgName = "com.ohos.screenStatusTest";
450 std::string networkId = "";
451 int32_t screenStatus = -1;
452 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
453 int32_t ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
454 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
455 }
456
457 HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_202, testing::ext::TestSize.Level1)
458 {
459 std::string pkgName = "";
460 std::string networkId = "networkIdTest";
461 int32_t screenStatus = -1;
462 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
463 int32_t ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
464 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
465
466 pkgName = "pkgName";
467 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
468 EXPECT_CALL(*softbusListenerMock_, GetDeviceScreenStatus(_, _)).WillOnce(Return(DM_OK));
469 ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
470 ASSERT_EQ(ret, DM_OK);
471 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
472 }
473
474 /**
475 * @tc.name: GetTrustedDeviceList_204
476 * @tc.desc:Set the intFlag of GetTrustedDeviceList_004 to true; Return DM_OK
477 * @tc.type: FUNC
478 * @tc.require: AR000GHSJK
479 */
480 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_204, testing::ext::TestSize.Level1)
481 {
482 std::string pkgName = "ohos_test";
483 std::string extra = "jdddd";
484 std::vector<DmDeviceInfo> deviceList;
485 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
486 DeviceManagerService::GetInstance().InitDMServiceListener();
487 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_)).WillOnce(Return(ERR_DM_FAILED));
488 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
489 EXPECT_EQ(ret, ERR_DM_FAILED);
490 DeviceManagerService::GetInstance().UninitDMServiceListener();
491 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
492 }
493
494 /**
495 * @tc.name: GetLocalDeviceInfo_203
496 * @tc.desc: The return value is ERR_DM_FAILED
497 * @tc.type: FUNC
498 * @tc.require: AR000GHSJK
499 */
500 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_203, testing::ext::TestSize.Level1)
501 {
502 DmDeviceInfo info;
503 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
504 EXPECT_CALL(*softbusListenerMock_, GetLocalDeviceInfo(_)).WillOnce(Return(ERR_DM_FAILED));
505 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
506 EXPECT_EQ(ret, ERR_DM_FAILED);
507 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
508 }
509
510 /**
511 * @tc.name: GetLocalDeviceInfo_204
512 * @tc.desc: The return value is ERR_DM_FAILED
513 * @tc.type: FUNC
514 * @tc.require: AR000GHSJK
515 */
516 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_204, testing::ext::TestSize.Level1)
517 {
518 DmDeviceInfo info;
519 DeletePermission();
520 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
521 EXPECT_CALL(*softbusListenerMock_, GetLocalDeviceInfo(_)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK));
522 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
523 EXPECT_EQ(ret, DM_OK);
524 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
525 }
526
527 HWTEST_F(DeviceManagerServiceTest, BindTarget_201, testing::ext::TestSize.Level1)
528 {
529 std::string pkgName = "pkgName";
530 PeerTargetId targetId;
531 targetId.wifiIp = "wifi_Ip";
532 std::map<std::string, std::string> bindParam;
533 std::string key = PARAM_KEY_TARGET_ID;
534 std::string value = "186";
535 bindParam.insert(std::make_pair(key, value));
536 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
537 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
538 EXPECT_EQ(ret, DM_OK);
539
540 targetId.wifiIp = "178.168.1.2";
541 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
542 EXPECT_CALL(*softbusListenerMock_, GetIPAddrTypeFromCache(_, _, _)).WillOnce(Return(DM_OK));
543 ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
544 EXPECT_EQ(ret, DM_OK);
545 }
546
547 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_201, testing::ext::TestSize.Level1)
548 {
549 std::string pkgName = "com.ohos.test";
550 std::string deviceId = "123456";
551 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
552 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
553 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
554 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
555 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(0));
556 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
557 EXPECT_NE(ret, DM_OK);
558 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
559 }
560
561 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_202, testing::ext::TestSize.Level1)
562 {
563 std::string pkgName = "com.ohos.test";
564 std::string deviceId = "123456";
565 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
566 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
567 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
568 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
569 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(0));
570 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
571 EXPECT_NE(ret, ERR_DM_POINT_NULL);
572
573 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
574 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
575 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK));
576 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(DM_IDENTICAL_ACCOUNT));
577 EXPECT_CALL(*deviceManagerServiceImplMock_, UnBindDevice(_, _, _)).WillOnce(Return(DM_OK));
578 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
579 EXPECT_NE(ret, ERR_DM_POINT_NULL);
580
581 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
582 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
583 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK));
584 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(DM_IDENTICAL_ACCOUNT));
585 EXPECT_CALL(*deviceManagerServiceImplMock_, UnBindDevice(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
586 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
587 EXPECT_NE(ret, ERR_DM_POINT_NULL);
588 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
589 }
590
591 HWTEST_F(DeviceManagerServiceTest, LoadHardwareFwkService_201, testing::ext::TestSize.Level1)
592 {
593 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
594 std::vector<DmDeviceInfo> deviceList;
595 DmDeviceInfo dmDeviceInfo;
596 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
597 dmDeviceInfo.extraData = "extraInfo";
598 deviceList.push_back(dmDeviceInfo);
599 std::unordered_map<std::string, DmAuthForm> udidMap;
600 udidMap.insert(std::make_pair("udid01", DmAuthForm::IDENTICAL_ACCOUNT));
601 udidMap.insert(std::make_pair("udid02", DmAuthForm::ACROSS_ACCOUNT));
602 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
603 .WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(DM_OK)));
604 EXPECT_CALL(*deviceManagerServiceImplMock_, GetAppTrustDeviceIdList(_)).WillOnce(Return(udidMap));
605 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
606 .WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
607 DeviceManagerService::GetInstance().LoadHardwareFwkService();
608 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_)).WillOnce(Return(ERR_DM_FAILED));
609 DeviceManagerService::GetInstance().LoadHardwareFwkService();
610 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
611 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
612 }
613
614 /**
615 * @tc.name: UnAuthenticateDevice_201
616 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
617 * value is SOFTBUS_IPC_ERR
618 * @tc.type: FUNC
619 * @tc.require: AR000GHSJK
620 */
621 HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_201, testing::ext::TestSize.Level1)
622 {
623 std::string pkgName = "com.ohos.test";
624 std::string networkId = "12345";
625 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
626 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
627 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(0));
628 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
629 EXPECT_EQ(ret, ERR_DM_FAILED);
630
631 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
632 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
633 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(1));
634 EXPECT_CALL(*deviceManagerServiceImplMock_, UnAuthenticateDevice(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
635 ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
636 EXPECT_EQ(ret, ERR_DM_FAILED);
637
638 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
639 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
640 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(1));
641 EXPECT_CALL(*deviceManagerServiceImplMock_, UnAuthenticateDevice(_, _, _)).WillOnce(Return(DM_OK));
642 ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
643 EXPECT_EQ(ret, DM_OK);
644
645 int32_t userId = 123456;
646 std::string accountId = "accountId";
647 std::string accountName = "accountName";
648 std::multimap<std::string, int32_t> deviceMap;
649 deviceMap.insert(std::make_pair("accountId", userId));
650 deviceMap.insert(std::make_pair("accountName", 1));
651 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_, _)).WillOnce(Return(deviceMap));
652 EXPECT_CALL(*cryptoMock_, GetAccountIdHash(_, _)).WillOnce(Return(DM_OK));
653 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName);
654
655 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_, _)).WillOnce(Return(deviceMap));
656 EXPECT_CALL(*cryptoMock_, GetAccountIdHash(_, _)).WillOnce(Return(ERR_DM_FAILED));
657 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName);
658
659 int32_t removeId = 123;
660 deviceMap.insert(std::make_pair("removeId", removeId));
661 EXPECT_CALL(*deviceManagerServiceImplMock_, GetDeviceIdAndUserId(_)).WillOnce(Return(deviceMap));
662 DeviceManagerService::GetInstance().HandleUserRemoved(userId);
663 }
664
665 HWTEST_F(DeviceManagerServiceTest, BindDevice_205, testing::ext::TestSize.Level1)
666 {
667 std::string pkgName = "com.ohos.test";
668 int32_t authType = 1;
669 std::string deviceId = "1234";
670 std::string bindParam;
671 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
672 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).Times(::testing::AtLeast(2)).WillRepeatedly(Return(DM_OK));
673 EXPECT_CALL(*softbusListenerMock_, GetTargetInfoFromCache(_, _, _)).WillOnce(Return(DM_OK));
674 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
675 EXPECT_EQ(ret, DM_OK);
676
677 ProcessInfo processInfo;
678 processInfo.pkgName = "pkgName";
679 if (DeviceManagerService::GetInstance().discoveryMgr_ == nullptr) {
680 DeviceManagerService::GetInstance().InitDMServiceListener();
681 }
682 DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
683 DeviceManagerService::GetInstance().RemoveNotifyRecord(processInfo);
684 }
685
686 /**
687 * @tc.name: AuthenticateDevice_205
688 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_BIND_INPUT_PARA_INVALID
689 * @tc.type: FUNC
690 * @tc.require: AR000GHSJK
691 */
692 HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_205, testing::ext::TestSize.Level1)
693 {
694 std::string pkgName = "com.ohos.test";
695 std::string extra = "jdddd";
696 int32_t authType = 0;
697 std::string deviceId = " 2345";
698 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
699 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK));
700 EXPECT_CALL(*softbusListenerMock_, GetTargetInfoFromCache(_, _, _)).WillOnce(Return(DM_OK));
701 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
702 EXPECT_EQ(ret, DM_OK);
703
704 std::vector<std::string> peerUdids;
705 int32_t userId = 123456;
706 if (DeviceManagerService::GetInstance().softbusListener_ == nullptr) {
707 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
708 }
709 DeviceManagerService::GetInstance().SendUserRemovedBroadCast(peerUdids, userId);
710
711 std::vector<int32_t> foregroundUserIds;
712 std::vector<int32_t> backgroundUserIds;
713 bool isNeedResponse = false;
714 foregroundUserIds.push_back(1);
715 foregroundUserIds.push_back(101);
716 backgroundUserIds.push_back(102);
717 backgroundUserIds.push_back(12);
718 DeviceManagerService::GetInstance().SendUserIdsBroadCast(peerUdids, foregroundUserIds,
719 backgroundUserIds, isNeedResponse);
720
721 std::vector<UserIdInfo> remoteUserIdInfos;
722 UserIdInfo userIdInfo(true, 1);
723 remoteUserIdInfos.push_back(userIdInfo);
724 UserIdInfo userIdInfo1(true, 102);
725 remoteUserIdInfos.push_back(userIdInfo1);
726 UserIdInfo userIdInfo2(false, 103);
727 remoteUserIdInfos.push_back(userIdInfo2);
728 UserIdInfo userIdInfo3(false, 104);
729 remoteUserIdInfos.push_back(userIdInfo3);
730 std::string remoteUdid = "remoteDeviceId";
731 isNeedResponse = true;
732 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
733 .WillOnce(Return(ERR_DM_FAILED)).WillOnce(Return(ERR_DM_FAILED));
734 EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(ERR_DM_FAILED));
735 DeviceManagerService::GetInstance().HandleUserIdsBroadCast(remoteUserIdInfos, remoteUdid, isNeedResponse);
736
737 std::vector<int32_t> foregroundUserVec;
738 foregroundUserVec.push_back(1);
739 foregroundUserVec.push_back(102);
740 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
741 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK))).WillOnce(Return(DM_OK));
742 EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(DM_OK));
743 DeviceManagerService::GetInstance().HandleUserIdsBroadCast(remoteUserIdInfos, remoteUdid, isNeedResponse);
744 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
745 }
746
747 HWTEST_F(DeviceManagerServiceTest, RegDevStateCallbackToService_201, testing::ext::TestSize.Level1)
748 {
749 std::string pkgName = "pkgName";
750 int32_t ret = DeviceManagerService::GetInstance().RegDevStateCallbackToService(pkgName);
751 EXPECT_EQ(ret, DM_OK);
752
753 std::string msg;
754 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
755 msg = R"(
756 {
757 "processType" : 1,
758 "g_authType" : 1,
759 "userId" : "123"
760 }))";
761 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
762
763 msg = R"(
764 {
765 "processType" : 1,
766 "g_authType" : 1,
767 "userId" : "123"
768 })";
769 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
770
771 msg = R"(
772 {
773 "networkId" : "networkId_001",
774 "g_authType" : 1,
775 "userId" : "123"
776 })";
777 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
778
779 JsonObject msgJsonObj;
780 msgJsonObj["networkId"] = "networkId_001";
781 msgJsonObj["discoverType"] = 0b0100;
782 msgJsonObj["ischange"] = true;
783 msg = msgJsonObj.Dump();
784 std::vector<int32_t> foregroundUserVec;
785 foregroundUserVec.push_back(101);
786 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
787 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK)));
788 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>(""), Return(DM_OK)));
789 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
790
791 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
792 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserVec), Return(DM_OK)));
793 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
794 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
795 Mock::VerifyAndClearExpectations(multipleUserConnectorMock_.get());
796
797 msgJsonObj["discoverType"] = 0;
798 msg = msgJsonObj.Dump();
799 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
800 }
801
802 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_205, testing::ext::TestSize.Level1)
803 {
804 std::string pkgName;
805 std::string extra = "extra";
806 std::vector<DmDeviceInfo> deviceList;
807 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
808 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
809 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
810
811 pkgName = "jjdjk_pkgName";
812 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
813 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
814 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
815
816 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
817 DeviceManagerService::GetInstance().InitDMServiceListener();
818 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_)).WillOnce(Return(ERR_DM_FAILED));
819 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
820 EXPECT_EQ(ret, ERR_DM_FAILED);
821
822 std::vector<DmDeviceInfo> onlineDeviceList;
823 DmDeviceInfo dmDeviceInfo;
824 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
825 dmDeviceInfo.networkType = 1;
826 onlineDeviceList.push_back(dmDeviceInfo);
827 std::unordered_map<std::string, DmAuthForm> udidMap;
828 udidMap.insert(std::make_pair("udid01", DmAuthForm::IDENTICAL_ACCOUNT));
829 udidMap.insert(std::make_pair("udid02", DmAuthForm::ACROSS_ACCOUNT));
830 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
831 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
832 .WillOnce(DoAll(SetArgReferee<0>(onlineDeviceList), Return(DM_OK)));
833 EXPECT_CALL(*deviceManagerServiceImplMock_, GetAppTrustDeviceIdList(_)).WillOnce(Return(udidMap));
834 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
835 .WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
836 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
837 EXPECT_EQ(ret, DM_OK);
838
839 pkgName = "ohos.deviceprofile";
840 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
841 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
842 .WillOnce(DoAll(SetArgReferee<0>(onlineDeviceList), Return(DM_OK)));
843 EXPECT_CALL(*deviceManagerServiceImplMock_, GetAppTrustDeviceIdList(_)).WillOnce(Return(udidMap));
844 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
845 .WillOnce(DoAll(SetArgReferee<1>("udid02"), Return(DM_OK)));
846 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
847 EXPECT_EQ(ret, DM_OK);
848 DeviceManagerService::GetInstance().UninitDMServiceListener();
849 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
850 }
851
852 HWTEST_F(DeviceManagerServiceTest, DmHiDumper_201, testing::ext::TestSize.Level1)
853 {
854 std::vector<std::string> args;
855 args.push_back(std::string("-getTrustlist"));
856 std::string result;
857 std::vector<DmDeviceInfo> deviceList;
858 DmDeviceInfo dmDeviceInfo;
859 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
860 dmDeviceInfo.deviceTypeId = 0;
861 deviceList.push_back(dmDeviceInfo);
862 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
863 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
864 .WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(DM_OK)));
865 int ret = DeviceManagerService::GetInstance().DmHiDumper(args, result);
866 EXPECT_EQ(ret, DM_OK);
867
868 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
869 .WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(ERR_DM_FAILED)));
870 ret = DeviceManagerService::GetInstance().DmHiDumper(args, result);
871 EXPECT_EQ(ret, ERR_DM_FAILED);
872 }
873
874 HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_207, testing::ext::TestSize.Level1)
875 {
876 SetSetDnPolicyPermission();
877 std::string packName = "com.ohos.test";
878 std::map<std::string, std::string> policy;
879 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100a";
880 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
881 std::string processName = "collaboration_service";
882 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
883 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
884 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
885 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
886 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
887 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
888
889 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
890 policy[PARAM_KEY_POLICY_TIME_OUT] = "10a";
891 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
892 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
893 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
894 ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
895 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
896
897 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
898 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(ERR_DM_FAILED)));
899 ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
900 ASSERT_EQ(ret, ERR_DM_FAILED);
901
902 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
903 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
904 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(false));
905 ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
906 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
907 }
908
909 HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_206, testing::ext::TestSize.Level1)
910 {
911 std::string pkgName;
912 std::vector<DmDeviceInfo> deviceList;
913 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, deviceList);
914 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
915
916 pkgName = "jjdjk_pkgName";
917 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
918 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, deviceList);
919 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
920
921 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
922 DeviceManagerService::GetInstance().InitDMServiceListener();
923 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_)).WillOnce(Return(ERR_DM_FAILED));
924 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, deviceList);
925 EXPECT_EQ(ret, ERR_DM_FAILED);
926
927 std::vector<DmDeviceInfo> onlineDeviceList;
928 DmDeviceInfo dmDeviceInfo;
929 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
930 dmDeviceInfo.networkType = 1;
931 onlineDeviceList.push_back(dmDeviceInfo);
932 std::unordered_map<std::string, DmAuthForm> udidMap;
933 udidMap.insert(std::make_pair("udid01", DmAuthForm::IDENTICAL_ACCOUNT));
934 udidMap.insert(std::make_pair("udid02", DmAuthForm::ACROSS_ACCOUNT));
935 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
936 .WillOnce(DoAll(SetArgReferee<0>(onlineDeviceList), Return(DM_OK)));
937 EXPECT_CALL(*deviceManagerServiceImplMock_, GetAppTrustDeviceIdList(_)).WillOnce(Return(udidMap));
938 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
939 .WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
940 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, deviceList);
941 EXPECT_EQ(ret, DM_OK);
942
943 pkgName = "ohos.deviceprofile";
944 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
945 .WillOnce(DoAll(SetArgReferee<0>(onlineDeviceList), Return(DM_OK)));
946 EXPECT_CALL(*deviceManagerServiceImplMock_, GetAppTrustDeviceIdList(_)).WillOnce(Return(udidMap));
947 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
948 .WillOnce(DoAll(SetArgReferee<1>("udid02"), Return(DM_OK)));
949 ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, deviceList);
950 EXPECT_EQ(ret, DM_OK);
951 DeviceManagerService::GetInstance().UninitDMServiceListener();
952 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
953 }
954
955 HWTEST_F(DeviceManagerServiceTest, ParseCheckSumMsg_201, testing::ext::TestSize.Level1)
956 {
957 std::string msg;
958 std::string networkId;
959 uint32_t discoveryType = 0;
960 bool isChange = false;
961 JsonObject msgJsonObj;
962 msgJsonObj["networkId"] = "networkId001";
963 msgJsonObj["discoverType"] = 1;
964 msgJsonObj["ischange"] = false;
965 msg = msgJsonObj.Dump();
966 int ret = DeviceManagerService::GetInstance().ParseCheckSumMsg(msg, networkId, discoveryType, isChange);
967 EXPECT_EQ(ret, DM_OK);
968 }
969
970 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_203, testing::ext::TestSize.Level1)
971 {
972 DeletePermission();
973 std::string pkgName;
974 std::string udidHash;
975 std::string extra;
976 int ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
977 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
978 }
979
980 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_204, testing::ext::TestSize.Level1)
981 {
982 std::string pkgName;
983 std::string udidHash;
984 std::string extra;
985 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
986 int ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
987 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
988
989 pkgName = "pkgName";
990 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
991 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
992 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
993
994 udidHash = "udidHash";
995 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
996 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
997 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
998 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(ERR_DM_FAILED));
999 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
1000 EXPECT_NE(ret, DM_OK);
1001
1002 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1003 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
1004 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
1005 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(0));
1006 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
1007 EXPECT_NE(ret, DM_OK);
1008
1009 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1010 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
1011 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
1012 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(1));
1013 EXPECT_CALL(*deviceManagerServiceImplMock_, UnBindDevice(_, _, _, _)).WillOnce(Return(ERR_DM_FAILED));
1014 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
1015 EXPECT_NE(ret, DM_OK);
1016
1017 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1018 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
1019 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
1020 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(1));
1021 EXPECT_CALL(*deviceManagerServiceImplMock_, UnBindDevice(_, _, _, _)).WillOnce(Return(DM_OK));
1022 ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
1023 EXPECT_EQ(ret, DM_OK);
1024 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1025 }
1026
1027 HWTEST_F(DeviceManagerServiceTest, UnBindDevice_205, testing::ext::TestSize.Level1)
1028 {
1029 std::string pkgName = "pkgName";
1030 std::string udidHash = "udidHash";
1031 std::string extra = "extra";
1032 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1033 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillRepeatedly(Return(true));
1034 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
1035 EXPECT_CALL(*softbusListenerMock_, GetUdidFromDp(_, _)).WillOnce(Return(DM_OK));
1036 EXPECT_CALL(*deviceManagerServiceImplMock_, GetBindLevel(_, _, _, _)).WillOnce(Return(1));
1037 EXPECT_CALL(*deviceManagerServiceImplMock_, UnBindDevice(_, _, _, _)).WillOnce(Return(ERR_DM_FAILED));
1038 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, udidHash, extra);
1039 EXPECT_NE(ret, DM_OK);
1040
1041 std::vector<UserIdInfo> remoteUserIdInfos;
1042 std::string remoteUdid;
1043 bool isNeedResponse = false;
1044 DeviceManagerService::GetInstance().HandleUserIdsBroadCast(remoteUserIdInfos, remoteUdid, isNeedResponse);
1045
1046 std::vector<std::string> peerUdids;
1047 int32_t userId = 123;
1048 uint64_t tokenId = 1;
1049 int32_t bindLevel = 1;
1050 uint64_t peerTokenId = 1;
1051 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, bindLevel, peerTokenId);
1052 bindLevel = 3;
1053 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, bindLevel, peerTokenId);
1054 bindLevel = 2;
1055 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, bindLevel, peerTokenId);
1056 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1057 }
1058
1059 HWTEST_F(DeviceManagerServiceTest, SendAppUnBindBroadCast_201, testing::ext::TestSize.Level1)
1060 {
1061 std::vector<std::string> peerUdids;
1062 int32_t userId = 12;
1063 uint64_t tokenId = 23;
1064 uint64_t peerTokenId = 1;
1065 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1066 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId, peerTokenId);
1067 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1068 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1069 }
1070
1071 HWTEST_F(DeviceManagerServiceTest, GetAnonyLocalUdid_201, testing::ext::TestSize.Level1)
1072 {
1073 DeletePermission();
1074 std::string pkgName;
1075 std::string anonyUdid;
1076 int32_t ret = DeviceManagerService::GetInstance().GetAnonyLocalUdid(pkgName, anonyUdid);
1077 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1078
1079 const char *peerUdid = "peerUdid";
1080 GroupInformation groupInfo;
1081 DeviceManagerService::GetInstance().HandleDeviceUnBind(peerUdid, groupInfo);
1082 }
1083
1084 HWTEST_F(DeviceManagerServiceTest, GetAnonyLocalUdid_202, testing::ext::TestSize.Level1)
1085 {
1086 std::string pkgName;
1087 std::string anonyUdid;
1088 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1089 int32_t ret = DeviceManagerService::GetInstance().GetAnonyLocalUdid(pkgName, anonyUdid);
1090 EXPECT_EQ(ret, DM_OK);
1091 }
1092
1093 HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_004, testing::ext::TestSize.Level1)
1094 {
1095 std::string pkgName = "pkgName_004";
1096 EXPECT_CALL(*deviceManagerServiceImplMock_, StopAuthenticateDevice(_)).WillOnce(Return(ERR_DM_FAILED));
1097 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1098 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
1099 EXPECT_EQ(ret, ERR_DM_FAILED);
1100 }
1101
1102 HWTEST_F(DeviceManagerServiceTest, IsDMServiceAdapterSoLoaded_201, testing::ext::TestSize.Level1)
1103 {
1104 DeviceManagerService::GetInstance().isAdapterResidentSoLoaded_ = false;
1105 bool ret = DeviceManagerService::GetInstance().IsDMServiceAdapterSoLoaded();
1106 EXPECT_FALSE(ret);
1107
1108 DeviceManagerService::GetInstance().isAdapterResidentSoLoaded_ = true;
1109 DeviceManagerService::GetInstance().dmServiceImplExtResident_ = nullptr;
1110 ret = DeviceManagerService::GetInstance().IsDMServiceAdapterSoLoaded();
1111 EXPECT_FALSE(ret);
1112
1113 DeviceManagerService::GetInstance().isAdapterResidentSoLoaded_ = false;
1114 DeviceManagerService::GetInstance().IsDMServiceAdapterResidentLoad();
1115 ret = DeviceManagerService::GetInstance().IsDMServiceAdapterSoLoaded();
1116 EXPECT_FALSE(ret);
1117
1118 DeviceManagerService::GetInstance().UnloadDMServiceAdapterResident();
1119 }
1120
1121 HWTEST_F(DeviceManagerServiceTest, LoadHardwareFwkService_202, testing::ext::TestSize.Level1)
1122 {
1123 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1124 std::vector<DmDeviceInfo> deviceList;
1125 EXPECT_CALL(*softbusListenerMock_, GetTrustedDeviceList(_))
1126 .WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(DM_OK)));
1127 DeviceManagerService::GetInstance().LoadHardwareFwkService();
1128 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1129 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1130 }
1131
1132 HWTEST_F(DeviceManagerServiceTest, RegisterAuthenticationType_201, testing::ext::TestSize.Level1)
1133 {
1134 std::string pkgName;
1135 std::map<std::string, std::string> authParam;
1136 DeletePermission();
1137 int32_t ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
1138 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1139
1140 std::string networkId;
1141 std::vector<int32_t> foregroundUserIds;
1142 std::vector<int32_t> backgroundUserIds;
1143 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>(""), Return(DM_OK)));
1144 DeviceManagerService::GetInstance().ProcessCheckSumByBT(networkId, foregroundUserIds, backgroundUserIds);
1145
1146 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
1147 DeviceManagerService::GetInstance().ProcessCheckSumByBT(networkId, foregroundUserIds, backgroundUserIds);
1148
1149 foregroundUserIds.push_back(101);
1150 EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(DoAll(SetArgReferee<1>("udid01"), Return(DM_OK)));
1151 DeviceManagerService::GetInstance().ProcessCheckSumByBT(networkId, foregroundUserIds, backgroundUserIds);
1152
1153 DeviceManagerService::GetInstance().localNetWorkId_ = "";
1154 networkId = "networkId001";
1155 std::string str = "deviceId";
1156 DmDeviceInfo deviceInfo;
1157 foregroundUserIds.push_back(102);
1158 memcpy_s(deviceInfo.networkId, DM_MAX_DEVICE_ID_LEN, str.c_str(), str.length());
1159 backgroundUserIds.push_back(201);
1160 backgroundUserIds.push_back(202);
1161 DeviceManagerService::GetInstance().ProcessCheckSumByWifi(networkId, foregroundUserIds, backgroundUserIds);
1162 }
1163
1164 HWTEST_F(DeviceManagerServiceTest, RegisterAuthenticationType_202, testing::ext::TestSize.Level1)
1165 {
1166 std::string pkgName;
1167
1168 std::map<std::string, std::string> authParam;
1169 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1170 int32_t ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
1171 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1172
1173 pkgName = "pkgName";
1174 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1175 ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
1176 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1177
1178 authParam.insert(std::make_pair(DM_AUTHENTICATION_TYPE, "authentication"));
1179 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1180 ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
1181 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1182
1183 authParam[DM_AUTHENTICATION_TYPE] = "123456";
1184 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1185 ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
1186 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1187
1188 std::string msg;
1189 JsonObject msgJsonObj;
1190 msgJsonObj["networkId"] = "networkId";
1191 msgJsonObj["discoverType"] = 123;
1192 msgJsonObj["ischange"] = false;
1193 msg = msgJsonObj.Dump();
1194 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
1195
1196 msgJsonObj["ischange"] = true;
1197 msg = msgJsonObj.Dump();
1198 std::vector<int32_t> foregroundUserIds;
1199 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
1200 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserIds), Return(ERR_DM_INPUT_PARA_INVALID)));
1201 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
1202
1203 foregroundUserIds.push_back(101);
1204 std::vector<int32_t> backgroundUserIds;
1205 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
1206 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserIds), Return(DM_OK)));
1207 EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_)).WillOnce(Return(ERR_DM_FAILED));
1208 EXPECT_CALL(*dMCommToolMock_, SendUserIds(_, _, _)).WillRepeatedly(Return(ERR_DM_FAILED));
1209 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
1210
1211 backgroundUserIds.push_back(102);
1212 msgJsonObj["discoverType"] = 1;
1213 msg = msgJsonObj.Dump();
1214 EXPECT_CALL(*multipleUserConnectorMock_, GetForegroundUserIds(_))
1215 .WillOnce(DoAll(SetArgReferee<0>(foregroundUserIds), Return(DM_OK)));
1216 EXPECT_CALL(*multipleUserConnectorMock_, GetBackgroundUserIds(_))
1217 .WillOnce(DoAll(SetArgReferee<0>(backgroundUserIds), Return(DM_OK)));
1218 DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
1219 }
1220
1221 HWTEST_F(DeviceManagerServiceTest, GetDeviceProfileInfoList_201, testing::ext::TestSize.Level1)
1222 {
1223 DeletePermission();
1224 std::string pkgName;
1225 OHOS::DistributedHardware::DmDeviceProfileInfoFilterOptions filterOptions;
1226 int32_t ret = DeviceManagerService::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions);
1227 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1228 }
1229
1230 HWTEST_F(DeviceManagerServiceTest, GetDeviceProfileInfoList_202, testing::ext::TestSize.Level1)
1231 {
1232 std::string pkgName = "pkgName";
1233 OHOS::DistributedHardware::DmDeviceProfileInfoFilterOptions filterOptions;
1234 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1235 int32_t ret = DeviceManagerService::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions);
1236 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
1237 }
1238
1239 HWTEST_F(DeviceManagerServiceTest, GetDeviceIconInfo_201, testing::ext::TestSize.Level1)
1240 {
1241 DeletePermission();
1242 std::string pkgName;
1243 OHOS::DistributedHardware::DmDeviceIconInfoFilterOptions filterOptions;
1244 int32_t ret = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions);
1245 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1246 }
1247
1248 HWTEST_F(DeviceManagerServiceTest, GetDeviceIconInfo_202, testing::ext::TestSize.Level1)
1249 {
1250 std::string pkgName = "pkgName";
1251 OHOS::DistributedHardware::DmDeviceIconInfoFilterOptions filterOptions;
1252 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1253 int32_t ret = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions);
1254 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
1255 }
1256
1257 HWTEST_F(DeviceManagerServiceTest, PutDeviceProfileInfoList_201, testing::ext::TestSize.Level1)
1258 {
1259 DeletePermission();
1260 std::string pkgName = "pkgName";
1261 std::vector<DmDeviceProfileInfo> deviceProfileInfoList;
1262 int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList);
1263 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1264 }
1265
1266 HWTEST_F(DeviceManagerServiceTest, PutDeviceProfileInfoList_202, testing::ext::TestSize.Level1)
1267 {
1268 std::string pkgName = "pkgName";
1269 std::vector<DmDeviceProfileInfo> deviceProfileInfoList;
1270 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1271 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidPutDeviceProfileInfoList(_)).WillOnce(Return(true));
1272 int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList);
1273 EXPECT_TRUE(ret == ERR_DM_UNSUPPORTED_METHOD || ret == ERR_DM_INPUT_PARA_INVALID);
1274 }
1275
1276 HWTEST_F(DeviceManagerServiceTest, SetLocalDisplayNameToSoftbus_201, testing::ext::TestSize.Level1)
1277 {
1278 std::string displayName = "displayName";
1279 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1280 int32_t ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName);
1281 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1282
1283 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1284 EXPECT_CALL(*softbusListenerMock_, SetLocalDisplayName(_)).WillOnce(Return(DM_OK));
1285 ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName);
1286 EXPECT_EQ(ret, DM_OK);
1287
1288 EXPECT_CALL(*softbusListenerMock_, SetLocalDisplayName(_)).WillOnce(Return(ERR_DM_NO_PERMISSION));
1289 ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName);
1290 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1291 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1292 }
1293
1294 HWTEST_F(DeviceManagerServiceTest, GetLocalDisplayDeviceName_201, testing::ext::TestSize.Level1)
1295 {
1296 DeletePermission();
1297 std::string pkgName = "packName";
1298 int32_t maxNameLength = 1;
1299 std::string displayName = "displayName";
1300 int32_t ret = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName);
1301 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1302 }
1303
1304 HWTEST_F(DeviceManagerServiceTest, GetLocalDisplayDeviceName_202, testing::ext::TestSize.Level1)
1305 {
1306 std::string pkgName = "packName";
1307 int32_t maxNameLength = 1;
1308 std::string displayName = "";
1309 std::string deviceName = "displayName";
1310 EXPECT_CALL(*deviceNameManagerMock_, GetLocalDisplayDeviceName(_, _))
1311 .WillOnce(DoAll(SetArgReferee<1>(deviceName), Return(0)));
1312 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1313 int32_t ret = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName);
1314 EXPECT_EQ(ret, DM_OK);
1315 EXPECT_EQ(displayName, deviceName);
1316 }
1317
1318 HWTEST_F(DeviceManagerServiceTest, GetDeviceNamePrefixs_201, testing::ext::TestSize.Level1)
1319 {
1320 auto ret = DeviceManagerService::GetInstance().GetDeviceNamePrefixs();
1321 EXPECT_EQ(ret.empty(), true);
1322 }
1323
1324 HWTEST_F(DeviceManagerServiceTest, GetAllTrustedDeviceList_201, testing::ext::TestSize.Level1)
1325 {
1326 std::string pkgName = "";
1327 std::string extra = "extra";
1328 std::vector<DmDeviceInfo> deviceList;
1329 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillRepeatedly(Return(true));
1330 int32_t ret = DeviceManagerService::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
1331 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1332
1333 pkgName = "pkgName";
1334 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1335 EXPECT_CALL(*softbusListenerMock_, GetAllTrustedDeviceList(_, _, _)).WillOnce(Return(DM_OK));
1336 ret = DeviceManagerService::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
1337 EXPECT_EQ(ret, DM_OK);
1338
1339 EXPECT_CALL(*softbusListenerMock_, GetAllTrustedDeviceList(_, _, _)).WillOnce(Return(ERR_DM_INPUT_PARA_INVALID));
1340 ret = DeviceManagerService::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
1341 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1342 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1343 DeviceManagerService::GetInstance().hichainListener_ = nullptr;
1344 DeviceManagerService::GetInstance().InitHichainListener();
1345 }
1346
1347 HWTEST_F(DeviceManagerServiceTest, GetAllTrustedDeviceList_202, testing::ext::TestSize.Level1)
1348 {
1349 DeletePermission();
1350 std::string pkgName = "pkgName";
1351 std::string extra = "extra";
1352 std::vector<DmDeviceInfo> deviceList;
1353 int32_t ret = DeviceManagerService::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
1354 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1355
1356 int32_t actionId = 1;
1357 std::string bindParam = "bindParamData";
1358 DeviceManagerService::GetInstance().AddHmlInfoToBindParam(actionId, bindParam);
1359 }
1360
1361 HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_202, testing::ext::TestSize.Level1)
1362 {
1363 std::string networkId = "networkId";
1364 DmDeviceInfo deviceInfo;
1365 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1366 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1367 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
1368 .WillOnce(DoAll(SetArgReferee<1>("peerDeviceId"), Return(DM_OK)));
1369 EXPECT_CALL(*softbusListenerMock_, GetDeviceInfo(_, _)).WillOnce(Return(DM_OK));
1370 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
1371 EXPECT_EQ(ret, DM_OK);
1372 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1373 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
1374 .WillOnce(DoAll(SetArgReferee<1>("peerDeviceId"), Return(DM_OK)));
1375 EXPECT_CALL(*softbusListenerMock_, GetDeviceInfo(_, _)).WillOnce(Return(ERR_DM_FAILED));
1376 ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
1377 EXPECT_EQ(ret, ERR_DM_FAILED);
1378 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1379 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
1380 .WillOnce(DoAll(SetArgReferee<1>("peerDeviceId"), Return(DM_OK)));
1381 EXPECT_CALL(*softbusListenerMock_, GetDeviceInfo(_, _)).WillOnce(Return(DM_OK));
1382 ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
1383 EXPECT_EQ(ret, DM_OK);
1384 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1385 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
1386 .WillOnce(DoAll(SetArgReferee<1>("peerDeviceId"), Return(DM_OK)));
1387 EXPECT_CALL(*softbusListenerMock_, GetDeviceInfo(_, _))
1388 .WillOnce(Return (DM_OK))
1389 .WillOnce(Return(DM_OK));
1390 ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
1391 EXPECT_EQ(ret, DM_OK);
1392 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1393 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _))
1394 .WillOnce(DoAll(SetArgReferee<1>("peerDeviceId"), Return(DM_OK)));
1395 ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
1396 EXPECT_EQ(ret, DM_OK);
1397 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1398 }
1399
1400 HWTEST_F(DeviceManagerServiceTest, InitDPLocalServiceInfo_201, testing::ext::TestSize.Level1)
1401 {
1402 DMLocalServiceInfo serviceInfo;
1403 DistributedDeviceProfile::LocalServiceInfo dpLocalServiceInfo;
1404 bool ret = DeviceManagerService::GetInstance().InitDPLocalServiceInfo(serviceInfo, dpLocalServiceInfo);
1405 EXPECT_TRUE(ret);
1406
1407 DeviceManagerService::GetInstance().InitServiceInfo(dpLocalServiceInfo, serviceInfo);
1408 std::vector<DistributedDeviceProfile::LocalServiceInfo> dpLocalServiceInfos;
1409 dpLocalServiceInfos.push_back(dpLocalServiceInfo);
1410 std::vector<DMLocalServiceInfo> serviceInfos;
1411 DeviceManagerService::GetInstance().InitServiceInfos(dpLocalServiceInfos, serviceInfos);
1412 }
1413
1414 HWTEST_F(DeviceManagerServiceTest, RegisterLocalServiceInfo_201, testing::ext::TestSize.Level1)
1415 {
1416 DMLocalServiceInfo serviceInfo;
1417 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1418 EXPECT_CALL(*deviceProfileConnectorMock_, PutLocalServiceInfo(_)).WillOnce(Return(DM_OK));
1419 int32_t ret = DeviceManagerService::GetInstance().RegisterLocalServiceInfo(serviceInfo);
1420 EXPECT_EQ(ret, DM_OK);
1421
1422 std::string localUdid = "U*******jkjk2";
1423 std::vector<std::string> deviceVec{"deviceInfo"};
1424 std::vector<int32_t> foregroundUserIds{10, 11};
1425 std::vector<int32_t> backgroundUserIds{1, 2};
1426 DeviceManagerService::GetInstance().InitDMServiceListener();
1427 DeviceManagerService::GetInstance().hichainListener_ = std::make_shared<HichainListener>();
1428 DeviceManagerService::GetInstance().UpdateAclAndDeleteGroup(localUdid, deviceVec,
1429 foregroundUserIds, backgroundUserIds);
1430
1431 std::string pkgName = "pkgName";
1432 DeviceManagerService::GetInstance().ClearPublishIdCache(pkgName);
1433 DeviceManagerService::GetInstance().hichainListener_ = nullptr;
1434 }
1435
1436 HWTEST_F(DeviceManagerServiceTest, UnRegisterLocalServiceInfo_201, testing::ext::TestSize.Level1)
1437 {
1438 std::string bundleName = "bund******98";
1439 int32_t pinExchangeType = 1;
1440 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1441 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteLocalServiceInfo(_, _)).WillOnce(Return(DM_OK));
1442 int32_t ret = DeviceManagerService::GetInstance().UnRegisterLocalServiceInfo(bundleName, pinExchangeType);
1443 EXPECT_EQ(ret, DM_OK);
1444 }
1445
1446 HWTEST_F(DeviceManagerServiceTest, UpdateLocalServiceInfo_201, testing::ext::TestSize.Level1)
1447 {
1448 DMLocalServiceInfo serviceInfo;
1449 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1450 EXPECT_CALL(*deviceProfileConnectorMock_, UpdateLocalServiceInfo(_)).WillOnce(Return(DM_OK));
1451 int32_t ret = DeviceManagerService::GetInstance().UpdateLocalServiceInfo(serviceInfo);
1452 EXPECT_EQ(ret, DM_OK);
1453 }
1454
1455 HWTEST_F(DeviceManagerServiceTest, GetLocalServiceInfoByBundleNameAndPinExchangeType_201,
1456 testing::ext::TestSize.Level1)
1457 {
1458 std::string bundleName = "bund******98";
1459 int32_t pinExchangeType = 1;
1460 DMLocalServiceInfo serviceInfo;
1461 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
1462 EXPECT_CALL(*deviceProfileConnectorMock_, GetLocalServiceInfoByBundleNameAndPinExchangeType(_, _, _))
1463 .WillOnce(Return(DM_OK));
1464 int32_t ret = DeviceManagerService::GetInstance().GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName,
1465 pinExchangeType, serviceInfo);
1466 EXPECT_EQ(ret, DM_OK);
1467 }
1468
1469 HWTEST_F(DeviceManagerServiceTest, InitDPLocalServiceInfo_001, testing::ext::TestSize.Level0)
1470 {
1471 DMLocalServiceInfo dmServiceInfo;
1472 dmServiceInfo.bundleName = "testbundle";
1473 dmServiceInfo.extraInfo = "testextra";
1474 DistributedDeviceProfile::LocalServiceInfo dpLocalServiceInfo;
1475 DeviceManagerService::GetInstance().InitDPLocalServiceInfo(dmServiceInfo, dpLocalServiceInfo);
1476 EXPECT_TRUE(dmServiceInfo.bundleName == dpLocalServiceInfo.GetBundleName());
1477 EXPECT_TRUE(dmServiceInfo.extraInfo == dpLocalServiceInfo.GetExtraInfo());
1478 }
1479
1480 HWTEST_F(DeviceManagerServiceTest, InitServiceInfo_001, testing::ext::TestSize.Level0)
1481 {
1482 DMLocalServiceInfo dmServiceInfo;
1483 DistributedDeviceProfile::LocalServiceInfo dpLocalServiceInfo;
1484 dpLocalServiceInfo.SetBundleName("testbundle");
1485 dpLocalServiceInfo.SetExtraInfo("testextra");
1486 DeviceManagerService::GetInstance().InitServiceInfo(dpLocalServiceInfo, dmServiceInfo);
1487 EXPECT_TRUE(dmServiceInfo.bundleName == dpLocalServiceInfo.GetBundleName());
1488 EXPECT_TRUE(dmServiceInfo.extraInfo == dpLocalServiceInfo.GetExtraInfo());
1489 }
1490
1491 HWTEST_F(DeviceManagerServiceTest, InitServiceInfos_001, testing::ext::TestSize.Level0)
1492 {
1493 std::vector<DMLocalServiceInfo> dmServiceInfos;
1494 std::vector<DistributedDeviceProfile::LocalServiceInfo> dpLocalServiceInfos;
1495 for (int k = 0; k < NUM_5; k++) {
1496 DistributedDeviceProfile::LocalServiceInfo dpLocalServiceInfo;
1497 dpLocalServiceInfo.SetBundleName(std::string("testbundle") + std::to_string(k));
1498 dpLocalServiceInfo.SetExtraInfo(std::string("testextra") + std::to_string(k));
1499 dpLocalServiceInfos.emplace_back(dpLocalServiceInfo);
1500 }
1501 DeviceManagerService::GetInstance().InitServiceInfos(dpLocalServiceInfos, dmServiceInfos);
1502 for (int k = 0; k < NUM_5; k++) {
1503 DMLocalServiceInfo &dmServiceInfo = dmServiceInfos[k];
1504 DistributedDeviceProfile::LocalServiceInfo &dpLocalServiceInfo = dpLocalServiceInfos[k];
1505 EXPECT_TRUE(dmServiceInfo.bundleName == dpLocalServiceInfo.GetBundleName());
1506 EXPECT_TRUE(dmServiceInfo.extraInfo == dpLocalServiceInfo.GetExtraInfo());
1507 }
1508 }
1509
1510 HWTEST_F(DeviceManagerServiceTest, RestoreLocalDeviceName_201, testing::ext::TestSize.Level1)
1511 {
1512 std::string pkgName = "pkgName";
1513 DeletePermission();
1514 int32_t ret = DeviceManagerService::GetInstance().RestoreLocalDeviceName(pkgName);
1515 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1516 }
1517
1518 HWTEST_F(DeviceManagerServiceTest, RestoreLocalDeviceName_202, testing::ext::TestSize.Level1)
1519 {
1520 std::string pkgName = "pkgName";
1521 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
1522 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(ERR_DM_FAILED));
1523 int32_t ret = DeviceManagerService::GetInstance().RestoreLocalDeviceName(pkgName);
1524 EXPECT_EQ(ret, ERR_DM_FAILED);
1525
1526 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1527 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyLocalDeviceName(_)).WillOnce(Return(false));
1528 ret = DeviceManagerService::GetInstance().RestoreLocalDeviceName(pkgName);
1529 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1530
1531 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1532 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyLocalDeviceName(_)).WillOnce(Return(true));
1533 ret = DeviceManagerService::GetInstance().RestoreLocalDeviceName(pkgName);
1534 EXPECT_EQ(ret, DM_OK);
1535 }
1536
1537 HWTEST_F(DeviceManagerServiceTest, SetLocalDeviceName_201, testing::ext::TestSize.Level1)
1538 {
1539 std::string pkgName = "pkgName";
1540 std::string deviceName = "deviceName";
1541 DeletePermission();
1542 int32_t ret = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
1543 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1544 }
1545
1546 HWTEST_F(DeviceManagerServiceTest, SetLocalDeviceName_202, testing::ext::TestSize.Level1)
1547 {
1548 std::string pkgName = "pkgName";
1549 std::string deviceName = "deviceName";
1550 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
1551 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(ERR_DM_FAILED));
1552 int32_t ret = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
1553 EXPECT_EQ(ret, ERR_DM_FAILED);
1554
1555 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1556 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyLocalDeviceName(_)).WillOnce(Return(false));
1557 ret = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
1558 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1559
1560 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1561 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyLocalDeviceName(_)).WillOnce(Return(true));
1562 ret = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
1563 EXPECT_NE(ret, DM_OK);
1564 }
1565
1566 HWTEST_F(DeviceManagerServiceTest, SetRemoteDeviceName_201, testing::ext::TestSize.Level1)
1567 {
1568 std::string pkgName = "pkgName";
1569 std::string deviceName = "deviceName";
1570 std::string deviceId = "d*********9";
1571 DeletePermission();
1572 int32_t ret = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
1573 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1574 }
1575
1576 HWTEST_F(DeviceManagerServiceTest, SetRemoteDeviceName_202, testing::ext::TestSize.Level1)
1577 {
1578 std::string pkgName = "pkgName";
1579 std::string deviceName = "deviceName";
1580 std::string deviceId = "d*********9";
1581 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
1582 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(ERR_DM_FAILED));
1583 int32_t ret = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
1584 EXPECT_EQ(ret, ERR_DM_FAILED);
1585
1586 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1587 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyRemoteDeviceName(_)).WillOnce(Return(false));
1588 ret = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
1589 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1590
1591 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
1592 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyRemoteDeviceName(_)).WillOnce(Return(true));
1593 ret = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
1594 EXPECT_NE(ret, DM_OK);
1595 }
1596
1597 HWTEST_F(DeviceManagerServiceTest, GetDeviceNetworkIdList_201, testing::ext::TestSize.Level1)
1598 {
1599 std::string pkgName = "pkgName";
1600 NetworkIdQueryFilter queryFilter;
1601 std::vector<std::string> networkIds{"uehd*****87"};
1602 DeletePermission();
1603 int32_t ret = DeviceManagerService::GetInstance().GetDeviceNetworkIdList(pkgName, queryFilter, networkIds);
1604 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1605
1606 int32_t stopUserId = 1;
1607 std::string stopEventUdid = "ud*********4";
1608 std::vector<std::string> acceptEventUdids{"acc**********7"};
1609 DeviceManagerService::GetInstance().InitDMServiceListener();
1610 DeviceManagerService::GetInstance().HandleUserStop(stopUserId, stopEventUdid, acceptEventUdids);
1611 DeviceManagerService::GetInstance().HandleUserStop(stopUserId, stopEventUdid);
1612
1613 std::string localUdid = "local*******76";
1614 std::vector<std::string> peerUdids;
1615 DeviceManagerService::GetInstance().NotifyRemoteLocalUserStop(localUdid, peerUdids, stopUserId);
1616 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1617 DeviceManagerService::GetInstance().SendUserStopBroadCast(peerUdids, stopUserId);
1618 std::string remoteUdid = "re********7";
1619 DeviceManagerService::GetInstance().HandleUserStopBroadCast(stopUserId, remoteUdid);
1620
1621 std::map<std::string, std::string> wifiDevices;
1622 wifiDevices.insert(std::make_pair("wikjdmcsk", "deviceInfowifi"));
1623 EXPECT_CALL(*dMCommToolMock_, SendUserStop(_, _)).WillOnce(Return(ERR_DM_FAILED));
1624 DeviceManagerService::GetInstance().NotifyRemoteLocalUserStopByWifi(localUdid, wifiDevices, stopUserId);
1625
1626 EXPECT_CALL(*dMCommToolMock_, SendUserStop(_, _)).WillOnce(Return(DM_OK));
1627 DeviceManagerService::GetInstance().NotifyRemoteLocalUserStopByWifi(localUdid, wifiDevices, stopUserId);
1628 DeviceManagerService::GetInstance().UninitDMServiceListener();
1629 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1630 }
1631
1632 HWTEST_F(DeviceManagerServiceTest, GetDeviceNetworkIdList_202, testing::ext::TestSize.Level1)
1633 {
1634 std::string pkgName = "pkgName";
1635 NetworkIdQueryFilter queryFilter;
1636 std::vector<std::string> networkIds{"uehd*****87"};
1637 int32_t ret = DeviceManagerService::GetInstance().GetDeviceNetworkIdList(pkgName, queryFilter, networkIds);
1638 EXPECT_NE(ret, DM_OK);
1639
1640 int32_t stopUserId = 1;
1641 std::map<std::string, int32_t> deviceMap;
1642 DeviceManagerService::GetInstance().InitDMServiceListener();
1643 DeviceManagerService::GetInstance().HandleUserStopEvent(stopUserId);
1644
1645 std::vector<std::string> peerUdids;
1646 std::vector<std::string> bleUdids;
1647 std::map<std::string, std::string> wifiDevices;
1648 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1649
1650 peerUdids.push_back("u********23");
1651 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1652 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1653
1654 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1655 EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _))
1656 .WillOnce(DoAll(SetArgReferee<1>(""), Return(DM_OK)));
1657 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1658
1659 EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _))
1660 .WillOnce(DoAll(SetArgReferee<1>("net********8"), Return(DM_OK)));
1661 EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _))
1662 .WillOnce(DoAll(SetArgReferee<1>(4), Return(ERR_DM_FAILED)));
1663 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1664
1665 EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _))
1666 .WillOnce(DoAll(SetArgReferee<1>("net********8"), Return(DM_OK)));
1667 EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _))
1668 .WillOnce(DoAll(SetArgReferee<1>(4), Return(DM_OK)));
1669 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1670
1671 EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _))
1672 .WillOnce(DoAll(SetArgReferee<1>("net********8"), Return(DM_OK)));
1673 EXPECT_CALL(*softbusListenerMock_, GetNetworkTypeByNetworkId(_, _))
1674 .WillOnce(DoAll(SetArgReferee<1>(2), Return(DM_OK)));
1675 DeviceManagerService::GetInstance().DivideNotifyMethod(peerUdids, bleUdids, wifiDevices);
1676 DeviceManagerService::GetInstance().UninitDMServiceListener();
1677 }
1678
1679 HWTEST_F(DeviceManagerServiceTest, SendShareTypeUnBindBroadCast_001, testing::ext::TestSize.Level1)
1680 {
1681 const char *credId = "testCredId";
1682 int32_t localUserId = 1001;
1683 std::vector<std::string> peerUdids = {"peerUdid1", "peerUdid2"};
1684
1685 DeviceManagerService::GetInstance().SendShareTypeUnBindBroadCast(credId, localUserId, peerUdids);
1686 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1687 }
1688
1689 HWTEST_F(DeviceManagerServiceTest, HandleCredentialDeleted_002, testing::ext::TestSize.Level1)
1690 {
1691 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleCredentialDeleted(_, _, _, _, _)).Times(0);
1692
1693 DeviceManagerService::GetInstance().HandleCredentialDeleted(nullptr, "credInfo");
1694 }
1695
1696 HWTEST_F(DeviceManagerServiceTest, HandleCredentialDeleted_004, testing::ext::TestSize.Level1)
1697 {
1698 EXPECT_CALL(*multipleUserConnectorMock_, GetCurrentAccountUserID()).Times(0);
1699 EXPECT_CALL(*softbusListenerMock_, SendAclChangedBroadcast(_)).Times(0);
1700
1701 DeviceManagerService::GetInstance().HandleCredentialDeleted("credId", "credInfo");
1702 }
1703
1704 HWTEST_F(DeviceManagerServiceTest, HandleCredentialDeleted_005, testing::ext::TestSize.Level1)
1705 {
1706 const char *credId = "testCredId";
1707 const char *credInfo = R"({"deviceId": "remoteUdid", "userId": 1})";
1708 std::string localUdid = "localUdid";
1709 std::string remoteUdid = "remoteUdid";
1710 bool isSendBroadCast = false;
1711
1712 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleCredentialDeleted(StrEq(credId), StrEq(credInfo), _, _, _))
1713 .WillOnce(DoAll(SetArgReferee<3>(remoteUdid), SetArgReferee<4>(isSendBroadCast)));
1714
1715 DeviceManagerService::GetInstance().HandleCredentialDeleted(credId, credInfo);
1716 }
1717
1718 HWTEST_F(DeviceManagerServiceTest, HandleCredentialDeleted_006, testing::ext::TestSize.Level1)
1719 {
1720 const char *credId = "testCredId";
1721 const char *credInfo = R"({"deviceId": "remoteUdid", "userId": 1})";
1722 std::string localUdid = "localUdid";
1723 std::string remoteUdid = "remoteUdid";
1724 bool isSendBroadCast = true;
1725
1726 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleCredentialDeleted(StrEq(credId), StrEq(credInfo), _, _, _))
1727 .WillOnce(DoAll(SetArgReferee<3>(remoteUdid), SetArgReferee<4>(isSendBroadCast)));
1728
1729 DeviceManagerService::GetInstance().HandleCredentialDeleted(credId, credInfo);
1730 }
1731
1732 HWTEST_F(DeviceManagerServiceTest, HandleShareUnbindBroadCast_001, testing::ext::TestSize.Level1)
1733 {
1734 std::string credId = "123456";
1735 int32_t userId = 1001;
1736 std::string localUdid = "localUdid";
1737 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleShareUnbindBroadCast(_, _, _)).Times(1);
1738
1739 DeviceManagerService::GetInstance().HandleShareUnbindBroadCast(userId, credId);
1740 }
1741
1742 HWTEST_F(DeviceManagerServiceTest, HandleShareUnbindBroadCast_002, testing::ext::TestSize.Level1)
1743 {
1744 std::string credId = "";
1745 int32_t userId = 1001;
1746
1747 EXPECT_CALL(*deviceManagerServiceImplMock_, HandleShareUnbindBroadCast(_, _, _)).Times(0);
1748
1749 DeviceManagerService::GetInstance().HandleShareUnbindBroadCast(userId, credId);
1750 }
1751
1752 HWTEST_F(DeviceManagerServiceTest, HandleShareUnbindBroadCast_003, testing::ext::TestSize.Level1)
1753 {
1754 std::string credId = "123456";
1755 int32_t userId = 1001;
1756
1757 EXPECT_TRUE(DeviceManagerService::GetInstance().IsDMServiceImplReady());
1758
1759 DeviceManagerService::GetInstance().HandleShareUnbindBroadCast(userId, credId);
1760 }
1761
1762 HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceName_201, testing::ext::TestSize.Level1)
1763 {
1764 std::string deviceName = "123";
1765 std::string displayName = "";
1766 EXPECT_CALL(*permissionManagerMock_, CheckReadLocalDeviceName()).WillOnce(Return(true));
1767 EXPECT_CALL(*deviceNameManagerMock_, GetLocalDisplayDeviceName(_, _))
1768 .WillOnce(DoAll(SetArgReferee<1>(deviceName), Return(0)));
1769 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceName(displayName);
1770 EXPECT_EQ(ret, DM_OK);
1771 EXPECT_EQ(displayName, deviceName);
1772
1773 displayName = "";
1774 std::string marketName = "456";
1775 EXPECT_CALL(*permissionManagerMock_, CheckReadLocalDeviceName()).WillOnce(Return(false));
1776 EXPECT_CALL(*deviceNameManagerMock_, GetLocalMarketName()).WillOnce(Return(marketName));
1777 ret = DeviceManagerService::GetInstance().GetLocalDeviceName(displayName);
1778 EXPECT_EQ(ret, DM_OK);
1779 EXPECT_EQ(displayName, marketName);
1780 }
1781
1782 HWTEST_F(DeviceManagerServiceTest, ValidateUnBindDeviceParams_201, testing::ext::TestSize.Level1)
1783 {
1784 std::string pkgName = "";
1785 std::string deviceId = "";
1786 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1787 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId);
1788 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1789 }
1790
1791 HWTEST_F(DeviceManagerServiceTest, ValidateUnBindDeviceParams_202, testing::ext::TestSize.Level1)
1792 {
1793 std::string pkgName = "ohos.test.pkgName";
1794 std::string deviceId = "deviceId";
1795 DeletePermission();
1796 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId);
1797 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1798 }
1799
1800 HWTEST_F(DeviceManagerServiceTest, ValidateUnBindDeviceParams_203, testing::ext::TestSize.Level1)
1801 {
1802 std::string pkgName = "";
1803 std::string deviceId = "";
1804 std::string extra;
1805 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
1806 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId, extra);
1807 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1808 }
1809
1810 HWTEST_F(DeviceManagerServiceTest, ValidateUnBindDeviceParams_204, testing::ext::TestSize.Level1)
1811 {
1812 std::string pkgName = "ohos.test.pkgName";
1813 std::string deviceId = "deviceId";
1814 std::string extra;
1815 DeletePermission();
1816 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId, extra);
1817 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
1818 }
1819
1820 HWTEST_F(DeviceManagerServiceTest, SendUninstAppByWifi_001, testing::ext::TestSize.Level1)
1821 {
1822 int32_t userId = 1001;
1823 int32_t tokenId = 1002;
1824 std::string networkId = "networkId123";
1825 EXPECT_CALL(*dMCommToolMock_, SendUninstAppObj(_, _, _)).WillOnce(Return(DM_OK));
1826 int32_t ret = DeviceManagerService::GetInstance().SendUninstAppByWifi(userId, tokenId, networkId);
1827 EXPECT_EQ(ret, DM_OK);
1828 }
1829
1830 HWTEST_F(DeviceManagerServiceTest, SendUninstAppByWifi_002, testing::ext::TestSize.Level1)
1831 {
1832 int32_t userId = 1001;
1833 int32_t tokenId = 1002;
1834 std::string networkId = "networkId123";
1835 EXPECT_CALL(*dMCommToolMock_, SendUninstAppObj(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
1836 int32_t ret = DeviceManagerService::GetInstance().SendUninstAppByWifi(userId, tokenId, networkId);
1837 EXPECT_EQ(ret, ERR_DM_FAILED);
1838 }
1839
1840 HWTEST_F(DeviceManagerServiceTest, GetNotifyRemoteUnBindAppWay_001, testing::ext::TestSize.Level1)
1841 {
1842 int32_t userId = 1001;
1843 int32_t tokenId = 11;
1844 std::map<std::string, std::string> wifiDevices;
1845 bool isBleWay = false;
1846 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
1847 DeviceManagerService::GetInstance().GetNotifyRemoteUnBindAppWay(userId, tokenId, wifiDevices, isBleWay);
1848 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1849 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1850 }
1851 HWTEST_F(DeviceManagerServiceTest, GetNotifyRemoteUnBindAppWay_002, testing::ext::TestSize.Level1)
1852 {
1853 int32_t userId = 1001;
1854 int32_t tokenId = 11;
1855 std::map<std::string, std::string> wifiDevices;
1856 bool isBleWay = false;
1857 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
1858 DeviceManagerService::GetInstance().GetNotifyRemoteUnBindAppWay(userId, tokenId, wifiDevices, isBleWay);
1859 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
1860 }
1861
1862 #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
1863 HWTEST_F(DeviceManagerServiceTest, ConvertUdidHashToAnoyDeviceId_001, testing::ext::TestSize.Level1)
1864 {
1865 std::string udidHash;
1866 std::string result;
1867 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return(""));
1868 int32_t ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
1869 EXPECT_EQ(ret, ERR_DM_FAILED);
1870 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return("appId"));
1871 EXPECT_CALL(*cryptoMock_, ConvertUdidHashToAnoyAndSave(_, _, _)).WillOnce(Return(DM_OK));
1872 ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
1873 EXPECT_EQ(ret, DM_OK);
1874 EXPECT_CALL(*appManagerMock_, GetAppId()).WillOnce(Return("appId"));
1875 EXPECT_CALL(*cryptoMock_, ConvertUdidHashToAnoyAndSave(_, _, _)).WillOnce(Return(ERR_DM_FAILED));
1876 ret = DeviceManagerService::GetInstance().ConvertUdidHashToAnoyDeviceId(udidHash, result);
1877 EXPECT_EQ(ret, ERR_DM_FAILED);
1878 }
1879
1880 HWTEST_F(DeviceManagerServiceTest, GetUdidHashByAnoyDeviceId_001, testing::ext::TestSize.Level1)
1881 {
1882 std::string udidHash;
1883 std::string anoyDeviceId = "anoyDeviceId";
1884 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(DM_OK));
1885 int32_t ret = DeviceManagerService::GetInstance().GetUdidHashByAnoyDeviceId(anoyDeviceId, udidHash);
1886 EXPECT_EQ(ret, DM_OK);
1887 EXPECT_CALL(*kVAdapterManagerMock_, Get(_, _)).WillOnce(Return(ERR_DM_FAILED));
1888 ret = DeviceManagerService::GetInstance().GetUdidHashByAnoyDeviceId(anoyDeviceId, udidHash);
1889 EXPECT_EQ(ret, ERR_DM_FAILED);
1890 }
1891 #endif
1892 } // namespace
1893 } // namespace DistributedHardware
1894 } // namespace OHOS
1895