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