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