1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "UTTest_device_manager_service_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 }
64
SetUpTestCase()65 void DeviceManagerServiceThreeTest::SetUpTestCase()
66 {
67 DmDeviceManagerService::dmDeviceManagerService = deviceManagerServiceMock_;
68 DmPermissionManager::dmPermissionManager = permissionManagerMock_;
69 DmSoftbusListener::dmSoftbusListener = softbusListenerMock_;
70 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = deviceManagerServiceImplMock_;
71 }
72
TearDownTestCase()73 void DeviceManagerServiceThreeTest::TearDownTestCase()
74 {
75 DmDeviceManagerService::dmDeviceManagerService = nullptr;
76 deviceManagerServiceMock_ = nullptr;
77 DmPermissionManager::dmPermissionManager = nullptr;
78 permissionManagerMock_ = nullptr;
79 DmSoftbusListener::dmSoftbusListener = nullptr;
80 softbusListenerMock_ = nullptr;
81 DmDeviceManagerServiceImpl::dmDeviceManagerServiceImpl = nullptr;
82 deviceManagerServiceImplMock_ = nullptr;
83 }
84
85 namespace {
86
SetSetDnPolicyPermission()87 void SetSetDnPolicyPermission()
88 {
89 const int32_t permsNum = 1;
90 const int32_t indexZero = 0;
91 uint64_t tokenId;
92 const char *perms[permsNum];
93 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
94 NativeTokenInfoParams infoInstance = {
95 .dcapsNum = 0,
96 .permsNum = permsNum,
97 .aclsNum = 0,
98 .dcaps = NULL,
99 .perms = perms,
100 .acls = NULL,
101 .processName = "collaboration_service",
102 .aplStr = "system_core",
103 };
104 tokenId = GetAccessTokenId(&infoInstance);
105 SetSelfTokenID(tokenId);
106 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
107 }
108
109 /**
110 * @tc.name: AuthenticateDevice_301
111 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_NOT_INIT
112 * @tc.type: FUNC
113 * @tc.require: AR000GHSJK
114 */
115 HWTEST_F(DeviceManagerServiceThreeTest, AuthenticateDevice_301, testing::ext::TestSize.Level0)
116 {
117 std::string pkgName = "com.ohos.test";
118 std::string extra = "jdddd";
119 int32_t authType = 1;
120 std::string deviceId = "deviceId";
121 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
122 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
123 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
124 }
125
126 /**
127 * @tc.name: UnAuthenticateDevice_301
128 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return
129 * value is SOFTBUS_IPC_ERR
130 * @tc.type: FUNC
131 * @tc.require: AR000GHSJK
132 */
133 HWTEST_F(DeviceManagerServiceThreeTest, UnAuthenticateDevice_301, testing::ext::TestSize.Level0)
134 {
135 std::string pkgName = "com.ohos.test";
136 std::string networkId = "12345";
137 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
138 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
139 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId);
140 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
141 }
142
143 /**
144 * @tc.name: SetUserOperation_301
145 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is
146 * DM_OK
147 * @tc.type: FUNC
148 * @tc.require: AR000GHSJK
149 */
150 HWTEST_F(DeviceManagerServiceThreeTest, SetUserOperation_301, testing::ext::TestSize.Level0)
151 {
152 std::string pkgName = "pkgName";
153 int32_t action = 0;
154 const std::string param = "extra";
155 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
156 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param);
157 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
158 }
159
160 /**
161 * @tc.name: RequestCredential_301
162 * @tc.desc:The return value is ERR_DM_FAILED
163 * @tc.type: FUNC
164 * @tc.require: AR000GHSJK
165 */
166 HWTEST_F(DeviceManagerServiceThreeTest, RequestCredential_301, testing::ext::TestSize.Level0)
167 {
168 const std::string reqJsonStr = "test";
169 std::string returnJsonStr = "returntest";
170 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
171 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr);
172 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
173 }
174
175 /**
176 * @tc.name: ImportCredential_301
177 * @tc.desc:The return value is ERR_DM_NOT_INIT
178 * @tc.type: FUNC
179 * @tc.require: AR000GHSJK
180 */
181 HWTEST_F(DeviceManagerServiceThreeTest, ImportCredential_301, testing::ext::TestSize.Level0)
182 {
183 const std::string pkgName = "pkgNametest";
184 const std::string credentialInfo = "credentialInfotest";
185 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
186 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo);
187 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
188
189 std::string reqJsonStr = "";
190 std::string returnJsonStr = "";
191 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
192 ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
193 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
194 }
195
196 /**
197 * @tc.name: DeleteCredential_301
198 * @tc.desc:The return value is ERR_DM_FAILED
199 * @tc.type: FUNC
200 * @tc.require: AR000GHSJK
201 */
202 HWTEST_F(DeviceManagerServiceThreeTest, DeleteCredential_301, testing::ext::TestSize.Level0)
203 {
204 const std::string pkgName = "pkgNametest";
205 const std::string deleteInfo = "deleteInfotest";
206 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
207 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo);
208 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
209 }
210
211 /**
212 * @tc.name: RegisterCredentialCallback_301
213 * @tc.desc: The return value is DM_OK
214 * @tc.type: FUNC
215 * @tc.require: AR000GHSJK
216 */
217 HWTEST_F(DeviceManagerServiceThreeTest, RegisterCredentialCallback_301, testing::ext::TestSize.Level0)
218 {
219 const std::string pkgName = "pkgNametest";
220 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
221 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName);
222 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
223 }
224
225 HWTEST_F(DeviceManagerServiceThreeTest, BindDevice_301, testing::ext::TestSize.Level0)
226 {
227 std::string pkgName = "com.ohos.test";
228 int32_t authType = 1;
229 std::string deviceId = "1234";
230 std::string bindParam;
231 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
232 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam);
233 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
234 }
235
236 HWTEST_F(DeviceManagerServiceThreeTest, UnBindDevice_301, testing::ext::TestSize.Level0)
237 {
238 std::string pkgName = "com.ohos.test";
239 std::string deviceId = "1234";
240 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
241 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId);
242 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
243 }
244
245 HWTEST_F(DeviceManagerServiceThreeTest, MineRequestCredential_301, testing::ext::TestSize.Level0)
246 {
247 DeviceManagerService::GetInstance().isImplsoLoaded_ = false;
248 std::string pkgName;
249 std::string returnJsonStr;
250 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
251 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr);
252 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
253 }
254
255 HWTEST_F(DeviceManagerServiceThreeTest, CheckCredential_301, testing::ext::TestSize.Level0)
256 {
257 std::string pkgName;
258 std::string returnJsonStr;
259 std::string reqJsonStr;
260 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
261 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr);
262 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
263 }
264
265 HWTEST_F(DeviceManagerServiceThreeTest, RegisterUiStateCallback_301, testing::ext::TestSize.Level0)
266 {
267 std::string pkgName = "pkgName";
268 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
269 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
270 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
271 }
272
273 HWTEST_F(DeviceManagerServiceThreeTest, UnRegisterUiStateCallback_301, testing::ext::TestSize.Level0)
274 {
275 std::string pkgName = "pkgName";
276 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
277 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
278 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
279 }
280
281 HWTEST_F(DeviceManagerServiceThreeTest, NotifyEvent_301, testing::ext::TestSize.Level0)
282 {
283 std::string pkgName;
284 int32_t eventId = 0;
285 std::string event;
286 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
287 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
288 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
289 }
290
291 HWTEST_F(DeviceManagerServiceThreeTest, BindTarget_301, testing::ext::TestSize.Level0)
292 {
293 std::string pkgName = "pkgName";
294 PeerTargetId targetId;
295 std::map<std::string, std::string> bindParam;
296 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
297 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
298 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
299
300 bindParam.insert(std::make_pair(PARAM_KEY_META_TYPE, pkgName));
301 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(true));
302 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
303 ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
304 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
305 }
306
307 HWTEST_F(DeviceManagerServiceThreeTest, DpAclAdd_301, testing::ext::TestSize.Level0)
308 {
309 std::string udid = "udid";
310 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
311 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid);
312 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
313 }
314
315 HWTEST_F(DeviceManagerServiceThreeTest, IsSameAccount_301, testing::ext::TestSize.Level0)
316 {
317 std::string udid = "udidTest";
318 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
319 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
320 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid);
321 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
322 }
323
324 HWTEST_F(DeviceManagerServiceThreeTest, CheckIsSameAccount_301, testing::ext::TestSize.Level0)
325 {
326 DmAccessCaller caller;
327 DmAccessCallee callee;
328 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
329 bool ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
330 EXPECT_FALSE(ret);
331 }
332
333 HWTEST_F(DeviceManagerServiceThreeTest, CheckAccessControl_301, testing::ext::TestSize.Level0)
334 {
335 DmAccessCaller caller;
336 DmAccessCallee callee;
337 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
338 bool ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
339 EXPECT_FALSE(ret);
340 }
341
342 HWTEST_F(DeviceManagerServiceThreeTest, StopAuthenticateDevice_301, testing::ext::TestSize.Level0)
343 {
344 std::string pkgName = "pkgName_003";
345 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
346 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
347 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
348 }
349
350 HWTEST_F(DeviceManagerServiceThreeTest, ImportAuthCode_301, testing::ext::TestSize.Level0)
351 {
352 std::string pkgName = "pkgName";
353 std::string authCode = "authCode";
354 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
355 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
356 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
357 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
358 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
359
360 std::vector<DmDeviceInfo> deviceList;
361 DmDeviceInfo dmDeviceInfo;
362 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
363 deviceList.push_back(dmDeviceInfo);
364 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
365 EXPECT_CALL(*deviceManagerServiceMock_, GetTrustedDeviceList(_, _))
366 .WillOnce(DoAll(SetArgReferee<1>(deviceList), Return(DM_OK)));
367 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
368 DeviceManagerService::GetInstance().LoadHardwareFwkService();
369 }
370
371 HWTEST_F(DeviceManagerServiceThreeTest, ExportAuthCode_301, testing::ext::TestSize.Level0)
372 {
373 std::string authCode = "authCode";
374 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_)).WillOnce(Return(DM_OK));
375 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnAuthCode(_)).WillOnce(Return(true));
376 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
377 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
378 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
379
380 int32_t userId = 0;
381 std::string accountId;
382 std::string accountName;
383 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterSoLoaded()).WillOnce(Return(false));
384 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
385 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
386 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName);
387
388 int32_t curUserId = 0;
389 int32_t preUserId = 1;
390 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
391 DeviceManagerService::GetInstance().HandleUserSwitched(curUserId, preUserId);
392
393 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
394 DeviceManagerService::GetInstance().HandleUserRemoved(preUserId);
395 }
396
397 HWTEST_F(DeviceManagerServiceThreeTest, UnbindTarget_301, testing::ext::TestSize.Level0)
398 {
399 std::string pkgName = "pkgName";
400 PeerTargetId targetId;
401 std::map<std::string, std::string> unbindParam;
402 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
403 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
404 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
405 }
406
407 HWTEST_F(DeviceManagerServiceThreeTest, SetDnPolicy_301, testing::ext::TestSize.Level0)
408 {
409 SetSetDnPolicyPermission();
410 std::string packName = "com.ohos.test";
411 std::map<std::string, std::string> policy;
412 policy[PARAM_KEY_POLICY_STRATEGY_FOR_BLE] = "100";
413 policy[PARAM_KEY_POLICY_TIME_OUT] = "10";
414 std::string processName = "collaboration_service";
415 EXPECT_CALL(*permissionManagerMock_, GetCallerProcessName(_))
416 .WillOnce(DoAll(SetArgReferee<0>(processName), Return(DM_OK)));
417 EXPECT_CALL(*permissionManagerMock_, CheckProcessNameValidOnSetDnPolicy(_)).WillOnce(Return(true));
418 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
419 int32_t ret = DeviceManagerService::GetInstance().SetDnPolicy(packName, policy);
420 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
421
422 std::string msg = "msg";
423 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
424 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
425 }
426
427 HWTEST_F(DeviceManagerServiceThreeTest, UnBindDevice_302, testing::ext::TestSize.Level0)
428 {
429 std::string pkgName = "com.ohos.test";
430 std::string deviceId = "1234";
431 std::string extra;
432 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
433 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId, extra);
434 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
435 }
436
437 HWTEST_F(DeviceManagerServiceThreeTest, RegisterAuthenticationType_301, testing::ext::TestSize.Level0)
438 {
439 std::string pkgName = "pkgName";
440 std::map<std::string, std::string> authParam;
441 authParam.insert(std::make_pair(DM_AUTHENTICATION_TYPE, "123456"));
442 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
443 int32_t ret = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
444 EXPECT_EQ(ret, ERR_DM_INIT_FAILED);
445 }
446
447 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceProfileInfoList_301, testing::ext::TestSize.Level0)
448 {
449 std::string pkgName = "pkgName";
450 DmDeviceProfileInfoFilterOptions filterOptions;
451 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
452 int32_t ret = DeviceManagerService::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions);
453 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
454 }
455
456 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceIconInfo_301, testing::ext::TestSize.Level0)
457 {
458 std::string pkgName = "pkgName";
459 DmDeviceIconInfoFilterOptions filterOptions;
460 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
461 int32_t ret = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions);
462 EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD);
463 }
464
465 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceInfo_301, testing::ext::TestSize.Level0)
466 {
467 std::string networkId = "networkId";
468 DmDeviceInfo deviceInfo;
469 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
470 EXPECT_CALL(*softbusListenerMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
471 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceImplReady()).WillOnce(Return(false));
472 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
473 EXPECT_EQ(ret, ERR_DM_NOT_INIT);
474 DeviceManagerService::GetInstance().softbusListener_ = nullptr;
475 }
476
477 HWTEST_F(DeviceManagerServiceThreeTest, PutDeviceProfileInfoList_301, testing::ext::TestSize.Level0)
478 {
479 std::string pkgName = "pkgName";
480 std::vector<DmDeviceProfileInfo> deviceProfileInfoList;
481 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
482 int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList);
483 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
484 }
485
486 HWTEST_F(DeviceManagerServiceThreeTest, GetDeviceNamePrefixs_301, testing::ext::TestSize.Level0)
487 {
488 EXPECT_CALL(*deviceManagerServiceMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false));
489 auto ret = DeviceManagerService::GetInstance().GetDeviceNamePrefixs();
490 EXPECT_TRUE(ret.empty());
491 }
492 } // namespace
493 } // namespace DistributedHardware
494 } // namespace OHOS
495