1 /*
2 * Copyright (c) 2022-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_three.h"
17
18 #include "accesstoken_kit.h"
19 #include "dm_constants.h"
20 #include "dm_device_info.h"
21 #include "dm_log.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "softbus_common.h"
25 #include "softbus_error_code.h"
26
27 using namespace OHOS::Security::AccessToken;
28 using namespace testing;
29 using namespace testing::ext;
30 namespace OHOS {
31 namespace DistributedHardware {
32
SetUp()33 void DeviceManagerServiceThreeTest::SetUp()
34 {
35 const int32_t permsNum = 4;
36 const int32_t indexZero = 0;
37 const int32_t indexOne = 1;
38 const int32_t indexTwo = 2;
39 const int32_t indexThree = 3;
40 uint64_t tokenId;
41 const char *perms[permsNum];
42 perms[indexZero] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
43 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
44 perms[indexTwo] = "ohos.permission.ACCESS_SERVICE_DM";
45 perms[indexThree] = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE";
46 NativeTokenInfoParams infoInstance = {
47 .dcapsNum = 0,
48 .permsNum = permsNum,
49 .aclsNum = 0,
50 .dcaps = NULL,
51 .perms = perms,
52 .acls = NULL,
53 .processName = "dsoftbus_service",
54 .aplStr = "system_core",
55 };
56 tokenId = GetAccessTokenId(&infoInstance);
57 SetSelfTokenID(tokenId);
58 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
59 }
60
TearDown()61 void DeviceManagerServiceThreeTest::TearDown()
62 {
63 Mock::VerifyAndClearExpectations(deviceManagerServiceMock_.get());
64 Mock::VerifyAndClearExpectations(permissionManagerMock_.get());
65 Mock::VerifyAndClearExpectations(softbusListenerMock_.get());
66 Mock::VerifyAndClearExpectations(deviceManagerServiceImplMock_.get());
67 }
68
SetUpTestCase()69 void DeviceManagerServiceThreeTest::SetUpTestCase()
70 {
71 DmDeviceManagerService::dmDeviceManagerService = deviceManagerServiceMock_;
72 DmPermissionManager::dmPermissionManager = permissionManagerMock_;
73 DmSoftbusListener::dmSoftbusListener = softbusListenerMock_;
74 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_;
75 }
76
TearDownTestCase()77 void DeviceManagerServiceThreeTest::TearDownTestCase()
78 {
79 DmDeviceManagerService::dmDeviceManagerService = nullptr;
80 deviceManagerServiceMock_ = nullptr;
81 DmPermissionManager::dmPermissionManager = nullptr;
82 permissionManagerMock_ = nullptr;
83 DmSoftbusListener::dmSoftbusListener = nullptr;
84 softbusListenerMock_ = nullptr;
85 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = nullptr;
86 deviceManagerServiceImplMock_ = nullptr;
87 }
88
89 namespace {
90
91 const int32_t SEND_DELAY_MAX_TIME = 5;
92
SetSetDnPolicyPermission()93 void SetSetDnPolicyPermission()
94 {
95 const int32_t permsNum = 1;
96 const int32_t indexZero = 0;
97 uint64_t tokenId;
98 const char *perms[permsNum];
99 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
100 NativeTokenInfoParams infoInstance = {
101 .dcapsNum = 0,
102 .permsNum = permsNum,
103 .aclsNum = 0,
104 .dcaps = NULL,
105 .perms = perms,
106 .acls = NULL,
107 .processName = "collaboration_service",
108 .aplStr = "system_core",
109 };
110 tokenId = GetAccessTokenId(&infoInstance);
111 SetSelfTokenID(tokenId);
112 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
113 }
114
115 /**
116 * @tc.name: AuthenticateDevice_301
117 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_NOT_INIT
118 * @tc.type: FUNC
119 * @tc.require: AR000GHSJK
120 */
121 HWTEST_F(DeviceManagerServiceThreeTest, AuthenticateDevice_301, testing::ext::TestSize.Level1)
122 {
123 std::string pkgName = "com.ohos.test";
124 std::string extra = "jdddd";
125 int32_t authType = 1;
126 std::string deviceId = "deviceId";
127 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
128 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
129 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
130 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
131 }
132
133 /**
134 * @tc.name: UnAuthenticateDevice_301
135 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
136 * value is SOFTBUS_IPC_ERR
137 * @tc.type: FUNC
138 * @tc.require: AR000GHSJK
139 */
140 HWTEST_F(DeviceManagerServiceThreeTest, UnAuthenticateDevice_301, testing::ext::TestSize.Level1)
141 {
142 std::string pkgName = "com.ohos.test";
143 std::string networkId = "12345";
144 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
145 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
146 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
147 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
148 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
149 }
150
151 /**
152 * @tc.name: SetUserOperation_301
153 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
154 * DM_OK
155 * @tc.type: FUNC
156 * @tc.require: AR000GHSJK
157 */
158 HWTEST_F(DeviceManagerServiceThreeTest, SetUserOperation_301, testing::ext::TestSize.Level1)
159 {
160 std::string pkgName = "pkgName";
161 int32_t action = 0;
162 const std::string param = "extra";
163 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
164 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
165 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
166 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
167 }
168
169 /**
170 * @tc.name: RequestCredential_301
171 * @tc.desc:The return value is ERR_DM_FAILED
172 * @tc.type: FUNC
173 * @tc.require: AR000GHSJK
174 */
175 HWTEST_F(DeviceManagerServiceThreeTest, RequestCredential_301, testing::ext::TestSize.Level1)
176 {
177 const std::string reqJsonStr = "test";
178 std::string returnJsonStr = "returntest";
179 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
180 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
181 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
182 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
183 }
184
185 /**
186 * @tc.name: ImportCredential_301
187 * @tc.desc:The return value is ERR_DM_NOT_INIT
188 * @tc.type: FUNC
189 * @tc.require: AR000GHSJK
190 */
191 HWTEST_F(DeviceManagerServiceThreeTest, ImportCredential_301, testing::ext::TestSize.Level1)
192 {
193 const std::string pkgName = "pkgNametest";
194 const std::string credentialInfo = "credentialInfotest";
195 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
196 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
197 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
198 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
199
200 std::string reqJsonStr = "";
201 std::string returnJsonStr = "";
202 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
203 ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
204 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
205 }
206
207 /**
208 * @tc.name: DeleteCredential_301
209 * @tc.desc:The return value is ERR_DM_FAILED
210 * @tc.type: FUNC
211 * @tc.require: AR000GHSJK
212 */
213 HWTEST_F(DeviceManagerServiceThreeTest, DeleteCredential_301, testing::ext::TestSize.Level1)
214 {
215 const std::string pkgName = "pkgNametest";
216 const std::string deleteInfo = "deleteInfotest";
217 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
218 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
219 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
220 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
221 }
222
223 /**
224 * @tc.name: RegisterCredentialCallback_301
225 * @tc.desc: The return value is DM_OK
226 * @tc.type: FUNC
227 * @tc.require: AR000GHSJK
228 */
229 HWTEST_F(DeviceManagerServiceThreeTest, RegisterCredentialCallback_301, testing::ext::TestSize.Level1)
230 {
231 const std::string pkgName = "pkgNametest";
232 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
233 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
234 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
235 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
236 }
237
238 HWTEST_F(DeviceManagerServiceThreeTest, BindDevice_301, testing::ext::TestSize.Level1)
239 {
240 std::string pkgName = "com.ohos.test";
241 int32_t authType = 1;
242 std::string deviceId = "1234";
243 std::string bindParam;
244 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
245 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
246 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
247 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
248 }
249
250 HWTEST_F(DeviceManagerServiceThreeTest, UnBindDevice_301, testing::ext::TestSize.Level1)
251 {
252 std::string pkgName = "com.ohos.test";
253 std::string deviceId = "1234";
254 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
255 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
256 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
257 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
258 }
259
260 HWTEST_F(DeviceManagerServiceThreeTest, MineRequestCredential_301, testing::ext::TestSize.Level1)
261 {
262 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
263 std::string pkgName;
264 std::string returnJsonStr;
265 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
266 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
267 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr);
268 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
269 }
270
271 HWTEST_F(DeviceManagerServiceThreeTest, CheckCredential_301, testing::ext::TestSize.Level1)
272 {
273 std::string pkgName;
274 std::string returnJsonStr;
275 std::string reqJsonStr;
276 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
277 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
278 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
279 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
280 }
281
282 HWTEST_F(DeviceManagerServiceThreeTest, RegisterUiStateCallback_301, testing::ext::TestSize.Level1)
283 {
284 std::string pkgName = "pkgName";
285 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
286 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
287 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
288 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
289 }
290
291 HWTEST_F(DeviceManagerServiceThreeTest, UnRegisterUiStateCallback_301, testing::ext::TestSize.Level1)
292 {
293 std::string pkgName = "pkgName";
294 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
295 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
296 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
297 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
298 }
299
300 HWTEST_F(DeviceManagerServiceThreeTest, NotifyEvent_301, testing::ext::TestSize.Level1)
301 {
302 std::string pkgName;
303 int32_t eventId = 0;
304 std::string event;
305 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
306 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
307 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
308 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
309 }
310
311 HWTEST_F(DeviceManagerServiceThreeTest, BindTarget_301, testing::ext::TestSize.Level1)
312 {
313 std::string pkgName = "pkgName";
314 PeerTargetId targetId;
315 std::map<std::string, std::string> bindParam;
316 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
317 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
318 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
319 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
320
321 bindParam.insert(std::make_pair(PARAM_KEY_META_TYPE, pkgName));
322 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
323 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
324 ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
325 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
326 }
327
328 HWTEST_F(DeviceManagerServiceThreeTest, DpAclAdd_301, testing::ext::TestSize.Level1)
329 {
330 std::string udid = "udid";
331 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
332 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
333 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid);
334 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
335 }
336
337 HWTEST_F(DeviceManagerServiceThreeTest, IsSameAccount_301, testing::ext::TestSize.Level1)
338 {
339 std::string udid = "udidTest";
340 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
341 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
342 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
343 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
344 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
345 }
346
347 HWTEST_F(DeviceManagerServiceThreeTest, CheckIsSameAccount_301, testing::ext::TestSize.Level1)
348 {
349 DmAccessCaller caller;
350 DmAccessCallee callee;
351 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
352 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
353 bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
354 EXPECT_FALSE(ret);
355 }
356
357 HWTEST_F(DeviceManagerServiceThreeTest, CheckAccessControl_301, testing::ext::TestSize.Level1)
358 {
359 DmAccessCaller caller;
360 DmAccessCallee callee;
361 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
362 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
363 bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
364 EXPECT_FALSE(ret);
365 }
366
367 HWTEST_F(DeviceManagerServiceThreeTest, StopAuthenticateDevice_301, testing::ext::TestSize.Level1)
368 {
369 std::string pkgName = "pkgName_003";
370 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
371 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
372 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
373 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
374 }
375
376 HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_301, testing::ext::TestSize.Level1)
377 {
378 std::string pkgName = "pkgName";
379 std::string authCode = "authCode";
380 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillRepeatedly(Return(true));
381 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
382 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
383 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
384 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
385 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
386
387 std::vector<DmDeviceInfo> deviceList;
388 DmDeviceInfo dmDeviceInfo;
389 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
390 deviceList.push_back(dmDeviceInfo);
391 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
392 EXPECT_CALL(*deviceManagerServiceMock_, GetTrustedDeviceList(_, _))
393 .WillOnce(DoAll(SetArgReferee<1>(deviceList), Return(DM_OK)));
394 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
395 DeviceManagerService::GetInstance().LoadHardwareFwkService();
396 }
397
398 HWTEST_F(DeviceManagerServiceThreeTest, ExportAuthCode_301, testing::ext::TestSize.Level1)
399 {
400 std::string authCode = "authCode";
401 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillRepeatedly(Return(true));
402 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
403 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
404 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
405 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
406 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
407
408 int32_t userId = 0;
409 std::string accountId;
410 std::string accountName;
411 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
412 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName);
413
414 int32_t preUserId = 1;
415 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
416 DeviceManagerService::GetInstance().HandleUserRemoved(preUserId);
417 }
418
419 HWTEST_F(DeviceManagerServiceThreeTest, UnbindTarget_301, testing::ext::TestSize.Level1)
420 {
421 std::string pkgName = "pkgName";
422 PeerTargetId targetId;
423 std::map<std::string, std::string> unbindParam;
424 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
425 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
426 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
427 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
428 }
429
430 HWTEST_F(DeviceManagerServiceThreeTest, SetDnPolicy_301, testing::ext::TestSize.Level1)
431 {
432 SetSetDnPolicyPermission();
433 std::string packName = "com.ohos.test";
434 std::map<std::string, std::string> policy;
435 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
436 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
437 std::string processName = "collaboration_service";
438 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillRepeatedly(Return(true));
439 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
440 .WillRepeatedly(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
441 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
442 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
443 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
444 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
445
446 std::string msg = "msg";
447 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
448 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
449 }
450
451 HWTEST_F(DeviceManagerServiceThreeTest, UnBindDevice_302, testing::ext::TestSize.Level1)
452 {
453 std::string pkgName = "com.ohos.test";
454 std::string deviceId = "1234";
455 std::string extra;
456 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
457 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
458 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
459 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
460 }
461
462 HWTEST_F(DeviceManagerServiceThreeTest, RegisterAuthenticationType_301, testing::ext::TestSize.Level1)
463 {
464 std::string pkgName = "pkgName";
465 std::map<std::string, std::string> authParam;
466 authParam.insert(std::make_pair(DM_AUTHENTICATION_TYPE, "123456"));
467 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
468 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
469 int32_t ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
470 EXPECT_EQ(ret, ERR_DM_INIT_FAILED);
471 }
472
473 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceProfileInfoList_301, testing::ext::TestSize.Level1)
474 {
475 std::string pkgName = "pkgName";
476 DmDeviceProfileInfoFilterOptions filterOptions;
477 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
478 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
479 int32_t ret = DeviceManagerService::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions);
480 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
481 }
482
483 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceIconInfo_301, testing::ext::TestSize.Level1)
484 {
485 std::string pkgName = "pkgName";
486 DmDeviceIconInfoFilterOptions filterOptions;
487 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
488 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
489 int32_t ret = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions);
490 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
491 }
492
493 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceInfo_301, testing::ext::TestSize.Level1)
494 {
495 std::string networkId = "networkId";
496 DmDeviceInfo deviceInfo;
497 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
498 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
499 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
500 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
501 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
502 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
503 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
504 }
505
506 HWTEST_F(DeviceManagerServiceThreeTest, PutDeviceProfileInfoList_301, testing::ext::TestSize.Level1)
507 {
508 std::string pkgName = "pkgName";
509 std::vector<DmDeviceProfileInfo> deviceProfileInfoList;
510 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
511 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
512 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidPutDeviceProfileInfoList(_)).WillOnce(Return(true));
513 int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList);
514 EXPECT_NE(ret, DM_OK);
515 }
516
517 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceNamePrefixs_301, testing::ext::TestSize.Level1)
518 {
519 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
520 auto ret = DeviceManagerService::GetInstance().GetDeviceNamePrefixs();
521 EXPECT_TRUE(ret.empty());
522 }
523
524 HWTEST_F(DeviceManagerServiceThreeTest, SetLocalDeviceName_301, testing::ext::TestSize.Level1)
525 {
526 std::string pkgName = "pkgName";
527 std::string deviceName = "deviceName";
528 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
529 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
530 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyLocalDeviceName(_)).WillOnce(Return(true));
531 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
532 int32_t ret = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
533 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
534 }
535
536 HWTEST_F(DeviceManagerServiceThreeTest, SetRemoteDeviceName_301, testing::ext::TestSize.Level1)
537 {
538 std::string pkgName = "pkgName";
539 std::string deviceName = "deviceName";
540 std::string deviceId = "d*********3";
541 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
542 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
543 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidModifyRemoteDeviceName(_)).WillOnce(Return(true));
544 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
545 int32_t ret = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
546 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
547 }
548
549 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceNetworkIdList_301, testing::ext::TestSize.Level1)
550 {
551 std::string pkgName = "pkgName";
552 NetworkIdQueryFilter queryFilter;
553 std::vector<std::string> networkIds{"uehd*****87"};
554 EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true));
555 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
556 int32_t ret = DeviceManagerService::GetInstance().GetDeviceNetworkIdList(pkgName, queryFilter, networkIds);
557 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
558 }
559
560 HWTEST_F(DeviceManagerServiceThreeTest, OnPinHolderSessionOpened_001, testing::ext::TestSize.Level1)
561 {
562 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
563 int sessionId = 0;
564 int result = 0;
565 void *data = nullptr;
566 unsigned int dataLen = 0;
567 int ret = DeviceManagerService::GetInstance().OnPinHolderSessionOpened(sessionId, result);
568 DeviceManagerService::GetInstance().OnPinHolderBytesReceived(sessionId, data, dataLen);
569 DeviceManagerService::GetInstance().OnPinHolderSessionClosed(sessionId);
570 EXPECT_NE(ret, DM_OK);
571 }
572
573 HWTEST_F(DeviceManagerServiceThreeTest, IsDMImplSoLoaded_001, testing::ext::TestSize.Level1)
574 {
575 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
576 bool ret = DeviceManagerService::GetInstance().IsDMImplSoLoaded();
577 EXPECT_FALSE(ret);
578 }
579
580 HWTEST_F(DeviceManagerServiceThreeTest, DmHiDumper_001, testing::ext::TestSize.Level1)
581 {
582 std::vector<std::string> args;
583 std::string result;
584 int32_t ret = DeviceManagerService::GetInstance().DmHiDumper(args, result);
585 EXPECT_EQ(ret, DM_OK);
586 }
587
588 HWTEST_F(DeviceManagerServiceThreeTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level1)
589 {
590 std::string pkgName;
591 std::string uuid;
592 std::string appId;
593 std::string encryptedUuid;
594 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
595 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
596 }
597
598 HWTEST_F(DeviceManagerServiceThreeTest, GenerateEncryptedUuid_002, testing::ext::TestSize.Level1)
599 {
600 std::string pkgName = "pkgName";
601 std::string uuid;
602 std::string appId;
603 std::string encryptedUuid;
604 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
605 EXPECT_EQ(ret, DM_OK);
606 }
607
608 HWTEST_F(DeviceManagerServiceThreeTest, HandleDeviceStatusChange_001, testing::ext::TestSize.Level1)
609 {
610 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
611 DmDeviceInfo devInfo;
612 DeviceManagerService::GetInstance().HandleDeviceStatusChange(devState, devInfo);
613 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
614 }
615
616 HWTEST_F(DeviceManagerServiceThreeTest, SendAppUnBindBroadCast_001, testing::ext::TestSize.Level1)
617 {
618 std::vector<std::string> peerUdids;
619 int32_t userId = 12;
620 uint64_t tokenId = 23;
621 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
622 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId);
623 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
624 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
625 }
626
627 HWTEST_F(DeviceManagerServiceThreeTest, SendAppUnBindBroadCast_002, testing::ext::TestSize.Level1)
628 {
629 std::vector<std::string> peerUdids;
630 int32_t userId = 12;
631 uint64_t peerTokenId = 3;
632 uint64_t tokenId = 23;
633 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
634 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId, peerTokenId);
635 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
636 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
637 }
638
639 HWTEST_F(DeviceManagerServiceThreeTest, SendServiceUnBindBroadCast_001, testing::ext::TestSize.Level1)
640 {
641 std::vector<std::string> peerUdids;
642 int32_t userId = 12;
643 uint64_t tokenId = 23;
644 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
645 DeviceManagerService::GetInstance().SendServiceUnBindBroadCast(peerUdids, userId, tokenId);
646 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
647 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
648 }
649
650 HWTEST_F(DeviceManagerServiceThreeTest, ClearDiscoveryCache_001, testing::ext::TestSize.Level1)
651 {
652 ProcessInfo processInfo;
653 processInfo.pkgName = "pkgName001";
654 DeviceManagerService::GetInstance().InitDMServiceListener();
655 DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
656 EXPECT_NE(DeviceManagerService::GetInstance().discoveryMgr_, nullptr);
657 DeviceManagerService::GetInstance().UninitDMServiceListener();
658 }
659
660 HWTEST_F(DeviceManagerServiceThreeTest, GetProxyInfosByParseExtra_001, testing::ext::TestSize.Level1)
661 {
662 std::string pkgName = "pkgName";
663 std::string extra = "extra";
664 std::vector<std::pair<int64_t, int64_t>> agentToProxyVec;
665 std::set<std::pair<std::string, std::string>> proxyInfos;
666 DeviceManagerService::GetInstance().InitDMServiceListener();
667 proxyInfos = DeviceManagerService::GetInstance().GetProxyInfosByParseExtra(pkgName, extra, agentToProxyVec);
668 DeviceManagerService::GetInstance().UninitDMServiceListener();
669 EXPECT_NE(proxyInfos.empty(), true);
670 }
671
672 HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_302, testing::ext::TestSize.Level1)
673 {
674 std::string pkgName;
675 std::string authCode;
676 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
677 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
678 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(false));
679 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
680 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
681 }
682
683 HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_303, testing::ext::TestSize.Level1)
684 {
685 std::string pkgName;
686 std::string authCode;
687 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
688 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(ERR_DM_FAILED));
689 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
690 EXPECT_EQ(ret, ERR_DM_FAILED);
691 }
692
693 HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_304, testing::ext::TestSize.Level1)
694 {
695 std::string pkgName;
696 std::string authCode;
697 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
698 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
699 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
700 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
701 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
702 }
703
704 HWTEST_F(DeviceManagerServiceThreeTest, ValidateUnBindDeviceParams_301, testing::ext::TestSize.Level1)
705 {
706 std::string pkgName = "ohos.test.pkgName";
707 std::string deviceId = "deviceId";
708 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
709 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(ERR_DM_FAILED));
710 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId);
711 EXPECT_EQ(ret, DM_OK);
712 }
713
714 HWTEST_F(DeviceManagerServiceThreeTest, ValidateUnBindDeviceParams_302, testing::ext::TestSize.Level1)
715 {
716 std::string pkgName = "ohos.test.pkgName";
717 std::string deviceId = "deviceId";
718 std::string extra;
719 EXPECT_CALL(*permissionManagerMock_, CheckNewPermission()).WillOnce(Return(true));
720 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(ERR_DM_FAILED));
721 int32_t ret = DeviceManagerService::GetInstance().ValidateUnBindDeviceParams(pkgName, deviceId, extra);
722 EXPECT_EQ(ret, DM_OK);
723 }
724
725 HWTEST_F(DeviceManagerServiceThreeTest, ProcessUninstApp_301, testing::ext::TestSize.Level1)
726 {
727 int32_t userId = 100;
728 int32_t tokenId = 200;
729 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
730 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
731 DeviceManagerService::GetInstance().ProcessUninstApp(userId, tokenId);
732 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
733 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
734 }
735
736 HWTEST_F(DeviceManagerServiceThreeTest, ProcessUnBindApp_301, testing::ext::TestSize.Level1)
737 {
738 int32_t userId = 100;
739 int32_t tokenId = 200;
740 std::string extra;
741 std::string udid = "ohos.test.udid";
742 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
743 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
744 DeviceManagerService::GetInstance().ProcessUnBindApp(userId, tokenId, extra, udid);
745 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
746 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
747 }
748
749 HWTEST_F(DeviceManagerServiceThreeTest, CalculateBroadCastDelayTime_001, testing::ext::TestSize.Level1)
750 {
751 DeviceManagerService::GetInstance().SendLastBroadCastTime_ = 10;
752 int32_t delayTime = DeviceManagerService::GetInstance().CalculateBroadCastDelayTime();
753 EXPECT_NE(delayTime, SEND_DELAY_MAX_TIME);
754 }
755
756 HWTEST_F(DeviceManagerServiceThreeTest, CalculateBroadCastDelayTime_002, testing::ext::TestSize.Level1)
757 {
758 int32_t delayTime = DeviceManagerService::GetInstance().CalculateBroadCastDelayTime();
759 EXPECT_NE(delayTime, SEND_DELAY_MAX_TIME);
760 }
761 HWTEST_F(DeviceManagerServiceThreeTest, ParseRelationShipChangeType_001, testing::ext::TestSize.Level1)
762 {
763 RelationShipChangeMsg msg;
764 msg.type = RelationShipChangeType::APP_UNINSTALL;
765 auto ret = DeviceManagerService::GetInstance().ParseRelationShipChangeType(msg);
766 EXPECT_EQ(ret, true);
767 }
768
769 HWTEST_F(DeviceManagerServiceThreeTest, SubscribePackageCommonEvent_301, testing::ext::TestSize.Level1)
770 {
771 DeviceManagerService::GetInstance().packageCommonEventManager_ = std::make_shared<DmPackageCommonEventManager>();
772 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
773 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
774 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
775
776 }
777
778 HWTEST_F(DeviceManagerServiceThreeTest, SubscribePackageCommonEvent_302, testing::ext::TestSize.Level1)
779 {
780 DeviceManagerService::GetInstance().packageCommonEventManager_ = std::make_shared<DmPackageCommonEventManager>();
781 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
782 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
783 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
784 }
785
786 HWTEST_F(DeviceManagerServiceThreeTest, SubscribePackageCommonEvent_303, testing::ext::TestSize.Level1)
787 {
788 DeviceManagerService::GetInstance().packageCommonEventManager_ = nullptr;
789 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
790 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
791 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
792 }
793
794 HWTEST_F(DeviceManagerServiceThreeTest, SubscribePackageCommonEvent_304, testing::ext::TestSize.Level1)
795 {
796 DeviceManagerService::GetInstance().packageCommonEventManager_ = nullptr;
797 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
798 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
799 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
800 }
801
802 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUninstallApp_301, testing::ext::TestSize.Level1)
803 {
804 int32_t userId = 100;
805 int32_t tokenId = 200;
806 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
807 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
808 DeviceManagerService::GetInstance().NotifyRemoteUninstallApp(userId, tokenId);
809 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr);
810 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
811 }
812
813 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUninstallApp_302, testing::ext::TestSize.Level1)
814 {
815 int32_t userId = 100;
816 int32_t tokenId = 200;
817 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
818 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
819 DeviceManagerService::GetInstance().NotifyRemoteUninstallApp(userId, tokenId);
820 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr);
821 }
822
823 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUninstallAppByWifi_001, testing::ext::TestSize.Level1)
824 {
825 int32_t userId = 100;
826 int32_t tokenId = 200;
827 std::map<std::string, std::string> wifiDevices;
828 DeviceManagerService::GetInstance().timer_ = nullptr;
829 DeviceManagerService::GetInstance().NotifyRemoteUninstallAppByWifi(userId, tokenId, wifiDevices);
830 EXPECT_EQ(DeviceManagerService::GetInstance().timer_, nullptr);
831 }
832
833 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUninstallAppByWifi_002, testing::ext::TestSize.Level1)
834 {
835 int32_t userId = 100;
836 int32_t tokenId = 200;
837 std::map<std::string, std::string> wifiDevices;
838 DeviceManagerService::GetInstance().timer_ = std::make_shared<DmTimer>();
839 DeviceManagerService::GetInstance().NotifyRemoteUninstallAppByWifi(userId, tokenId, wifiDevices);
840 EXPECT_NE(DeviceManagerService::GetInstance().timer_, nullptr);
841 }
842
843 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUninstallAppByWifi_003, testing::ext::TestSize.Level1)
844 {
845 int32_t userId = 100;
846 int32_t tokenId = 200;
847 std::map<std::string, std::string> wifiDevices;
848 DeviceManagerService::GetInstance().timer_ = nullptr;
849 DeviceManagerService::GetInstance().NotifyRemoteUninstallAppByWifi(userId, tokenId, wifiDevices);
850 EXPECT_EQ(DeviceManagerService::GetInstance().timer_, nullptr);
851 }
852
853 HWTEST_F(DeviceManagerServiceThreeTest, NotifyRemoteUnBindAppByWifi_001, testing::ext::TestSize.Level1)
854 {
855 int32_t userId = 100;
856 int32_t tokenId = 200;
857 std::map<std::string, std::string> wifiDevices;
858 std::string extra;
859 DeviceManagerService::GetInstance().timer_ = std::make_shared<DmTimer>();
860 DeviceManagerService::GetInstance().NotifyRemoteUnBindAppByWifi(userId, tokenId, extra, wifiDevices);
861 EXPECT_NE(DeviceManagerService::GetInstance().timer_, nullptr);
862 }
863
864 HWTEST_F(DeviceManagerServiceThreeTest, ProcessReceiveRspAppUninstall_301, testing::ext::TestSize.Level1)
865 {
866 std::string remoteUdid = "ohos";
867 DeviceManagerService::GetInstance().timer_ = std::make_shared<DmTimer>();
868 DeviceManagerService::GetInstance().ProcessReceiveRspAppUninstall(remoteUdid);
869 EXPECT_NE(DeviceManagerService::GetInstance().timer_, nullptr);
870 }
871
872 HWTEST_F(DeviceManagerServiceThreeTest, ProcessReceiveRspAppUninstall_302, testing::ext::TestSize.Level1)
873 {
874 std::string remoteUdid = "ohos";
875 DeviceManagerService::GetInstance().timer_ = nullptr;
876 DeviceManagerService::GetInstance().ProcessReceiveRspAppUninstall(remoteUdid);
877 EXPECT_EQ(DeviceManagerService::GetInstance().timer_, nullptr);
878 }
879
880 HWTEST_F(DeviceManagerServiceThreeTest, ProcessReceiveRspAppUnbind_301, testing::ext::TestSize.Level1)
881 {
882 std::string remoteUdid = "ohos";
883 DeviceManagerService::GetInstance().timer_ = std::make_shared<DmTimer>();
884 DeviceManagerService::GetInstance().ProcessReceiveRspAppUnbind(remoteUdid);
885 EXPECT_NE(DeviceManagerService::GetInstance().timer_, nullptr);
886 }
887
888 HWTEST_F(DeviceManagerServiceThreeTest, ProcessReceiveRspAppUnbind_302, testing::ext::TestSize.Level1)
889 {
890 std::string remoteUdid = "ohos";
891 DeviceManagerService::GetInstance().timer_ = nullptr;
892 DeviceManagerService::GetInstance().ProcessReceiveRspAppUnbind(remoteUdid);
893 EXPECT_EQ(DeviceManagerService::GetInstance().timer_, nullptr);
894 }
895
896 HWTEST_F(DeviceManagerServiceThreeTest, StartDetectDeviceRisk_301, testing::ext::TestSize.Level1)
897 {
898 DeviceManagerService::GetInstance().isDeviceRiskDetectSoLoaded_ = false;
899 DeviceManagerService::GetInstance().StartDetectDeviceRisk();
900 EXPECT_EQ(DeviceManagerService::GetInstance().isDeviceRiskDetectSoLoaded_, false);
901 }
902
903 HWTEST_F(DeviceManagerServiceThreeTest, UnloadDMDeviceRiskDetect_301, testing::ext::TestSize.Level1)
904 {
905 DeviceManagerService::GetInstance().UnloadDMDeviceRiskDetect();
906 EXPECT_EQ(DeviceManagerService::GetInstance().dmDeviceRiskDetect_, nullptr);
907 }
908 } // namespace
909 } // namespace DistributedHardware
910 } // namespace OHOS
911