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_impl.h"
17 #include "softbus_error_code.h"
18 #include "common_event_support.h"
19 #include "deviceprofile_connector.h"
20 #include "distributed_device_profile_client.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace OHOS::DistributedDeviceProfile;
25 namespace OHOS {
26 namespace DistributedHardware {
SetUp()27 void DeviceManagerServiceImplTest::SetUp()
28 {
29 if (deviceManagerServiceImpl_ == nullptr) {
30 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
31 }
32 deviceManagerServiceImpl_->Initialize(listener_);
33 }
34 const std::string TEST_ID("111111");
35
TearDown()36 void DeviceManagerServiceImplTest::TearDown()
37 {
38 }
39
SetUpTestCase()40 void DeviceManagerServiceImplTest::SetUpTestCase()
41 {
42 DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_;
43 DmSoftbusConnector::dmSoftbusConnector = softbusConnectorMock_;
44 DmDmDeviceStateManager::dmDeviceStateManager = dmDeviceStateManagerMock_;
45 DmMineHiChainConnector::dmMineHiChainConnector = mineHiChainConnectorMock_;
46 }
47
TearDownTestCase()48 void DeviceManagerServiceImplTest::TearDownTestCase()
49 {
50 DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr;
51 deviceProfileConnectorMock_ = nullptr;
52 DmSoftbusConnector::dmSoftbusConnector = nullptr;
53 softbusConnectorMock_ = nullptr;
54 DmDmDeviceStateManager::dmDeviceStateManager = nullptr;
55 dmDeviceStateManagerMock_ = nullptr;
56 DmMineHiChainConnector::dmMineHiChainConnector = nullptr;
57 mineHiChainConnectorMock_ = nullptr;
58 }
59
60 namespace {
CheckSoftbusRes(int32_t ret)61 bool CheckSoftbusRes(int32_t ret)
62 {
63 return ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR ||
64 ret == SOFTBUS_IPC_ERR;
65 }
66
AddAccessControlProfileFirst(std::vector<AccessControlProfile> & accessControlProfiles)67 void AddAccessControlProfileFirst(std::vector<AccessControlProfile>& accessControlProfiles)
68 {
69 int32_t userId = 123456;
70 int32_t bindType = 4;
71 int32_t deviceIdType = 1;
72 uint32_t bindLevel = DEVICE;
73 uint32_t status = 0;
74 uint32_t authenticationType = 2;
75 uint32_t accesserId = 1;
76 uint32_t tokenId = 1001;
77
78 std::string oldAccountId = "accountId_123";
79 std::string newAccountId = "accountId_456";
80 std::string deviceId = "deviceId";
81 std::string trustDeviceId = "123456";
82
83 Accesser accesser;
84 accesser.SetAccesserId(accesserId);
85 accesser.SetAccesserDeviceId(deviceId);
86 accesser.SetAccesserUserId(userId);
87 accesser.SetAccesserAccountId(oldAccountId);
88 accesser.SetAccesserTokenId(tokenId);
89 accesser.SetAccesserBundleName("bundleName");
90 accesser.SetAccesserHapSignature("uph1");
91 accesser.SetAccesserBindLevel(bindLevel);
92
93 Accessee accessee;
94 accessee.SetAccesseeId(accesserId);
95 accessee.SetAccesseeDeviceId(deviceId);
96 accessee.SetAccesseeUserId(userId);
97 accessee.SetAccesseeAccountId(newAccountId);
98 accessee.SetAccesseeTokenId(tokenId);
99 accessee.SetAccesseeBundleName("bundleName");
100 accessee.SetAccesseeHapSignature("uph1");
101 accessee.SetAccesseeBindLevel(bindLevel);
102
103 AccessControlProfile profileFirst;
104 profileFirst.SetAccessControlId(accesserId);
105 profileFirst.SetAccesserId(accesserId);
106 profileFirst.SetAccesseeId(accesserId);
107 profileFirst.SetTrustDeviceId(trustDeviceId);
108 profileFirst.SetBindType(bindType);
109 profileFirst.SetAuthenticationType(authenticationType);
110 profileFirst.SetDeviceIdType(deviceIdType);
111 profileFirst.SetStatus(status);
112 profileFirst.SetBindLevel(bindLevel);
113 profileFirst.SetAccesser(accesser);
114 profileFirst.SetAccessee(accessee);
115 accessControlProfiles.push_back(profileFirst);
116 }
117
118 /**
119 * @tc.name: Initialize_001
120 * @tc.desc: return DM_OK
121 * @tc.type: FUNC
122 */
123 HWTEST_F(DeviceManagerServiceImplTest, Initialize_001, testing::ext::TestSize.Level0)
124 {
125 if (deviceManagerServiceImpl_ == nullptr) {
126 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
127 }
128 deviceManagerServiceImpl_->commonEventManager_ = std::make_shared<DmCommonEventManager>();
129 int ret = deviceManagerServiceImpl_->Initialize(listener_);
130 EXPECT_EQ(ret, DM_OK);
131 }
132
133 /**
134 * @tc.name: Initialize_002
135 * @tc.desc: return DM_OK
136 * @tc.type: FUNC
137 */
138 HWTEST_F(DeviceManagerServiceImplTest, Initialize_002, testing::ext::TestSize.Level0)
139 {
140 if (deviceManagerServiceImpl_ == nullptr) {
141 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
142 }
143 deviceManagerServiceImpl_->commonEventManager_ = nullptr;
144 int ret = deviceManagerServiceImpl_->Initialize(listener_);
145 EXPECT_EQ(ret, DM_OK);
146 }
147
148 /**
149 * @tc.name: Initialize_003
150 * @tc.desc: return DM_OK
151 * @tc.type: FUNC
152 */
153 HWTEST_F(DeviceManagerServiceImplTest, Initialize_003, testing::ext::TestSize.Level0)
154 {
155 if (deviceManagerServiceImpl_ == nullptr) {
156 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
157 }
158 deviceManagerServiceImpl_->softbusConnector_ = nullptr;
159 deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
160 deviceManagerServiceImpl_->mineHiChainConnector_ = nullptr;
161 deviceManagerServiceImpl_->hiChainAuthConnector_ = nullptr;
162 deviceManagerServiceImpl_->deviceStateMgr_ = nullptr;
163 deviceManagerServiceImpl_->authMgr_ = nullptr;
164 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
165 int ret = deviceManagerServiceImpl_->Initialize(listener_);
166 EXPECT_EQ(ret, DM_OK);
167 }
168
169 /**
170 * @tc.name: PraseNotifyEventJson_001
171 * @tc.desc: return ERR_DM_FAILED
172 * @tc.type: FUNC
173 */
174 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_001, testing::ext::TestSize.Level0)
175 {
176 std::string event = R"({"extra": {"deviceId": "123"})";
177 JsonObject jsonObject;
178 if (deviceManagerServiceImpl_ == nullptr) {
179 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
180 }
181 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
182 EXPECT_EQ(ret, ERR_DM_FAILED);
183 }
184
185 /**
186 * @tc.name: PraseNotifyEventJson_002
187 * @tc.desc: return ERR_DM_FAILED
188 * @tc.type: FUNC
189 */
190 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_002, testing::ext::TestSize.Level0)
191 {
192 std::string event = R"({"content": {"deviceid": "123"}})";
193 JsonObject jsonObject;
194 if (deviceManagerServiceImpl_ == nullptr) {
195 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
196 }
197 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
198 EXPECT_EQ(ret, ERR_DM_FAILED);
199 }
200
201 /**
202 * @tc.name: PraseNotifyEventJson_003
203 * @tc.desc: return ERR_DM_FAILED
204 * @tc.type: FUNC
205 */
206 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_003, testing::ext::TestSize.Level0)
207 {
208 std::string event = R"({"extra": {"deviceaId": "123"}})";
209 JsonObject jsonObject;
210 if (deviceManagerServiceImpl_ == nullptr) {
211 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
212 }
213 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
214 EXPECT_EQ(ret, ERR_DM_FAILED);
215 }
216
217 /**
218 * @tc.name: PraseNotifyEventJson_004
219 * @tc.desc: return ERR_DM_FAILED
220 * @tc.type: FUNC
221 */
222 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_004, testing::ext::TestSize.Level0)
223 {
224 std::string event = R"({"extra": {"deviceId": 123}})";
225 JsonObject jsonObject;
226 if (deviceManagerServiceImpl_ == nullptr) {
227 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
228 }
229 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
230 EXPECT_EQ(ret, ERR_DM_FAILED);
231 }
232
233 /**
234 * @tc.name: PraseNotifyEventJson_005
235 * @tc.desc: return ERR_DM_FAILED
236 * @tc.type: FUNC
237 */
238 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_005, testing::ext::TestSize.Level0)
239 {
240 std::string event = R"({"Extra": {"deviceId": "123"}})";
241 JsonObject jsonObject;
242 if (deviceManagerServiceImpl_ == nullptr) {
243 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
244 }
245 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
246 EXPECT_EQ(ret, ERR_DM_FAILED);
247 }
248
249 /**
250 * @tc.name: PraseNotifyEventJson_006
251 * @tc.desc: return ERR_DM_FAILED
252 * @tc.type: FUNC
253 */
254 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_006, testing::ext::TestSize.Level0)
255 {
256 std::string event = R"({"extra":"123"}})";
257 JsonObject jsonObject;
258 if (deviceManagerServiceImpl_ == nullptr) {
259 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
260 }
261 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
262 EXPECT_EQ(ret, ERR_DM_FAILED);
263 }
264
265 /**
266 * @tc.name: PraseNotifyEventJson_007
267 * @tc.desc: return DM_OK
268 * @tc.type: FUNC
269 */
270 HWTEST_F(DeviceManagerServiceImplTest, PraseNotifyEventJson_007, testing::ext::TestSize.Level0)
271 {
272 std::string event = R"({"extra": {"deviceId": "123"}})";
273 JsonObject jsonObject;
274 if (deviceManagerServiceImpl_ == nullptr) {
275 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
276 }
277 int ret = deviceManagerServiceImpl_->PraseNotifyEventJson(event, jsonObject);
278 EXPECT_EQ(ret, DM_OK);
279 }
280
281 /**
282 * @tc.name: NotifyEvent_001
283 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
284 * @tc.type: FUNC
285 */
286 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_001, testing::ext::TestSize.Level0)
287 {
288 std::string pkgName = "com.ohos.test";
289 int32_t eventId = DM_NOTIFY_EVENT_START;
290 std::string event = R"({"extra": {"deviceId": "123"}})";
291 if (deviceManagerServiceImpl_ == nullptr) {
292 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
293 }
294 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
295 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
296 }
297
298 /**
299 * @tc.name: NotifyEvent_002
300 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
301 * @tc.type: FUNC
302 */
303 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_002, testing::ext::TestSize.Level0)
304 {
305 std::string pkgName = "com.ohos.test";
306 int32_t eventId = DM_NOTIFY_EVENT_BUTT;
307 std::string event = R"({"extra": {"deviceId": "123"}})";
308 if (deviceManagerServiceImpl_ == nullptr) {
309 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
310 }
311 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
312 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
313 }
314
315 /**
316 * @tc.name: NotifyEvent_003
317 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
318 * @tc.type: FUNC
319 */
320 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_003, testing::ext::TestSize.Level0)
321 {
322 std::string pkgName = "com.ohos.test";
323 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
324 std::string event = R"({"extra": {"deviceId": "123"})";
325 if (deviceManagerServiceImpl_ == nullptr) {
326 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
327 }
328 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
329 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
330 }
331
332 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_004, testing::ext::TestSize.Level0)
333 {
334 std::string pkgName = "com.ohos.test_004";
335 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
336 std::string event = R"({"extra": {"deviceId": "789"}})";
337 if (deviceManagerServiceImpl_ == nullptr) {
338 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
339 }
340 deviceManagerServiceImpl_->deviceStateMgr_ = nullptr;
341 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
342 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
343 }
344
345 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_005, testing::ext::TestSize.Level0)
346 {
347 std::string pkgName = "com.ohos.test_005";
348 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
349 std::string event = R"({"extra": {"deviceId": "789"}})";
350 if (deviceManagerServiceImpl_ == nullptr) {
351 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
352 }
353 deviceManagerServiceImpl_->Initialize(listener_);
354 std::string commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED;
355 deviceManagerServiceImpl_->ScreenCommonEventCallback(commonEventType);
356 int32_t remoteUserId = 1;
357 std::string remoteAccountHash = "45552878";
358 std::string remoteUdid = "ajdakndkwj98877";
359 std::multimap<std::string, int32_t> devIdAndUserMap;
360 devIdAndUserMap.insert(std::make_pair("devId01", 101));
361 devIdAndUserMap.insert(std::make_pair("devId02", 102));
362 devIdAndUserMap.insert(std::make_pair("devId03", 103));
363 EXPECT_CALL(*deviceProfileConnectorMock_, GetDevIdAndUserIdByActHash(_, _, _, _)).WillOnce(Return(devIdAndUserMap));
364 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForAccountLogOut(_, _, _, _))
365 .Times(::testing::AtLeast(3)).WillOnce(Return(true));
366 deviceManagerServiceImpl_->HandleAccountLogoutEvent(remoteUserId, remoteAccountHash, remoteUdid);
367
368 std::string localUdid = "localUdid";
369 int32_t localUserId = 123;
370 std::string peerUdid = "peerUdid";
371 int32_t peerUserId = 456;
372 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForAccountLogOut(_, _, _, _)).WillOnce(Return(true));
373 deviceManagerServiceImpl_->HandleIdentAccountLogout(localUdid, localUserId, peerUdid, peerUserId);
374
375 EXPECT_CALL(*dmDeviceStateManagerMock_, ProcNotifyEvent(_, _)).WillOnce(Return(DM_OK));
376 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
377 EXPECT_EQ(ret, DM_OK);
378 }
379
380 /**
381 * @tc.name: RequestCredential_001
382 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
383 * @tc.type: FUNC
384 */
385 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_001, testing::ext::TestSize.Level0)
386 {
387 const std::string reqJsonStr = "";
388 std::string returnJsonStr = "returntest";
389 if (deviceManagerServiceImpl_ == nullptr) {
390 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
391 }
392 int32_t ret = deviceManagerServiceImpl_->RequestCredential(reqJsonStr, returnJsonStr);
393 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
394 }
395
396 /**
397 * @tc.name: RequestCredential_002
398 * @tc.desc: return ERR_DM_POINT_NULL
399 * @tc.type: FUNC
400 */
401 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_002, testing::ext::TestSize.Level0)
402 {
403 const std::string reqJsonStr = "test";
404 std::string returnJsonStr = "returntest";
405 if (deviceManagerServiceImpl_ == nullptr) {
406 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
407 }
408 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
409 int32_t ret = deviceManagerServiceImpl_->RequestCredential(reqJsonStr, returnJsonStr);
410 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
411 }
412
413 /**
414 * @tc.name: ImportCredential_001
415 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
416 * @tc.type: FUNC
417 */
418 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_001, testing::ext::TestSize.Level0)
419 {
420 const std::string pkgName = "";
421 const std::string credentialInfo = "";
422 if (deviceManagerServiceImpl_ == nullptr) {
423 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
424 }
425 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
426 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
427 }
428
429 /**
430 * @tc.name: ImportCredential_002
431 * @tc.desc: return ERR_DM_POINT_NULL
432 * @tc.type: FUNC
433 */
434 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_002, testing::ext::TestSize.Level0)
435 {
436 const std::string pkgName = "pkgNametest";
437 const std::string credentialInfo = "credentialInfotest";
438 if (deviceManagerServiceImpl_ == nullptr) {
439 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
440 }
441 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
442 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
443 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
444 }
445
446 /**
447 * @tc.name: ImportCredential_003
448 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
449 * @tc.type: FUNC
450 */
451 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_003, testing::ext::TestSize.Level0)
452 {
453 const std::string pkgName;
454 const std::string credentialInfo = "credentialInfotest";
455 if (deviceManagerServiceImpl_ == nullptr) {
456 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
457 }
458 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
459 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
460 }
461
462 /**
463 * @tc.name: ImportCredential_004
464 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
465 * @tc.type: FUNC
466 */
467 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_004, testing::ext::TestSize.Level0)
468 {
469 const std::string pkgName = "pkgNametest";
470 const std::string credentialInfo;
471 if (deviceManagerServiceImpl_ == nullptr) {
472 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
473 }
474 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
475 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
476 }
477
478 /**
479 * @tc.name: ImportCredential_005
480 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_005, testing::ext::TestSize.Level0)
484 {
485 const std::string pkgName = "pkgNametest";
486 std::string reqJsonStr;
487 std::string returnJsonStr;
488 if (deviceManagerServiceImpl_ == nullptr) {
489 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
490 }
491 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, reqJsonStr, returnJsonStr);
492 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
493 }
494
495 /**
496 * @tc.name: ImportCredential_006
497 * @tc.desc: return ERR_DM_HICHAIN_CREDENTIAL_IMPORT_FAILED
498 * @tc.type: FUNC
499 */
500 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_006, testing::ext::TestSize.Level0)
501 {
502 const std::string pkgName = "pkgNametest";
503 std::string reqJsonStr = "reqJsonStr";
504 std::string returnJsonStr;
505 if (deviceManagerServiceImpl_ == nullptr) {
506 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
507 }
508 EXPECT_CALL(*mineHiChainConnectorMock_,
509 ImportCredential(_, _)).WillOnce(Return(ERR_DM_HICHAIN_CREDENTIAL_IMPORT_FAILED));
510 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, reqJsonStr, returnJsonStr);
511 EXPECT_EQ(ret, ERR_DM_HICHAIN_CREDENTIAL_IMPORT_FAILED);
512 }
513
514 /**
515 * @tc.name: DeleteCredential_001
516 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
517 * @tc.type: FUNC
518 */
519 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_001, testing::ext::TestSize.Level0)
520 {
521 const std::string pkgName = "";
522 const std::string deleteInfo = "";
523 if (deviceManagerServiceImpl_ == nullptr) {
524 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
525 }
526 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
527 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
528 }
529
530 /**
531 * @tc.name: DeleteCredential_002
532 * @tc.desc: return ERR_DM_POINT_NULL
533 * @tc.type: FUNC
534 */
535 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_002, testing::ext::TestSize.Level0)
536 {
537 const std::string pkgName = "pkgNametest";
538 const std::string deleteInfo = "deleteInfotest";
539 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
540 if (deviceManagerServiceImpl_ == nullptr) {
541 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
542 }
543 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
544 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
545 }
546
547 /**
548 * @tc.name: DeleteCredential_003
549 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
550 * @tc.type: FUNC
551 */
552 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_003, testing::ext::TestSize.Level0)
553 {
554 const std::string pkgName;
555 const std::string deleteInfo = "deleteInfotest";
556 if (deviceManagerServiceImpl_ == nullptr) {
557 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
558 }
559 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
560 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
561 }
562
563 /**
564 * @tc.name: DeleteCredential_004
565 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
566 * @tc.type: FUNC
567 */
568 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_004, testing::ext::TestSize.Level0)
569 {
570 const std::string pkgName = "pkgNametest";
571 const std::string deleteInfo;
572 if (deviceManagerServiceImpl_ == nullptr) {
573 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
574 }
575 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
576 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
577 }
578
579 /**
580 * @tc.name: DeleteCredential_005
581 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
582 * @tc.type: FUNC
583 */
584 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_005, testing::ext::TestSize.Level0)
585 {
586 const std::string pkgName = "pkgNametest";
587 std::string reqJsonStr;
588 std::string returnJsonStr;
589 if (deviceManagerServiceImpl_ == nullptr) {
590 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
591 }
592 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
593 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
594 }
595
596 /**
597 * @tc.name: DeleteCredential_006
598 * @tc.desc: return DM_OK
599 * @tc.type: FUNC
600 */
601 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_006, testing::ext::TestSize.Level0)
602 {
603 const std::string pkgName = "pkgNametest";
604 std::string reqJsonStr = "reqJsonStr";
605 std::string returnJsonStr;
606 if (deviceManagerServiceImpl_ == nullptr) {
607 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
608 }
609 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
610 EXPECT_EQ(ret, DM_OK);
611 }
612
613 /**
614 * @tc.name: RegisterCredentialCallback_001
615 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
616 * @tc.type: FUNC
617 */
618 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0)
619 {
620 const std::string pkgName = "";
621 if (deviceManagerServiceImpl_ == nullptr) {
622 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
623 }
624 int32_t ret = deviceManagerServiceImpl_->RegisterCredentialCallback(pkgName);
625 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
626 }
627
628 /**
629 * @tc.name: RegisterCredentialCallback_002
630 * @tc.desc: return ERR_DM_POINT_NULL
631 * @tc.type: FUNC
632 */
633 HWTEST_F(DeviceManagerServiceImplTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0)
634 {
635 const std::string pkgName = "pkgNametest";
636 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
637 if (deviceManagerServiceImpl_ == nullptr) {
638 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
639 }
640 int32_t ret = deviceManagerServiceImpl_->RegisterCredentialCallback(pkgName);
641 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
642 }
643
644 /**
645 * @tc.name: UnRegisterCredentialCallback_001
646 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
647 * @tc.type: FUNC
648 */
649 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0)
650 {
651 const std::string pkgName = "";
652 int32_t ret = deviceManagerServiceImpl_->UnRegisterCredentialCallback(pkgName);
653 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
654 }
655
656 /**
657 * @tc.name: UnRegisterCredentialCallback_002
658 * @tc.desc: return ERR_DM_POINT_NULL
659 * @tc.type: FUNC
660 */
661 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0)
662 {
663 const std::string pkgName = "pkgNametest";
664 if (deviceManagerServiceImpl_ == nullptr) {
665 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
666 }
667 deviceManagerServiceImpl_->credentialMgr_ = nullptr;
668 int32_t ret = deviceManagerServiceImpl_->UnRegisterCredentialCallback(pkgName);
669 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
670 }
671
672 /**
673 * @tc.name: RegisterUiStateCallback_001
674 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
675 * @tc.type: FUNC
676 */
677 HWTEST_F(DeviceManagerServiceImplTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level0)
678 {
679 const std::string pkgName = "";
680 if (deviceManagerServiceImpl_ == nullptr) {
681 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
682 }
683 int32_t ret = deviceManagerServiceImpl_->RegisterUiStateCallback(pkgName);
684 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
685 }
686
687 /**
688 * @tc.name: RegisterUiStateCallback_002
689 * @tc.desc: return ERR_DM_POINT_NULL
690 * @tc.type: FUNC
691 */
692 HWTEST_F(DeviceManagerServiceImplTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level0)
693 {
694 const std::string pkgName = "pkgNametest";
695 if (deviceManagerServiceImpl_ == nullptr) {
696 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
697 }
698 deviceManagerServiceImpl_->authMgr_ = nullptr;
699 int32_t ret = deviceManagerServiceImpl_->RegisterUiStateCallback(pkgName);
700 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
701 }
702
703 /**
704 * @tc.name: UnRegisterUiStateCallback_001
705 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
706 * @tc.type: FUNC
707 */
708 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level0)
709 {
710 const std::string pkgName = "";
711 if (deviceManagerServiceImpl_ == nullptr) {
712 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
713 }
714 int32_t ret = deviceManagerServiceImpl_->UnRegisterUiStateCallback(pkgName);
715 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
716 }
717
718 /**
719 * @tc.name: UnRegisterUiStateCallback_002
720 * @tc.desc: return ERR_DM_POINT_NULL
721 * @tc.type: FUNC
722 */
723 HWTEST_F(DeviceManagerServiceImplTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level0)
724 {
725 const std::string pkgName = "pkgNametest";
726 if (deviceManagerServiceImpl_ == nullptr) {
727 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
728 }
729 deviceManagerServiceImpl_->authMgr_ = nullptr;
730 int32_t ret = deviceManagerServiceImpl_->UnRegisterUiStateCallback(pkgName);
731 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
732 }
733
734 /**
735 * @tc.name: SetUserOperation_001
736 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
737 * @tc.type: FUNC
738 */
739 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_001, testing::ext::TestSize.Level0)
740 {
741 std::string pkgName = "";
742 int32_t action = 1;
743 const std::string params = "params";
744 if (deviceManagerServiceImpl_ == nullptr) {
745 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
746 }
747 int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
748 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
749 }
750
751 /**
752 * @tc.name: SetUserOperation_002
753 * @tc.desc: return DM_OK
754 * @tc.type: FUNC
755 */
756 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_002, testing::ext::TestSize.Level0)
757 {
758 std::string pkgName = "com.ohos.test";
759 int32_t action = 1;
760 const std::string params = "paramsTest";
761 if (deviceManagerServiceImpl_ == nullptr) {
762 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
763 }
764 int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
765 EXPECT_EQ(ret, DM_OK);
766 }
767
768 /**
769 * @tc.name: SetUserOperation_003
770 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
771 * @tc.type: FUNC
772 */
773 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_003, testing::ext::TestSize.Level0)
774 {
775 std::string pkgName;
776 int32_t action = 1;
777 const std::string params;
778 if (deviceManagerServiceImpl_ == nullptr) {
779 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
780 }
781 int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
782 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
783 }
784
785 /**
786 * @tc.name: SetUserOperation_004
787 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
788 * @tc.type: FUNC
789 */
790 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_004, testing::ext::TestSize.Level0)
791 {
792 std::string pkgName = "com.ohos.test";
793 int32_t action = 1;
794 const std::string params;
795 if (deviceManagerServiceImpl_ == nullptr) {
796 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
797 }
798 int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
799 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
800 }
801
802 /**
803 * @tc.name: SetUserOperation_005
804 * @tc.desc: return ERR_DM_INPUT_PARA_INVALID
805 * @tc.type: FUNC
806 */
807 HWTEST_F(DeviceManagerServiceImplTest, SetUserOperation_005, testing::ext::TestSize.Level0)
808 {
809 std::string pkgName = "com.ohos.test";
810 int32_t action = 1;
811 const std::string params;
812 if (deviceManagerServiceImpl_ == nullptr) {
813 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
814 }
815 deviceManagerServiceImpl_->authMgr_ = nullptr;
816 int32_t ret = deviceManagerServiceImpl_->SetUserOperation(pkgName, action, params);
817 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
818 }
819
820 /**
821 * @tc.name: HandleOffline_001
822 * @tc.type: FUNC
823 */
824 HWTEST_F(DeviceManagerServiceImplTest, HandleOffline_001, testing::ext::TestSize.Level0)
825 {
826 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
827 DmDeviceInfo devInfo;
828 if (deviceManagerServiceImpl_ == nullptr) {
829 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
830 }
831 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
832 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
833 }
834
835 /**
836 * @tc.name: HandleOffline_002
837 * @tc.type: FUNC
838 */
839 HWTEST_F(DeviceManagerServiceImplTest, HandleOffline_002, testing::ext::TestSize.Level0)
840 {
841 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
842 DmDeviceInfo devInfo;
843 strcpy_s(devInfo.networkId, sizeof(devInfo.networkId) - 1, TEST_ID.c_str());
844 devInfo.networkId[sizeof(devInfo.networkId) - 1] = '\0';
845 if (deviceManagerServiceImpl_ == nullptr) {
846 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
847 }
848 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
849 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
850 }
851
852 /**
853 * @tc.name: HandleOnline_001
854 * @tc.type: FUNC
855 */
856 HWTEST_F(DeviceManagerServiceImplTest, HandleOnline_001, testing::ext::TestSize.Level0)
857 {
858 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
859 DmDeviceInfo devInfo;
860 if (deviceManagerServiceImpl_ == nullptr) {
861 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
862 }
863 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
864 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
865 }
866
867 /**
868 * @tc.name: HandleOnline_002
869 * @tc.type: FUNC
870 */
871 HWTEST_F(DeviceManagerServiceImplTest, HandleOnline_002, testing::ext::TestSize.Level0)
872 {
873 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
874 DmDeviceInfo devInfo;
875 strcpy_s(devInfo.networkId, sizeof(devInfo.networkId) - 1, TEST_ID.c_str());
876 devInfo.networkId[sizeof(devInfo.networkId) - 1] = '\0';
877 if (deviceManagerServiceImpl_ == nullptr) {
878 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
879 }
880 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
881 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
882 }
883
884 /**
885 * @tc.name: HandleDeviceStatusChange_001
886 * @tc.type: FUNC
887 */
888 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0)
889 {
890 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
891 DmDeviceInfo devInfo;
892 if (deviceManagerServiceImpl_ == nullptr) {
893 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
894 }
895 deviceManagerServiceImpl_->deviceStateMgr_ = nullptr;
896 deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
897 EXPECT_EQ(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
898 }
899
900 /**
901 * @tc.name: HandleDeviceStatusChange_002
902 * @tc.type: FUNC
903 */
904 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_002, testing::ext::TestSize.Level0)
905 {
906 DmDeviceState devState = DmDeviceState::DEVICE_STATE_ONLINE;
907 DmDeviceInfo devInfo;
908 if (deviceManagerServiceImpl_ == nullptr) {
909 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
910 }
911 deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
912 EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
913 }
914
915 /**
916 * @tc.name: HandleDeviceStatusChange_003
917 * @tc.type: FUNC
918 */
919 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_003, testing::ext::TestSize.Level0)
920 {
921 DmDeviceState devState = DmDeviceState::DEVICE_STATE_OFFLINE;
922 DmDeviceInfo devInfo;
923 if (deviceManagerServiceImpl_ == nullptr) {
924 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
925 }
926 deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
927 EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
928 }
929
930 /**
931 * @tc.name: HandleDeviceStatusChange_004
932 * @tc.type: FUNC
933 */
934 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceStatusChange_004, testing::ext::TestSize.Level0)
935 {
936 DmDeviceState devState = DmDeviceState::DEVICE_INFO_CHANGED;
937 DmDeviceInfo devInfo;
938 if (deviceManagerServiceImpl_ == nullptr) {
939 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
940 }
941 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
942 deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
943
944 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
945 deviceManagerServiceImpl_->HandleDeviceStatusChange(devState, devInfo);
946 EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
947 }
948
949 /**
950 * @tc.name: GetUdidHashByNetWorkId_001
951 * @tc.desc: return ERR_DM_POINT_NULL
952 * @tc.type: FUNC
953 */
954 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_001, testing::ext::TestSize.Level0)
955 {
956 char *networkId = nullptr;
957 std::string deviceId;
958 if (deviceManagerServiceImpl_ == nullptr) {
959 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
960 }
961 deviceManagerServiceImpl_->softbusConnector_ = nullptr;
962 int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
963 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
964 }
965
966 /**
967 * @tc.name: GetUdidHashByNetWorkId_002
968 * @tc.desc: return ERR_DM_POINT_NULL
969 * @tc.type: FUNC
970 */
971 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_002, testing::ext::TestSize.Level0)
972 {
973 char *networkId = nullptr;
974 std::string deviceId;
975 if (deviceManagerServiceImpl_ == nullptr) {
976 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
977 }
978 deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
979 int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
980 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
981 }
982
983 /**
984 * @tc.name: GetUdidHashByNetWorkId_003
985 * @tc.desc: return SOFTBUS_IPC_ERR
986 * @tc.type: FUNC
987 */
988 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_003, testing::ext::TestSize.Level0)
989 {
990 const char *networkId = "networkId";
991 std::string deviceId;
992 if (deviceManagerServiceImpl_ == nullptr) {
993 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
994 }
995 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(SOFTBUS_IPC_ERR));
996 int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
997 EXPECT_TRUE(CheckSoftbusRes(ret));
998 }
999
1000 /**
1001 * @tc.name: Release_001
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(DeviceManagerServiceImplTest, Release_001, testing::ext::TestSize.Level0)
1005 {
1006 if (deviceManagerServiceImpl_ == nullptr) {
1007 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1008 }
1009 deviceManagerServiceImpl_->Release();
1010 EXPECT_EQ(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1011 }
1012
1013 /**
1014 * @tc.name: OnSessionOpened_001
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(DeviceManagerServiceImplTest, OnSessionOpened_001, testing::ext::TestSize.Level0)
1018 {
1019 int sessionId = 1;
1020 int result = 1;
1021 std::string data = "15631023";
1022 if (deviceManagerServiceImpl_ == nullptr) {
1023 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1024 }
1025 int ret = deviceManagerServiceImpl_->OnSessionOpened(sessionId, result);
1026 deviceManagerServiceImpl_->OnBytesReceived(sessionId, data.c_str(), data.size());
1027 deviceManagerServiceImpl_->OnSessionClosed(sessionId);
1028 EXPECT_EQ(ret, DM_OK);
1029 }
1030
1031 /**
1032 * @tc.name: MineRequestCredential_001
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(DeviceManagerServiceImplTest, MineRequestCredential_001, testing::ext::TestSize.Level0)
1036 {
1037 std::string pkgName = "com.ohos.test";
1038 std::string returnJsonStr;
1039 if (deviceManagerServiceImpl_ == nullptr) {
1040 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1041 }
1042 int32_t ret = deviceManagerServiceImpl_->MineRequestCredential(pkgName, returnJsonStr);
1043 EXPECT_EQ(ret, DM_OK);
1044 }
1045
1046 /**
1047 * @tc.name: CheckCredential_001
1048 * @tc.type: FUNC
1049 */
1050 HWTEST_F(DeviceManagerServiceImplTest, CheckCredential_001, testing::ext::TestSize.Level0)
1051 {
1052 std::string pkgName = "com.ohos.test";
1053 const std::string reqJsonStr;
1054 std::string returnJsonStr;
1055 if (deviceManagerServiceImpl_ == nullptr) {
1056 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1057 }
1058 int32_t ret = deviceManagerServiceImpl_->CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1059 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1060 }
1061
1062 /**
1063 * @tc.name: CheckCredential_002
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(DeviceManagerServiceImplTest, CheckCredential_002, testing::ext::TestSize.Level0)
1067 {
1068 std::string pkgName = "com.ohos.test";
1069 const std::string reqJsonStr = "reqJsonStr";
1070 std::string returnJsonStr;
1071 if (deviceManagerServiceImpl_ == nullptr) {
1072 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1073 }
1074 int32_t ret = deviceManagerServiceImpl_->CheckCredential(pkgName, reqJsonStr, returnJsonStr);
1075 EXPECT_EQ(ret, DM_OK);
1076 }
1077
1078 /**
1079 * @tc.name: GetGroupType_001
1080 * @tc.type: FUNC
1081 */
1082 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_001, testing::ext::TestSize.Level0)
1083 {
1084 std::vector<DmDeviceInfo> deviceList;
1085 if (deviceManagerServiceImpl_ == nullptr) {
1086 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1087 }
1088 deviceManagerServiceImpl_->softbusConnector_ = nullptr;
1089 int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1090 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1091 }
1092
1093 /**
1094 * @tc.name: GetGroupType_002
1095 * @tc.type: FUNC
1096 */
1097 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_002, testing::ext::TestSize.Level0)
1098 {
1099 std::vector<DmDeviceInfo> deviceList;
1100 if (deviceManagerServiceImpl_ == nullptr) {
1101 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1102 }
1103 deviceManagerServiceImpl_->hiChainConnector_ = nullptr;
1104 int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1105 EXPECT_EQ(ret, ERR_DM_POINT_NULL);
1106 }
1107
1108 /**
1109 * @tc.name: GetGroupType_003
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_003, testing::ext::TestSize.Level0)
1113 {
1114 DmDeviceInfo deviceInfo = {
1115 .deviceId = "123456789101112131415",
1116 .deviceName = "deviceName",
1117 .deviceTypeId = 1
1118 };
1119 std::vector<DmDeviceInfo> deviceList;
1120 deviceList.push_back(deviceInfo);
1121 if (deviceManagerServiceImpl_ == nullptr) {
1122 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1123 }
1124 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1125 int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1126 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1127 }
1128
1129 /**
1130 * @tc.name: ImportAuthCode_001
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
1134 {
1135 std::string pkgName;
1136 std::string authCode = "authCode";
1137 if (deviceManagerServiceImpl_ == nullptr) {
1138 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1139 }
1140 int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1141 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1142 }
1143
1144 /**
1145 * @tc.name: ImportAuthCode_002
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_002, testing::ext::TestSize.Level0)
1149 {
1150 std::string pkgName = "com.ohos.test";
1151 std::string authCode;
1152 if (deviceManagerServiceImpl_ == nullptr) {
1153 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1154 }
1155 int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1156 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1157 }
1158
1159 /**
1160 * @tc.name: ImportAuthCode_003
1161 * @tc.type: FUNC
1162 */
1163 HWTEST_F(DeviceManagerServiceImplTest, ImportAuthCode_003, testing::ext::TestSize.Level0)
1164 {
1165 std::string pkgName = "com.ohos.test";
1166 std::string authCode = "authCode";
1167 if (deviceManagerServiceImpl_ == nullptr) {
1168 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1169 }
1170 int32_t ret = deviceManagerServiceImpl_->ImportAuthCode(pkgName, authCode);
1171 EXPECT_EQ(ret, DM_OK);
1172 }
1173
1174 /**
1175 * @tc.name: ExportAuthCode_001
1176 * @tc.type: FUNC
1177 */
1178 HWTEST_F(DeviceManagerServiceImplTest, ExportAuthCode_001, testing::ext::TestSize.Level0)
1179 {
1180 std::string authCode = "authCode";
1181 if (deviceManagerServiceImpl_ == nullptr) {
1182 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1183 }
1184 int32_t ret = deviceManagerServiceImpl_->ExportAuthCode(authCode);
1185 EXPECT_EQ(ret, DM_OK);
1186 }
1187
1188 /**
1189 * @tc.name: BindTarget_001
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(DeviceManagerServiceImplTest, BindTarget_001, testing::ext::TestSize.Level0)
1193 {
1194 std::string pkgName;
1195 PeerTargetId targetId;
1196 std::map<std::string, std::string> bindParam;
1197 if (deviceManagerServiceImpl_ == nullptr) {
1198 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1199 }
1200 int32_t ret = deviceManagerServiceImpl_->BindTarget(pkgName, targetId, bindParam);
1201 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1202 }
1203
1204 /**
1205 * @tc.name: PutIdenticalAccountToAcl_001
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(DeviceManagerServiceImplTest, PutIdenticalAccountToAcl_001, testing::ext::TestSize.Level0)
1209 {
1210 std::string requestDeviceId;
1211 std::string trustDeviceId;
1212 if (deviceManagerServiceImpl_ == nullptr) {
1213 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1214 }
1215 deviceManagerServiceImpl_->PutIdenticalAccountToAcl(requestDeviceId, trustDeviceId);
1216 EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1217 }
1218
1219 /**
1220 * @tc.name: DpAclAdd_001
1221 * @tc.type: FUNC
1222 */
1223 HWTEST_F(DeviceManagerServiceImplTest, DpAclAdd_001, testing::ext::TestSize.Level0)
1224 {
1225 std::string udid = "2342154";
1226 if (deviceManagerServiceImpl_ == nullptr) {
1227 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1228 }
1229 int32_t ret = deviceManagerServiceImpl_->DpAclAdd(udid);
1230 EXPECT_EQ(ret, DM_OK);
1231 }
1232
1233 /**
1234 * @tc.name: IsSameAccount_001
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(DeviceManagerServiceImplTest, IsSameAccount_001, testing::ext::TestSize.Level0)
1238 {
1239 std::string udid;
1240 if (deviceManagerServiceImpl_ == nullptr) {
1241 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1242 }
1243 int32_t ret = deviceManagerServiceImpl_->IsSameAccount(udid);
1244 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1245 }
1246
1247 /**
1248 * @tc.name: IsSameAccount_002
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(DeviceManagerServiceImplTest, IsSameAccount_002, testing::ext::TestSize.Level0)
1252 {
1253 std::string udid = "2342154";
1254 if (deviceManagerServiceImpl_ == nullptr) {
1255 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1256 }
1257 int32_t ret = deviceManagerServiceImpl_->IsSameAccount(udid);
1258 EXPECT_EQ(ret, ERR_DM_FAILED);
1259 }
1260
1261 /**
1262 * @tc.name: GetAppTrustDeviceIdList_003
1263 * @tc.type: FUNC
1264 */
1265 HWTEST_F(DeviceManagerServiceImplTest, GetAppTrustDeviceIdList_003, testing::ext::TestSize.Level0)
1266 {
1267 std::string pkgname = "pkgname";
1268 if (deviceManagerServiceImpl_ == nullptr) {
1269 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1270 }
1271 auto ret = deviceManagerServiceImpl_->GetAppTrustDeviceIdList(pkgname);
1272 EXPECT_EQ(ret.empty(), true);
1273 }
1274
1275 /**
1276 * @tc.name: LoadHardwareFwkService_001
1277 * @tc.type: FUNC
1278 */
1279 HWTEST_F(DeviceManagerServiceImplTest, LoadHardwareFwkService_001, testing::ext::TestSize.Level0)
1280 {
1281 if (deviceManagerServiceImpl_ == nullptr) {
1282 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1283 }
1284 deviceManagerServiceImpl_->LoadHardwareFwkService();
1285 EXPECT_NE(deviceManagerServiceImpl_->hiChainConnector_, nullptr);
1286 }
1287
1288 /**
1289 * tc.name: ScreenCommonEventCallback_001
1290 * tc.type: FUNC
1291 */
1292 HWTEST_F(DeviceManagerServiceImplTest, ScreenCommonEventCallback_001, testing::ext::TestSize.Level0)
1293 {
1294 std::string commonEventType = "usual.event.SCREEN_LOCKED";
1295 deviceManagerServiceImpl_->ScreenCommonEventCallback(commonEventType);
1296 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
1297 commonEventType = "commonEventType";
1298 deviceManagerServiceImpl_->ScreenCommonEventCallback(commonEventType);
1299 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
1300 }
1301
1302 /**
1303 * tc.name: HandleDeviceNotTrust_001
1304 * tc.type: FUNC
1305 */
1306 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceNotTrust_001, testing::ext::TestSize.Level0)
1307 {
1308 std::string udid = TEST_ID;
1309 deviceManagerServiceImpl_->HandleDeviceNotTrust(udid);
1310 EXPECT_NE(deviceManagerServiceImpl_->authMgr_, nullptr);
1311 }
1312
1313 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0)
1314 {
1315 std::string pkgName;
1316 std::string udid;
1317 int32_t bindLevel = 0;
1318 int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, udid, bindLevel);
1319 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1320 }
1321
1322 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_102, testing::ext::TestSize.Level0)
1323 {
1324 std::string pkgName = "pkgname";
1325 std::string udid;
1326 int32_t bindLevel = 0;
1327 int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, udid, bindLevel);
1328 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1329 }
1330
1331 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_103, testing::ext::TestSize.Level0)
1332 {
1333 std::string pkgName;
1334 std::string udid = "123";
1335 int32_t bindLevel = 0;
1336 int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, udid, bindLevel);
1337 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1338 }
1339
1340 HWTEST_F(DeviceManagerServiceImplTest, UnAuthenticateDevice_104, testing::ext::TestSize.Level0)
1341 {
1342 std::string pkgName = "pkgname";
1343 std::string udid = "123";
1344 int32_t bindLevel = 0;
1345 int32_t ret = deviceManagerServiceImpl_->UnAuthenticateDevice(pkgName, udid, bindLevel);
1346 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1347 }
1348
1349 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_101, testing::ext::TestSize.Level0)
1350 {
1351 std::string pkgName = "pkgname";
1352 std::string udid;
1353 int32_t bindLevel = 0;
1354 std::string extra;
1355 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel);
1356 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1357
1358 ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1359 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1360 }
1361
1362 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_102, testing::ext::TestSize.Level0)
1363 {
1364 std::string pkgName;
1365 std::string udid = "123";
1366 int32_t bindLevel = 0;
1367 std::string extra;
1368 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel);
1369 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1370
1371 ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1372 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1373 }
1374
1375 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_103, testing::ext::TestSize.Level0)
1376 {
1377 std::string pkgName;
1378 std::string udid;
1379 int32_t bindLevel = 0;
1380 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel);
1381 deviceManagerServiceImpl_->HandleDeviceNotTrust(udid);
1382 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1383 }
1384
1385 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_104, testing::ext::TestSize.Level0)
1386 {
1387 std::string pkgName = "pkgname";
1388 std::string udid = "123";
1389 int32_t bindLevel = 0;
1390 std::string extra;
1391 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel);
1392 int32_t userId = 100;
1393 std::string accountId = "60008";
1394 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForAccountLogOut(_, _, _, _))
1395 .Times(::testing::AtLeast(1)).WillOnce(Return(true));
1396 deviceManagerServiceImpl_->HandleIdentAccountLogout(udid, userId, udid, userId);
1397 deviceManagerServiceImpl_->HandleUserRemoved(userId);
1398 deviceManagerServiceImpl_->HandleDeviceNotTrust(udid);
1399 EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
1400
1401 ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1402 EXPECT_EQ(ret, ERR_DM_FAILED);
1403 }
1404
1405 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_105, testing::ext::TestSize.Level0)
1406 {
1407 std::string pkgName = "pkgname";
1408 std::string udid;
1409 int32_t bindLevel = 0;
1410 std::string extra = "extra";
1411 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1412 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1413 }
1414
1415 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_106, testing::ext::TestSize.Level0)
1416 {
1417 std::string pkgName;
1418 std::string udid = "123";
1419 int32_t bindLevel = 0;
1420 std::string extra = "extra";
1421 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1422 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1423 }
1424
1425 HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_107, testing::ext::TestSize.Level0)
1426 {
1427 std::string pkgName;
1428 std::string udid;
1429 int32_t bindLevel = 0;
1430 std::string extra = "extra";
1431 int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel, extra);
1432 deviceManagerServiceImpl_->HandleDeviceNotTrust(udid);
1433 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1434 }
1435
1436 HWTEST_F(DeviceManagerServiceImplTest, GetBindLevel_101, testing::ext::TestSize.Level0)
1437 {
1438 std::string pkgName = "pkgname";
1439 const std::string localUdid = "123";
1440 const std::string udid = "234";
1441 uint64_t tokenId = 123;
1442 int32_t tokenId2 = 123;
1443 int32_t remoteUserId = 100;
1444 int32_t ret = deviceManagerServiceImpl_->GetBindLevel(pkgName, localUdid, udid, tokenId);
1445 EXPECT_EQ(ret, INVALIED_TYPE);
1446 }
1447
1448 HWTEST_F(DeviceManagerServiceImplTest, ConvertBindTypeToAuthForm_101, testing::ext::TestSize.Level0)
1449 {
1450 int32_t bindType = DM_INVALIED_BINDTYPE;
1451 DmAuthForm authForm = deviceManagerServiceImpl_->ConvertBindTypeToAuthForm(bindType);
1452 EXPECT_EQ(authForm, DmAuthForm::INVALID_TYPE);
1453 }
1454
1455 HWTEST_F(DeviceManagerServiceImplTest, ConvertBindTypeToAuthForm_102, testing::ext::TestSize.Level0)
1456 {
1457 int32_t bindType = DM_IDENTICAL_ACCOUNT;
1458 DmAuthForm authForm = deviceManagerServiceImpl_->ConvertBindTypeToAuthForm(bindType);
1459 EXPECT_EQ(authForm, DmAuthForm::IDENTICAL_ACCOUNT);
1460 }
1461
1462
1463 HWTEST_F(DeviceManagerServiceImplTest, ConvertBindTypeToAuthForm_103, testing::ext::TestSize.Level0)
1464 {
1465 int32_t bindType = DM_POINT_TO_POINT;
1466 DmAuthForm authForm = deviceManagerServiceImpl_->ConvertBindTypeToAuthForm(bindType);
1467 EXPECT_EQ(authForm, DmAuthForm::PEER_TO_PEER);
1468 }
1469
1470 HWTEST_F(DeviceManagerServiceImplTest, ConvertBindTypeToAuthForm_104, testing::ext::TestSize.Level0)
1471 {
1472 int32_t bindType = DM_ACROSS_ACCOUNT;
1473 DmAuthForm authForm = deviceManagerServiceImpl_->ConvertBindTypeToAuthForm(bindType);
1474 EXPECT_EQ(authForm, DmAuthForm::ACROSS_ACCOUNT);
1475 }
1476
1477 HWTEST_F(DeviceManagerServiceImplTest, CredentialAuthStatus_101, testing::ext::TestSize.Level0)
1478 {
1479 std::string deviceList;
1480 uint16_t deviceTypeId = 0x00;
1481 int32_t errcode = -1;
1482 deviceManagerServiceImpl_->HandleCredentialAuthStatus(deviceList, deviceTypeId, errcode);
1483 EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
1484 }
1485
1486 HWTEST_F(DeviceManagerServiceImplTest, ProcessAppUnintall_101, testing::ext::TestSize.Level0)
1487 {
1488 std::string appId;
1489 int32_t accessTokenId = 101;
1490 int ret = deviceManagerServiceImpl_->ProcessAppUnintall(appId, accessTokenId);
1491 EXPECT_EQ(ret, DM_OK);
1492 }
1493
1494 HWTEST_F(DeviceManagerServiceImplTest, ProcessAppUnintall_102, testing::ext::TestSize.Level0)
1495 {
1496 std::string appId;
1497 int32_t accessTokenId = 102;
1498 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1499 AddAccessControlProfileFirst(profiles);
1500 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1501 int ret = deviceManagerServiceImpl_->ProcessAppUnintall(appId, accessTokenId);
1502 EXPECT_EQ(ret, DM_OK);
1503 }
1504
1505 HWTEST_F(DeviceManagerServiceImplTest, ProcessAppUnintall_103, testing::ext::TestSize.Level0)
1506 {
1507 std::string appId;
1508 int32_t accessTokenId = 1001;
1509 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1510 AddAccessControlProfileFirst(profiles);
1511 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1512 if (deviceManagerServiceImpl_->hiChainConnector_ == nullptr) {
1513 deviceManagerServiceImpl_->Initialize(listener_);
1514 }
1515 int ret = deviceManagerServiceImpl_->ProcessAppUnintall(appId, accessTokenId);
1516 EXPECT_EQ(ret, DM_OK);
1517 }
1518
1519 HWTEST_F(DeviceManagerServiceImplTest, StopAuthenticateDevice_101, testing::ext::TestSize.Level0)
1520 {
1521 std::string pkgName;
1522 int ret = deviceManagerServiceImpl_->StopAuthenticateDevice(pkgName);
1523 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1524 }
1525
1526 HWTEST_F(DeviceManagerServiceImplTest, StopAuthenticateDevice_102, testing::ext::TestSize.Level0)
1527 {
1528 std::string pkgName = "StopAuthenticateDevice_102";
1529 if (deviceManagerServiceImpl_->authMgr_ == nullptr) {
1530 deviceManagerServiceImpl_->Initialize(listener_);
1531 }
1532 int ret = deviceManagerServiceImpl_->StopAuthenticateDevice(pkgName);
1533 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1534 }
1535
1536 HWTEST_F(DeviceManagerServiceImplTest, CheckIsSameAccount_001, testing::ext::TestSize.Level0)
1537 {
1538 DmAccessCaller caller;
1539 std::string srcUdid = "";
1540 DmAccessCallee callee;
1541 std::string sinkUdid = "";
1542 if (deviceManagerServiceImpl_->authMgr_ == nullptr) {
1543 deviceManagerServiceImpl_->Initialize(listener_);
1544 }
1545 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1546 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1547 int ret = deviceManagerServiceImpl_->CheckIsSameAccount(caller, srcUdid, callee, sinkUdid);
1548 EXPECT_EQ(ret, ERR_DM_FAILED);
1549 }
1550
1551 HWTEST_F(DeviceManagerServiceImplTest, CheckAccessControl_001, testing::ext::TestSize.Level0)
1552 {
1553 DmAccessCaller caller;
1554 std::string srcUdid = "";
1555 DmAccessCallee callee;
1556 std::string sinkUdid = "";
1557 if (deviceManagerServiceImpl_->authMgr_ == nullptr) {
1558 deviceManagerServiceImpl_->Initialize(listener_);
1559 }
1560 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1561 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1562 int ret = deviceManagerServiceImpl_->CheckAccessControl(caller, srcUdid, callee, sinkUdid);
1563 EXPECT_EQ(ret, ERR_DM_FAILED);
1564 }
1565
1566 HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceScreenStatusChange_001, testing::ext::TestSize.Level0)
1567 {
1568 DmDeviceInfo devInfo;
1569 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1570 deviceManagerServiceImpl_->Initialize(listener_);
1571 }
1572 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
1573 deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
1574
1575 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1576 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(INVALIED_TYPE));
1577 deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
1578
1579 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1580 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(IDENTICAL_ACCOUNT_TYPE));
1581 deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
1582
1583 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1584 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1585 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_PEER_TO_PEER_TYPE));
1586 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1587 deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
1588 EXPECT_NE(deviceManagerServiceImpl_->softbusConnector_, nullptr);
1589 }
1590
1591 HWTEST_F(DeviceManagerServiceImplTest, GetUdidHashByNetWorkId_004, testing::ext::TestSize.Level0)
1592 {
1593 const char *networkId = "networkId";
1594 std::string deviceId = "deviceId";
1595 if (deviceManagerServiceImpl_ == nullptr) {
1596 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1597 }
1598
1599 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1600 deviceManagerServiceImpl_->Initialize(listener_);
1601 }
1602 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1603 int32_t ret = deviceManagerServiceImpl_->GetUdidHashByNetWorkId(networkId, deviceId);
1604 EXPECT_EQ(ret, DM_OK);
1605 }
1606
1607 HWTEST_F(DeviceManagerServiceImplTest, HandleOnline_003, testing::ext::TestSize.Level0)
1608 {
1609 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
1610 DmDeviceInfo devInfo;
1611 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1612 deviceManagerServiceImpl_->Initialize(listener_);
1613 }
1614 strcpy_s(devInfo.networkId, sizeof(devInfo.networkId) - 1, TEST_ID.c_str());
1615 devInfo.networkId[sizeof(devInfo.networkId) - 1] = '\0';
1616 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(ERR_DM_FAILED));
1617 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1618
1619 deviceManagerServiceImpl_->isCredentialType_.store(true);
1620 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1621 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(INVALIED_TYPE));
1622 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1623
1624 deviceManagerServiceImpl_->isCredentialType_.store(false);
1625 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1626 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(IDENTICAL_ACCOUNT_TYPE));
1627 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1628
1629 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1630 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(DEVICE_PEER_TO_PEER_TYPE));
1631 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1632
1633 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1634 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(DEVICE_ACROSS_ACCOUNT_TYPE));
1635 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1636
1637 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1638 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1639 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_PEER_TO_PEER_TYPE));
1640 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1641 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1642
1643 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
1644 EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_ACROSS_ACCOUNT_TYPE));
1645 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1646 deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
1647 EXPECT_NE(deviceManagerServiceImpl_->softbusConnector_, nullptr);
1648 }
1649
1650 HWTEST_F(DeviceManagerServiceImplTest, HandleOffline_003, testing::ext::TestSize.Level0)
1651 {
1652 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY;
1653 DmDeviceInfo devInfo;
1654 strcpy_s(devInfo.networkId, sizeof(devInfo.networkId) - 1, TEST_ID.c_str());
1655 devInfo.networkId[sizeof(devInfo.networkId) - 1] = '\0';
1656 if (deviceManagerServiceImpl_->deviceStateMgr_ == nullptr) {
1657 deviceManagerServiceImpl_->Initialize(listener_);
1658 }
1659 EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return(""));
1660 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
1661
1662 std::map<int32_t, int32_t> userIdAndBindLevel;
1663 userIdAndBindLevel[1] = INVALIED_TYPE;
1664 userIdAndBindLevel[2] = DEVICE;
1665 userIdAndBindLevel[3] = SERVICE;
1666 userIdAndBindLevel[4] = APP;
1667 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1668 EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return("123456"));
1669 EXPECT_CALL(*deviceProfileConnectorMock_, GetUserIdAndBindLevel(_, _)).WillOnce(Return(userIdAndBindLevel));
1670 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile())
1671 .WillOnce(Return(profiles)).WillOnce(Return(profiles));
1672 deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
1673 EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
1674 }
1675
1676 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_007, testing::ext::TestSize.Level0)
1677 {
1678 const std::string pkgName = "pkgNametest";
1679 std::string reqJsonStr = "reqJsonStr";
1680 std::string returnJsonStr;
1681 if (deviceManagerServiceImpl_ == nullptr) {
1682 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1683 }
1684 EXPECT_CALL(*mineHiChainConnectorMock_, ImportCredential(_, _)).WillOnce(Return(DM_OK));
1685 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, reqJsonStr, returnJsonStr);
1686 EXPECT_EQ(ret, DM_OK);
1687 }
1688
1689 HWTEST_F(DeviceManagerServiceImplTest, NotifyEvent_006, testing::ext::TestSize.Level0)
1690 {
1691 std::string pkgName = "com.ohos.test_006";
1692 int32_t eventId = DM_NOTIFY_EVENT_ONDEVICEREADY;
1693 std::string event = R"({"extra": {"deviceId": "789"}})";
1694 if (deviceManagerServiceImpl_ == nullptr) {
1695 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1696 }
1697 deviceManagerServiceImpl_->Initialize(listener_);
1698 EXPECT_CALL(*dmDeviceStateManagerMock_, ProcNotifyEvent(_, _)).WillOnce(Return(ERR_DM_INPUT_PARA_INVALID));
1699 int ret = deviceManagerServiceImpl_->NotifyEvent(pkgName, eventId, event);
1700 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1701 }
1702
1703 HWTEST_F(DeviceManagerServiceImplTest, GetGroupType_004, testing::ext::TestSize.Level0)
1704 {
1705 DmDeviceInfo deviceInfo = {
1706 .deviceId = "123456789101112131415",
1707 .deviceName = "deviceName",
1708 .deviceTypeId = 1
1709 };
1710
1711 DmDeviceInfo deviceInfo1 = {
1712 .deviceId = "123456789689898989",
1713 .deviceName = "deviceName1",
1714 .deviceTypeId = 2
1715 };
1716 std::vector<DmDeviceInfo> deviceList;
1717 deviceList.push_back(deviceInfo);
1718 deviceList.push_back(deviceInfo1);
1719 if (deviceManagerServiceImpl_ == nullptr) {
1720 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1721 deviceManagerServiceImpl_->Initialize(listener_);
1722 }
1723 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK)).WillOnce(Return(DM_OK));
1724 int32_t ret = deviceManagerServiceImpl_->GetGroupType(deviceList);
1725 EXPECT_EQ(ret, DM_OK);
1726 }
1727
1728 HWTEST_F(DeviceManagerServiceImplTest, GetDeviceIdAndUserId_001, testing::ext::TestSize.Level0)
1729 {
1730 int32_t userId = 1;
1731 std::string accountId = "accountId";
1732 auto ret = deviceManagerServiceImpl_->GetDeviceIdAndUserId(userId, accountId);
1733 EXPECT_TRUE(ret.empty());
1734
1735 ret = deviceManagerServiceImpl_->GetDeviceIdAndUserId(userId);
1736 EXPECT_TRUE(ret.empty());
1737
1738 std::string localUdid = "deviceId";
1739 int32_t localUserId = 123456;
1740 std::string peerUdid = "remoteUdid";
1741 int32_t peerUserId = 1;
1742 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForAccountLogOut(_, _, _, _)).WillOnce(Return(true));
1743 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1744 deviceManagerServiceImpl_->Initialize(listener_);
1745 }
1746
1747 if (deviceManagerServiceImpl_->deviceStateMgr_ == nullptr) {
1748 deviceManagerServiceImpl_->Initialize(listener_);
1749 }
1750 deviceManagerServiceImpl_->HandleIdentAccountLogout(localUdid, localUserId, peerUdid, peerUserId);
1751
1752 std::vector<uint32_t> foregroundUserIds;
1753 std::vector<uint32_t> backgroundUserIds;
1754 std::string remoteUdid = "deviceId";
1755 deviceManagerServiceImpl_->HandleSyncUserIdEvent(foregroundUserIds, backgroundUserIds, remoteUdid, false);
1756
1757 std::vector<std::string> deviceVec;
1758 int32_t currentUserId = 1;
1759 int32_t beforeUserId = 0;
1760 deviceManagerServiceImpl_->HandleUserSwitched(deviceVec, currentUserId, beforeUserId);
1761 }
1762
1763 HWTEST_F(DeviceManagerServiceImplTest, SaveOnlineDeviceInfo_001, testing::ext::TestSize.Level0)
1764 {
1765 std::vector<DmDeviceInfo> deviceList;
1766 DmDeviceInfo dmDeviceInfo;
1767 dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
1768 dmDeviceInfo.networkType = 1;
1769 deviceList.push_back(dmDeviceInfo);
1770
1771 if (deviceManagerServiceImpl_->deviceStateMgr_ == nullptr) {
1772 deviceManagerServiceImpl_->Initialize(listener_);
1773 }
1774 EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK));
1775 int32_t ret = deviceManagerServiceImpl_->SaveOnlineDeviceInfo(deviceList);
1776 EXPECT_EQ(ret, DM_OK);
1777
1778 int32_t remoteUserId = 1;
1779 std::string remoteUdid = "remoteDeviceId";
1780 int32_t tokenId = 0;
1781 ProcessInfo processInfo;
1782 EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _)).WillOnce(Return(processInfo));
1783 deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId);
1784
1785 processInfo.pkgName = "pkgName";
1786 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1787 deviceManagerServiceImpl_->Initialize(listener_);
1788 }
1789 EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _)).WillOnce(Return(processInfo));
1790 deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId);
1791
1792 EXPECT_CALL(*deviceProfileConnectorMock_, HandleDevUnBindEvent(_, _, _)).WillOnce(Return(DM_INVALIED_BINDTYPE));
1793 deviceManagerServiceImpl_->HandleDevUnBindEvent(remoteUserId, remoteUdid);
1794
1795 EXPECT_CALL(*deviceProfileConnectorMock_, HandleDevUnBindEvent(_, _, _)).WillOnce(Return(DM_IDENTICAL_ACCOUNT));
1796 if (deviceManagerServiceImpl_->authMgr_ == nullptr) {
1797 deviceManagerServiceImpl_->Initialize(listener_);
1798 }
1799 deviceManagerServiceImpl_->HandleDevUnBindEvent(remoteUserId, remoteUdid);
1800
1801 int32_t userId = 123456;
1802 remoteUdid = "remoteDeviceId";
1803 if (deviceManagerServiceImpl_->hiChainConnector_ == nullptr) {
1804 deviceManagerServiceImpl_->Initialize(listener_);
1805 }
1806 std::vector<int32_t> localUserIds;
1807 localUserIds.push_back(123);
1808 localUserIds.push_back(456);
1809 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForRemoteUserRemoved(_, _, _))
1810 .WillOnce(DoAll(SetArgReferee<2>(localUserIds), Return()));
1811 deviceManagerServiceImpl_->HandleRemoteUserRemoved(userId, remoteUdid);
1812 }
1813
1814 HWTEST_F(DeviceManagerServiceImplTest, GetTokenIdByNameAndDeviceId_002, testing::ext::TestSize.Level0)
1815 {
1816 std::string pkgName = "pkgName";
1817 std::string requestDeviceId = "";
1818 auto ret = deviceManagerServiceImpl_->GetTokenIdByNameAndDeviceId(pkgName, requestDeviceId);
1819 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1820 }
1821
1822 HWTEST_F(DeviceManagerServiceImplTest, GetDeviceIdAndBindLevel_001, testing::ext::TestSize.Level0)
1823 {
1824 int32_t userId = 123456;
1825 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1826 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1827 auto ret = deviceManagerServiceImpl_->GetDeviceIdAndBindLevel(userId);
1828 EXPECT_TRUE(ret.empty());
1829 }
1830
1831 HWTEST_F(DeviceManagerServiceImplTest, GetDeviceIdAndUserId_002, testing::ext::TestSize.Level0)
1832 {
1833 int32_t localUserId = 123456;
1834 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1835 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1836 auto ret = deviceManagerServiceImpl_->GetDeviceIdAndUserId(localUserId);
1837 EXPECT_TRUE(ret.empty());
1838 }
1839
1840 HWTEST_F(DeviceManagerServiceImplTest, GetTokenIdByNameAndDeviceId_001, testing::ext::TestSize.Level0)
1841 {
1842 std::string pkgName;
1843 std::string requestDeviceId = "requestDeviceId";
1844 uint64_t ret = deviceManagerServiceImpl_->GetTokenIdByNameAndDeviceId(pkgName, requestDeviceId);
1845 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1846
1847 pkgName = "pkgName";
1848 requestDeviceId = "";
1849 ret = deviceManagerServiceImpl_->GetTokenIdByNameAndDeviceId(pkgName, requestDeviceId);
1850 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1851
1852 requestDeviceId = "requestDeviceId";
1853 ret = deviceManagerServiceImpl_->GetTokenIdByNameAndDeviceId(pkgName, requestDeviceId);
1854 EXPECT_EQ(ret, DM_OK);
1855
1856 int32_t remoteUserId = 1;
1857 std::string remoteUdid = "remoteDeviceId";
1858 int32_t tokenId = 0;
1859 int32_t peerTokenId = 1;
1860 ProcessInfo processInfo;
1861 EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _, _)).WillOnce(Return(processInfo));
1862 deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId, peerTokenId);
1863
1864 processInfo.pkgName = "pkgName";
1865 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1866 deviceManagerServiceImpl_->Initialize(listener_);
1867 }
1868 EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _, _)).WillOnce(Return(processInfo));
1869 deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId, peerTokenId);
1870
1871 int32_t bindType = 1;
1872 std::string peerUdid = "peerUdid";
1873 std::string localUdid = "localUdid";
1874 int32_t localUserId = 1;
1875 std::string localAccountId = "localAccountId";
1876 deviceManagerServiceImpl_->HandleDeviceUnBind(bindType, peerUdid, localUdid, localUserId, localAccountId);
1877 }
1878
1879 HWTEST_F(DeviceManagerServiceImplTest, RegisterAuthenticationType_001, testing::ext::TestSize.Level0)
1880 {
1881 int32_t authenticationType = 1;
1882 if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) {
1883 deviceManagerServiceImpl_->Initialize(listener_);
1884 }
1885 int32_t ret = deviceManagerServiceImpl_->RegisterAuthenticationType(authenticationType);
1886 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1887
1888 int32_t userId = 0;
1889 std::string remoteUdid = "remoteUdid";
1890 std::vector<int32_t> localUserIds;
1891 EXPECT_CALL(*deviceProfileConnectorMock_, DeleteAclForRemoteUserRemoved(_, _, _))
1892 .WillOnce(DoAll(SetArgReferee<2>(localUserIds), Return()));
1893 deviceManagerServiceImpl_->HandleRemoteUserRemoved(userId, remoteUdid);
1894 }
1895
1896 HWTEST_F(DeviceManagerServiceImplTest, RequestCredential_003, testing::ext::TestSize.Level0)
1897 {
1898 const std::string reqJsonStr = "test";
1899 std::string returnJsonStr = "returntest";
1900 if (deviceManagerServiceImpl_ == nullptr) {
1901 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1902 }
1903 if (deviceManagerServiceImpl_->credentialMgr_ == nullptr) {
1904 deviceManagerServiceImpl_->Initialize(listener_);
1905 }
1906 int32_t ret = deviceManagerServiceImpl_->RequestCredential(reqJsonStr, returnJsonStr);
1907 EXPECT_EQ(ret, ERR_DM_FAILED);
1908 }
1909
1910 HWTEST_F(DeviceManagerServiceImplTest, ImportCredential_010, testing::ext::TestSize.Level0)
1911 {
1912 std::string pkgName = "pkgName";
1913 std::string credentialInfo = "credentialInfo";
1914 if (deviceManagerServiceImpl_ == nullptr) {
1915 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1916 }
1917 if (deviceManagerServiceImpl_->credentialMgr_ == nullptr) {
1918 deviceManagerServiceImpl_->Initialize(listener_);
1919 }
1920 int32_t ret = deviceManagerServiceImpl_->ImportCredential(pkgName, credentialInfo);
1921 EXPECT_EQ(ret, ERR_DM_FAILED);
1922 }
1923
1924 HWTEST_F(DeviceManagerServiceImplTest, DeleteCredential_010, testing::ext::TestSize.Level0)
1925 {
1926 std::string pkgName = "pkgName";
1927 std::string deleteInfo = "deleteInfo";
1928 if (deviceManagerServiceImpl_ == nullptr) {
1929 deviceManagerServiceImpl_ = std::make_shared<DeviceManagerServiceImpl>();
1930 }
1931 if (deviceManagerServiceImpl_->credentialMgr_ == nullptr) {
1932 deviceManagerServiceImpl_->Initialize(listener_);
1933 }
1934 int32_t ret = deviceManagerServiceImpl_->DeleteCredential(pkgName, deleteInfo);
1935 EXPECT_EQ(ret, ERR_DM_FAILED);
1936
1937 std::vector<DistributedDeviceProfile::AccessControlProfile> profiles;
1938 DistributedDeviceProfile::AccessControlProfile accessProfile;
1939 accessProfile.SetBindType(1);
1940 profiles.push_back(accessProfile);
1941 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1942 deviceManagerServiceImpl_->DeleteAlwaysAllowTimeOut();
1943
1944 std::string remoteUdid = "remoteUdid";
1945 profiles.clear();
1946 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1947 deviceManagerServiceImpl_->CheckDeleteCredential(remoteUdid);
1948
1949 accessProfile.SetTrustDeviceId(remoteUdid);
1950 profiles.push_back(accessProfile);
1951 EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).WillOnce(Return(profiles));
1952 deviceManagerServiceImpl_->CheckDeleteCredential(remoteUdid);
1953 }
1954 } // namespace
1955 } // namespace DistributedHardware
1956 } // namespace OHOS
1957