1/* 2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "UTTest_device_manager_service.h" 17 18#include "accesstoken_kit.h" 19#include "dm_constants.h" 20#include "dm_device_info.h" 21#include "dm_log.h" 22#include "nativetoken_kit.h" 23#include "token_setproc.h" 24#include "softbus_common.h" 25#include "softbus_error_code.h" 26 27using namespace OHOS::Security::AccessToken; 28namespace OHOS { 29namespace DistributedHardware { 30DM_IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService); 31 32void DeviceManagerServiceTest::SetUp() 33{ 34 const int32_t permsNum = 4; 35 const int32_t indexZero = 0; 36 const int32_t indexOne = 1; 37 const int32_t indexTwo = 2; 38 const int32_t indexThree = 3; 39 uint64_t tokenId; 40 const char *perms[permsNum]; 41 perms[indexZero] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER"; 42 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC"; 43 perms[indexTwo] = "ohos.permission.ACCESS_SERVICE_DM"; 44 perms[indexThree] = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE"; 45 NativeTokenInfoParams infoInstance = { 46 .dcapsNum = 0, 47 .permsNum = permsNum, 48 .aclsNum = 0, 49 .dcaps = NULL, 50 .perms = perms, 51 .acls = NULL, 52 .processName = "dsoftbus_service", 53 .aplStr = "system_core", 54 }; 55 tokenId = GetAccessTokenId(&infoInstance); 56 SetSelfTokenID(tokenId); 57 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); 58} 59 60void DeviceManagerServiceTest::TearDown() 61{ 62} 63 64void DeviceManagerServiceTest::SetUpTestCase() 65{ 66} 67 68void DeviceManagerServiceTest::TearDownTestCase() 69{ 70} 71 72namespace { 73void DeletePermission() 74{ 75 const int32_t permsNum = 1; 76 const int32_t indexZero = 0; 77 uint64_t tokenId; 78 const char *perms[permsNum]; 79 perms[indexZero] = "ohos.permission"; 80 NativeTokenInfoParams infoInstance = { 81 .dcapsNum = 0, 82 .permsNum = permsNum, 83 .aclsNum = 0, 84 .dcaps = NULL, 85 .perms = perms, 86 .acls = NULL, 87 .processName = "DeviceManagerServiceTest", 88 .aplStr = "system_core", 89 }; 90 tokenId = GetAccessTokenId(&infoInstance); 91 SetSelfTokenID(tokenId); 92 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); 93} 94 95/** 96 * @tc.name: InitDMServiceListener_001 97 * @tc.desc: Init device manager listener and return DM_OK 98 * @tc.type: FUNC 99 * @tc.require: AR000GHSJK 100 */ 101HWTEST_F(DeviceManagerServiceTest, InitDMServiceListener_001, testing::ext::TestSize.Level0) 102{ 103 int ret = DeviceManagerService::GetInstance().InitDMServiceListener(); 104 EXPECT_EQ(ret, DM_OK); 105 DeviceManagerService::GetInstance().UninitDMServiceListener(); 106} 107 108/** 109 * @tc.name: StartDeviceDiscovery_001 110 * @tc.desc: Start device discovery and return ERR_DM_NO_PERMISSION 111 * @tc.type: FUNC 112 * @tc.require: AR000GHSJK 113 */ 114HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0) 115{ 116 DeletePermission(); 117 std::string pkgName = "com.ohos.test"; 118 DmSubscribeInfo subscribeInfo; 119 std::string extra; 120 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); 121 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 122} 123 124/** 125 * @tc.name: StartDeviceDiscovery_002 126 * @tc.desc: Empty pkgName of StartDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID 127 * @tc.type: FUNC 128 * @tc.require: AR000GHSJK 129 */ 130HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0) 131{ 132 std::string pkgName; 133 DmSubscribeInfo subscribeInfo; 134 std::string extra = "test"; 135 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); 136 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 137} 138 139/** 140 * @tc.name: StartDeviceDiscovery_003 141 * @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return 142 * ERR_DM_DISCOVERY_REPEATED 143 * @tc.type: FUNC 144 * @tc.require: AR000GHSJK 145 */ 146HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0) 147{ 148 std::string pkgName = "com.ohos.test"; 149 DmSubscribeInfo subscribeInfo; 150 std::string extra = "test"; 151 DeviceManagerService::GetInstance().InitDMServiceListener(); 152 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); 153 EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED); 154 DeviceManagerService::GetInstance().UninitDMServiceListener(); 155} 156 157/** 158 * @tc.name: StopDeviceDiscovery_001 159 * @tc.desc: Stop device discovery and return SOFTBUS_ERR 160 * @tc.type: FUNC 161 * @tc.require: AR000GHSJK 162 */ 163HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0) 164{ 165 std::string pkgName = "com.ohos.test"; 166 uint16_t subscribeId = 1; 167 DeviceManagerService::GetInstance().InitDMServiceListener(); 168 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); 169 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); 170 DeviceManagerService::GetInstance().UninitDMServiceListener(); 171} 172 173/** 174 * @tc.name:StopDeviceDiscovery_002 175 * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID 176 * @tc.type: FUNC 177 * @tc.require: AR000GHSJK 178 */ 179HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0) 180{ 181 std::string pkgName; 182 uint16_t subscribeId = 1; 183 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); 184 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 185} 186 187/** 188 * @tc.name:StopDeviceDiscovery_003 189 * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID 190 * @tc.type: FUNC 191 * @tc.require: AR000GHSJK 192 */ 193HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0) 194{ 195 DeletePermission(); 196 std::string pkgName = "StopDeviceDiscovery_003"; 197 uint16_t subscribeId = 1; 198 int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); 199 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 200} 201 202/** 203 * @tc.name: PublishDeviceDiscovery_001 204 * @tc.desc: Publish device discovery and return ERR_DM_NO_PERMISSION 205 * @tc.type: FUNC 206 * @tc.require: I5N1K3 207 */ 208HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0) 209{ 210 DeletePermission(); 211 std::string pkgName = "com.ohos.test12"; 212 DmPublishInfo publishInfo; 213 publishInfo.publishId = 1; 214 publishInfo.mode = DM_DISCOVER_MODE_ACTIVE; 215 publishInfo.freq = DM_HIGH; 216 publishInfo.ranging = 1; 217 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 218 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 219 DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishInfo.publishId); 220} 221 222/** 223 * @tc.name: PublishDeviceDiscovery_002 224 * @tc.desc: Empty pkgName of PublishDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID 225 * @tc.type: FUNC 226 * @tc.require: I5N1K3 227 */ 228HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0) 229{ 230 std::string pkgName; 231 DmPublishInfo publishInfo; 232 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 233 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 234} 235 236/** 237 * @tc.name: PublishDeviceDiscovery_003 238 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return 239 * SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM 240 * @tc.type: FUNC 241 * @tc.require: I5N1K3 242 */ 243HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0) 244{ 245 std::string pkgName = "com.ohos.test"; 246 DmPublishInfo publishInfo; 247 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 248 pkgName = "1com.ohos.test1"; 249 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 250 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 251} 252 253/** 254 * @tc.name: PublishDeviceDiscovery_004 255 * @tc.desc: Call PublishDeviceDiscovery twice with pkgName not null and flag bit not false and return 256 * SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM 257 * @tc.type: FUNC 258 * @tc.require: I5N1K3 259 */ 260HWTEST_F(DeviceManagerServiceTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0) 261{ 262 std::string pkgName = "PublishDeviceDiscovery_004"; 263 DmPublishInfo publishInfo; 264 DeviceManagerService::GetInstance().InitDMServiceListener(); 265 int ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 266 pkgName = "1com.ohos.test1"; 267 ret = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, publishInfo); 268 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM); 269 DeviceManagerService::GetInstance().UninitDMServiceListener(); 270} 271 272/** 273 * @tc.name: UnPublishDeviceDiscovery_001 274 * @tc.desc: UnPublish device discovery and return SOFTBUS_ERR 275 * @tc.type: FUNC 276 * @tc.require: I5N1K3 277 */ 278HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0) 279{ 280 std::string pkgName = "com.ohos.test"; 281 int32_t publishId = 1; 282 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); 283 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 284} 285 286/** 287 * @tc.name: UnPublishDeviceDiscovery_002 288 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID 289 * @tc.type: FUNC 290 * @tc.require: I5N1K3 291 */ 292HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0) 293{ 294 std::string pkgName; 295 int32_t publishId = 1; 296 DeviceManagerService::GetInstance().InitDMServiceListener(); 297 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); 298 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 299 DeviceManagerService::GetInstance().UninitDMServiceListener(); 300} 301 302/** 303 * @tc.name: UnPublishDeviceDiscovery_003 304 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID 305 * @tc.type: FUNC 306 * @tc.require: I5N1K3 307 */ 308HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0) 309{ 310 std::string pkgName = "com.ohos.test003"; 311 int32_t publishId = 1; 312 DeviceManagerService::GetInstance().InitDMServiceListener(); 313 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); 314 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); 315 DeviceManagerService::GetInstance().UninitDMServiceListener(); 316} 317 318/** 319 * @tc.name: UnPublishDeviceDiscovery_004 320 * @tc.desc: UnPublishDeviceDiscovery is initialized, pkgName is null, and its return ERR_DM_INPUT_PARA_INVALID 321 * @tc.type: FUNC 322 * @tc.require: I5N1K3 323 */ 324HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0) 325{ 326 std::string pkgName = "com.ohos.test003"; 327 int32_t publishId = 1; 328 int32_t userId = 23; 329 std::string accountId = "hello123"; 330 int32_t preUserId = 3; 331 std::vector<std::string> peerUdids; 332 std::string accountName = "openharmony123"; 333 std::string commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED; 334 DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType); 335 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN; 336 DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType); 337 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT; 338 DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType); 339 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED; 340 DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType); 341 commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED; 342 DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType); 343 DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId); 344 DeviceManagerService::GetInstance().HandleUserRemoved(preUserId); 345 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 346 DeviceManagerService::GetInstance().SendAccountLogoutBroadCast(peerUdids, accountId, accountName, userId); 347 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 348 DeletePermission(); 349 int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId); 350 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 351} 352 353/** 354 * @tc.name: GetTrustedDeviceList_001 355 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true and pkgName = null; Return ERR_DM_INPUT_PARA_INVALID 356 * @tc.type: FUNC 357 * @tc.require: AR000GHSJK 358 */ 359HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0) 360{ 361 std::string pkgName; 362 std::string extra = "jdddd"; 363 std::vector<DmDeviceInfo> deviceList; 364 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); 365 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 366} 367 368/** 369 * @tc.name: GetTrustedDeviceList_002 370 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true; Return DM_OK 371 * @tc.type: FUNC 372 * @tc.require: AR000GHSJK 373 */ 374HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0) 375{ 376 std::string pkgName = "ohos_test"; 377 std::string extra = "jdddd"; 378 std::vector<DmDeviceInfo> deviceList; 379 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 380 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); 381 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 382} 383 384/** 385 * @tc.name: GetTrustedDeviceList_003 386 * @tc.desc:Set the intFlag of GetTrustedDeviceList to true; Return DM_OK 387 * @tc.type: FUNC 388 * @tc.require: AR000GHSJK 389 */ 390HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0) 391{ 392 std::string pkgName = "ohos_test"; 393 std::string extra = "jdddd"; 394 std::vector<DmDeviceInfo> deviceList; 395 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 396 DeviceManagerService::GetInstance().InitDMServiceListener(); 397 int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); 398 EXPECT_EQ(ret, DM_OK); 399 DeviceManagerService::GetInstance().UninitDMServiceListener(); 400 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 401} 402 403/** 404 * @tc.name: ShiftLNNGear_001 405 * @tc.desc:Set the pkgName to null, callerId not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID 406 * @tc.type: FUNC 407 * @tc.require: AR000GHSJK 408 */ 409HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_001, testing::ext::TestSize.Level0) 410{ 411 std::string pkgName; 412 std::string callerId = "com.ohos.test"; 413 bool isRefresh = true; 414 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 415 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 416} 417 418/** 419 * @tc.name: ShiftLNNGear_002 420 * @tc.desc:Set the callerId to null, pkgNamenot not to null, and isRefresh to true; Return ERR_DM_INPUT_PARA_INVALID 421 * @tc.type: FUNC 422 * @tc.require: AR000GHSJK 423 */ 424HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_002, testing::ext::TestSize.Level0) 425{ 426 std::string pkgName = "com.ohos.test"; 427 std::string callerId; 428 bool isRefresh = true; 429 std::vector<DmDeviceInfo> deviceList; 430 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 431 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 432} 433 434/** 435 * @tc.name: ShiftLNNGear_003 436 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return DM_OK 437 * @tc.type: FUNC 438 * @tc.require: AR000GHSJK 439 */ 440HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_003, testing::ext::TestSize.Level0) 441{ 442 const int32_t permsNum = 1; 443 const int32_t indexZero = 0; 444 uint64_t tokenId; 445 const char *perms[permsNum]; 446 perms[indexZero] = "ohos.permission"; 447 NativeTokenInfoParams infoInstance = { 448 .dcapsNum = 0, 449 .permsNum = permsNum, 450 .aclsNum = 0, 451 .dcaps = NULL, 452 .perms = perms, 453 .acls = NULL, 454 .processName = "DeviceManagerServiceTest", 455 .aplStr = "system_core", 456 }; 457 tokenId = GetAccessTokenId(&infoInstance); 458 SetSelfTokenID(tokenId); 459 std::string pkgName = "com.ohos.test"; 460 std::string callerId = "com.ohos.test"; 461 bool isRefresh = true; 462 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 463 EXPECT_NE(ret, DM_OK); 464} 465 466/** 467 * @tc.name: ShiftLNNGear_004 468 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to false; Return DM_OK 469 * @tc.type: FUNC 470 * @tc.require: AR000GHSJK 471 */ 472HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_004, testing::ext::TestSize.Level0) 473{ 474 const int32_t permsNum = 1; 475 const int32_t indexZero = 0; 476 uint64_t tokenId; 477 const char *perms[permsNum]; 478 perms[indexZero] = "ohos.permission"; 479 NativeTokenInfoParams infoInstance = { 480 .dcapsNum = 0, 481 .permsNum = permsNum, 482 .aclsNum = 0, 483 .dcaps = NULL, 484 .perms = perms, 485 .acls = NULL, 486 .processName = "DeviceManagerServiceTest", 487 .aplStr = "system_core", 488 }; 489 tokenId = GetAccessTokenId(&infoInstance); 490 SetSelfTokenID(tokenId); 491 std::string pkgName = "com.ohos.test"; 492 std::string callerId = "com.ohos.test"; 493 bool isRefresh = false; 494 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 495 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 496} 497 498/** 499 * @tc.name: ShiftLNNGear_005 500 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to false; Return DM_OK 501 * @tc.type: FUNC 502 * @tc.require: AR000GHSJK 503 */ 504HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_005, testing::ext::TestSize.Level0) 505{ 506 std::string pkgName = "com.ohos.test"; 507 std::string callerId = "com.ohos.test"; 508 bool isRefresh = false; 509 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 510 EXPECT_EQ(ret, DM_OK); 511} 512 513/** 514 * @tc.name: ShiftLNNGear_006 515 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return NOT DM_OK 516 * @tc.type: FUNC 517 * @tc.require: AR000GHSJK 518 */ 519HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_006, testing::ext::TestSize.Level0) 520{ 521 std::string pkgName = "ShiftLNNGear_006"; 522 std::string callerId = "ShiftLNNGear_006"; 523 bool isRefresh = true; 524 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 525 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 526 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 527} 528 529/** 530 * @tc.name: ShiftLNNGear_007 531 * @tc.desc:Set the callerId and pkgNamenot not to null, and isRefresh to true; Return NOT DM_OK 532 * @tc.type: FUNC 533 * @tc.require: AR000GHSJK 534 */ 535HWTEST_F(DeviceManagerServiceTest, ShiftLNNGear_007, testing::ext::TestSize.Level0) 536{ 537 std::string pkgName = "ShiftLNNGear_007"; 538 std::string callerId = "ShiftLNNGear_007"; 539 bool isRefresh = true; 540 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 541 int ret = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, callerId, isRefresh, false); 542 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 543 EXPECT_NE(ret, DM_OK); 544} 545 546/** 547 * @tc.name: AuthenticateDevice_001 548 * @tc.desc: Set unsupport authType = 0 and return ERR_DM_INPUT_PARA_INVALID 549 * @tc.type: FUNC 550 * @tc.require: AR000GHSJK 551 */ 552HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_001, testing::ext::TestSize.Level0) 553{ 554 std::string pkgName = "com.ohos.test"; 555 std::string extra = "jdddd"; 556 int32_t authType = 1; 557 std::string deviceId; 558 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); 559 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 560} 561 562/** 563 * @tc.name: AuthenticateDevice_002 564 * @tc.desc: Set intFlag for GAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID 565 * @tc.type: FUNC 566 * @tc.require: AR000GHSJK 567 */ 568HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_002, testing::ext::TestSize.Level0) 569{ 570 std::string pkgName; 571 std::string extra = "jdddd"; 572 int32_t authType = 0; 573 std::string deviceId = " 2345"; 574 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); 575 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 576} 577 578/** 579 * @tc.name: AuthenticateDevice_003 580 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_BIND_INPUT_PARA_INVALID 581 * @tc.type: FUNC 582 * @tc.require: AR000GHSJK 583 */ 584HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_003, testing::ext::TestSize.Level0) 585{ 586 std::string pkgName = "com.ohos.test"; 587 std::string extra = "jdddd"; 588 int32_t authType = 0; 589 std::string deviceId = " 2345"; 590 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); 591 EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID); 592} 593 594/** 595 * @tc.name: AuthenticateDevice_004 596 * @tc.desc: Set intFlag for GAuthenticateDevice to True and deviceId to null; Return ERR_DM_NO_PERMISSION 597 * @tc.type: FUNC 598 * @tc.require: AR000GHSJK 599 */ 600HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_004, testing::ext::TestSize.Level0) 601{ 602 std::string pkgName = "com.ohos.test"; 603 std::string extra = "jdddd"; 604 int32_t authType = 0; 605 std::string deviceId = " 2345"; 606 DeletePermission(); 607 int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); 608 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 609} 610 611/** 612 * @tc.name: UnAuthenticateDevice_001 613 * @tc.desc: 将UnAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";Return ERR_DM_NO_PERMISSION 614 * @tc.type: FUNC 615 * @tc.require: AR000GHSJK 616 */ 617HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0) 618{ 619 DeletePermission(); 620 std::string pkgName = "com.ohos.test"; 621 std::string networkId = "12345"; 622 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId); 623 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 624} 625 626/** 627 * @tc.name: UnAuthenticateDevice_002 628 * @tc.desc: Set intFlag for UnAuthenticateDevice to True and pkgName to null; Return ERR_DM_INPUT_PARA_INVALID 629 * @tc.type: FUNC 630 * @tc.require: AR000GHSJK 631 */ 632HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0) 633{ 634 std::string pkgName; 635 std::string networkId = "12345"; 636 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId); 637 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 638} 639 640/** 641 * @tc.name: UnAuthenticateDevice_003 642 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return 643 * value is ERR_DM_INPUT_PARA_INVALID 644 * @tc.type: FUNC 645 * @tc.require: AR000GHSJK 646 */ 647HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0) 648{ 649 std::string pkgName = "com.ohos.test"; 650 std::string networkId; 651 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId); 652 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 653} 654 655/** 656 * @tc.name: UnAuthenticateDevice_004 657 * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return 658 * value is SOFTBUS_IPC_ERR 659 * @tc.type: FUNC 660 * @tc.require: AR000GHSJK 661 */ 662HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0) 663{ 664 std::string pkgName = "com.ohos.test"; 665 std::string networkId = "12345"; 666 int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, networkId); 667 EXPECT_EQ(ret, ERR_DM_FAILED); 668} 669 670/** 671 * @tc.name: GetUdidByNetworkId_001 672 * @tc.desc: Make success for GetUdidByNetworkId，The return value is 673 * SOFTBUS_IPC_ERR 674 * @tc.type: FUNC 675 * @tc.require: AR000GHSJK 676 */ 677HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0) 678{ 679 std::string pkgName = "com.ohos.test"; 680 std::string netWorkId = "123"; 681 std::string udid = "123"; 682 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid); 683 EXPECT_EQ(ret, SOFTBUS_IPC_ERR); 684} 685 686/** 687 * @tc.name: GetUdidByNetworkId_002 688 * @tc.desc: Make not init for GetUdidByNetworkId，The return value is 689 * ERR_DM_INPUT_PARA_INVALID 690 * @tc.type: FUNC 691 * @tc.require: AR000GHSJK 692 */ 693HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0) 694{ 695 std::string pkgName; 696 std::string netWorkId = "111"; 697 std::string udid = "2222"; 698 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid); 699 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 700} 701 702/** 703 * @tc.name: GetUdidByNetworkId_003 704 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is 705 * ERR_DM_INPUT_PARA_INVALID 706 * @tc.type: FUNC 707 * @tc.require: AR000GHSJK 708 */ 709HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0) 710{ 711 std::string pkgName = "pkgName"; 712 std::string netWorkId = ""; 713 std::string udid = ""; 714 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid); 715 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 716} 717 718/** 719 * @tc.name: GetUdidByNetworkId_004 720 * @tc.desc: Make pkgName empty for GetUdidByNetworkId，The return value is 721 * ERR_DM_INPUT_PARA_INVALID 722 * @tc.type: FUNC 723 * @tc.require: AR000GHSJK 724 */ 725HWTEST_F(DeviceManagerServiceTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0) 726{ 727 std::string pkgName = "pkgName"; 728 std::string netWorkId = "123"; 729 std::string udid = "123"; 730 DeletePermission(); 731 int ret = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid); 732 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 733} 734 735/** 736 * @tc.name: GetUuidByNetworkId_001 737 * @tc.desc: Make success for GetUuidByNetworkId，The return value is 738 * SOFTBUS_IPC_ERR 739 * @tc.type: FUNC 740 * @tc.require: AR000GHSJK 741 */ 742HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0) 743{ 744 std::string pkgName = "com.ohos.test"; 745 std::string netWorkId = "12"; 746 std::string uuid = "12"; 747 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid); 748 EXPECT_EQ(ret, SOFTBUS_IPC_ERR); 749} 750 751/** 752 * @tc.name: GetUuidByNetworkId_002 753 * @tc.desc: Make not init for GetUuidByNetworkId，The return value is 754 * ERR_DM_INPUT_PARA_INVALID 755 * @tc.type: FUNC 756 * @tc.require: AR000GHSJK 757 */ 758HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0) 759{ 760 std::string pkgName; 761 std::string netWorkId = "12"; 762 std::string uuid = "21"; 763 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid); 764 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 765} 766 767/** 768 * @tc.name: GetUuidByNetworkId_003 769 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is 770 * ERR_DM_INPUT_PARA_INVALID 771 * @tc.type: FUNC 772 * @tc.require: AR000GHSJK 773 */ 774HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0) 775{ 776 std::string pkgName = "com.ohos.test"; 777 std::string netWorkId = ""; 778 std::string uuid = ""; 779 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid); 780 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 781} 782 783/** 784 * @tc.name: GetUuidByNetworkId_004 785 * @tc.desc: Make pkgName empty for GetUuidByNetworkId，The return value is 786 * ERR_DM_INPUT_PARA_INVALID 787 * @tc.type: FUNC 788 * @tc.require: AR000GHSJK 789 */ 790HWTEST_F(DeviceManagerServiceTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0) 791{ 792 std::string pkgName = "com.ohos.test"; 793 std::string netWorkId = ""; 794 std::string uuid = ""; 795 DeletePermission(); 796 int ret = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid); 797 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 798} 799 800/** 801 * @tc.name: SetUserOperation_001 802 * @tc.desc: Make success for SetUserOperation，The return value is 803 * ERR_DM_NO_PERMISSION 804 * @tc.type: FUNC 805 * @tc.require: AR000GHSJK 806 */ 807HWTEST_F(DeviceManagerServiceTest, SetUserOperation_001, testing::ext::TestSize.Level0) 808{ 809 DeletePermission(); 810 std::string pkgName = "com.ohos.test"; 811 int32_t action = 0; 812 const std::string param = "extra"; 813 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param); 814 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 815} 816 817/** 818 * @tc.name: SetUserOperation_002 819 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is 820 * ERR_DM_INPUT_PARA_INVALID 821 * @tc.type: FUNC 822 * @tc.require: AR000GHSJK 823 */ 824HWTEST_F(DeviceManagerServiceTest, SetUserOperation_002, testing::ext::TestSize.Level0) 825{ 826 std::string pkgName = ""; 827 int32_t action = 0; 828 const std::string param = "extra"; 829 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param); 830 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 831} 832 833/** 834 * @tc.name: SetUserOperation_003 835 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is 836 * ERR_DM_INPUT_PARA_INVALID 837 * @tc.type: FUNC 838 * @tc.require: AR000GHSJK 839 */ 840HWTEST_F(DeviceManagerServiceTest, SetUserOperation_003, testing::ext::TestSize.Level0) 841{ 842 std::string pkgName = "pkgName"; 843 int32_t action = 0; 844 const std::string param; 845 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param); 846 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 847} 848 849/** 850 * @tc.name: SetUserOperation_004 851 * @tc.desc: Make pkgName empty for SetUserOperation，The return value is 852 * DM_OK 853 * @tc.type: FUNC 854 * @tc.require: AR000GHSJK 855 */ 856HWTEST_F(DeviceManagerServiceTest, SetUserOperation_004, testing::ext::TestSize.Level0) 857{ 858 std::string pkgName = "pkgName"; 859 int32_t action = 0; 860 const std::string param = "extra"; 861 int ret = DeviceManagerService::GetInstance().SetUserOperation(pkgName, action, param); 862 EXPECT_EQ(ret, DM_OK); 863} 864 865/** 866 * @tc.name: GetLocalDeviceInfo_001 867 * @tc.desc: The return value is DM_OK 868 * @tc.type: FUNC 869 * @tc.require: AR000GHSJK 870 */ 871HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0) 872{ 873 DmDeviceInfo info; 874 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 875 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info); 876 EXPECT_EQ(ret, DM_OK); 877} 878 879/** 880 * @tc.name: RequestCredential_001 881 * @tc.desc:The return value is ERR_DM_FAILED 882 * @tc.type: FUNC 883 * @tc.require: AR000GHSJK 884 */ 885HWTEST_F(DeviceManagerServiceTest, RequestCredential_001, testing::ext::TestSize.Level0) 886{ 887 const std::string reqJsonStr = "test"; 888 std::string returnJsonStr = "returntest"; 889 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr); 890 EXPECT_EQ(ret, ERR_DM_FAILED); 891} 892 893/** 894 * @tc.name: RequestCredential_002 895 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID 896 * @tc.type: FUNC 897 * @tc.require: AR000GHSJK 898 */ 899HWTEST_F(DeviceManagerServiceTest, RequestCredential_002, testing::ext::TestSize.Level0) 900{ 901 const std::string reqJsonStr = ""; 902 std::string returnJsonStr = "returntest"; 903 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr); 904 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 905} 906 907/** 908 * @tc.name: RequestCredential_003 909 * @tc.desc:The return value is ERR_DM_FAILED 910 * @tc.type: FUNC 911 * @tc.require: AR000GHSJK 912 */ 913HWTEST_F(DeviceManagerServiceTest, RequestCredential_003, testing::ext::TestSize.Level0) 914{ 915 const std::string reqJsonStr = "test"; 916 std::string returnJsonStr = "returntest"; 917 DeletePermission(); 918 int32_t ret = DeviceManagerService::GetInstance().RequestCredential(reqJsonStr, returnJsonStr); 919 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 920} 921 922/** 923 * @tc.name: ImportCredential_001 924 * @tc.desc:The return value is ERR_DM_FAILED 925 * @tc.type: FUNC 926 * @tc.require: AR000GHSJK 927 */ 928HWTEST_F(DeviceManagerServiceTest, ImportCredential_001, testing::ext::TestSize.Level0) 929{ 930 const std::string pkgName = "pkgNametest"; 931 const std::string credentialInfo = "credentialInfotest"; 932 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo); 933 EXPECT_EQ(ret, ERR_DM_FAILED); 934} 935 936/** 937 * @tc.name: ImportCredential_002 938 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID 939 * @tc.type: FUNC 940 * @tc.require: AR000GHSJK 941 */ 942HWTEST_F(DeviceManagerServiceTest, ImportCredential_002, testing::ext::TestSize.Level0) 943{ 944 const std::string pkgName = ""; 945 const std::string credentialInfo = ""; 946 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo); 947 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 948} 949 950/** 951 * @tc.name: ImportCredential_003 952 * @tc.desc:The return value is ERR_DM_FAILED 953 * @tc.type: FUNC 954 * @tc.require: AR000GHSJK 955 */ 956HWTEST_F(DeviceManagerServiceTest, ImportCredential_003, testing::ext::TestSize.Level0) 957{ 958 const std::string pkgName = "pkgNametest"; 959 const std::string credentialInfo = "credentialInfotest"; 960 DeletePermission(); 961 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, credentialInfo); 962 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 963} 964 965/** 966 * @tc.name: DeleteCredential_001 967 * @tc.desc:The return value is ERR_DM_FAILED 968 * @tc.type: FUNC 969 * @tc.require: AR000GHSJK 970 */ 971HWTEST_F(DeviceManagerServiceTest, DeleteCredential_001, testing::ext::TestSize.Level0) 972{ 973 const std::string pkgName = "pkgNametest"; 974 const std::string deleteInfo = "deleteInfotest"; 975 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo); 976 EXPECT_EQ(ret, ERR_DM_FAILED); 977} 978 979/** 980 * @tc.name: DeleteCredential_002 981 * @tc.desc:The return value is ERR_DM_NO_PERMISSION 982 * @tc.type: FUNC 983 * @tc.require: AR000GHSJK 984 */ 985HWTEST_F(DeviceManagerServiceTest, DeleteCredential_002, testing::ext::TestSize.Level0) 986{ 987 const std::string pkgName = "pkgNametest"; 988 const std::string deleteInfo = "deleteInfotest"; 989 DeletePermission(); 990 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo); 991 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 992} 993 994/** 995 * @tc.name: DeleteCredential_003 996 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID 997 * @tc.type: FUNC 998 * @tc.require: AR000GHSJK 999 */ 1000HWTEST_F(DeviceManagerServiceTest, DeleteCredential_003, testing::ext::TestSize.Level0) 1001{ 1002 const std::string pkgName = ""; 1003 const std::string deleteInfo = ""; 1004 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, deleteInfo); 1005 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1006} 1007 1008/** 1009 * @tc.name: RegisterCredentialCallback_001 1010 * @tc.desc: The return value is DM_OK 1011 * @tc.type: FUNC 1012 * @tc.require: AR000GHSJK 1013 */ 1014HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_001, testing::ext::TestSize.Level0) 1015{ 1016 const std::string pkgName = "pkgNametest"; 1017 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName); 1018 EXPECT_EQ(ret, DM_OK); 1019} 1020 1021/** 1022 * @tc.name: RegisterCredentialCallback_002 1023 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID 1024 * @tc.type: FUNC 1025 * @tc.require: AR000GHSJK 1026 */ 1027HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_002, testing::ext::TestSize.Level0) 1028{ 1029 const std::string pkgName = ""; 1030 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName); 1031 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1032} 1033 1034/** 1035 * @tc.name: RegisterCredentialCallback_003 1036 * @tc.desc: The return value is ERR_DM_NO_PERMISSION 1037 * @tc.type: FUNC 1038 * @tc.require: AR000GHSJK 1039 */ 1040HWTEST_F(DeviceManagerServiceTest, RegisterCredentialCallback_003, testing::ext::TestSize.Level0) 1041{ 1042 const std::string pkgName = "pkgNametest"; 1043 DeletePermission(); 1044 int32_t ret = DeviceManagerService::GetInstance().RegisterCredentialCallback(pkgName); 1045 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1046} 1047 1048/** 1049 * @tc.name: UnRegisterCredentialCallback_001 1050 * @tc.desc:The return value is DM_OK 1051 * @tc.type: FUNC 1052 * @tc.require: AR000GHSJK 1053 */ 1054HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_001, testing::ext::TestSize.Level0) 1055{ 1056 const std::string pkgName = "pkgNametest"; 1057 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName); 1058 EXPECT_EQ(ret, DM_OK); 1059} 1060 1061/** 1062 * @tc.name: UnRegisterCredentialCallback_002 1063 * @tc.desc:The return value is ERR_DM_INPUT_PARA_INVALID 1064 * @tc.type: FUNC 1065 * @tc.require: AR000GHSJK 1066 */ 1067HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_002, testing::ext::TestSize.Level0) 1068{ 1069 const std::string pkgName = ""; 1070 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName); 1071 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1072} 1073 1074/** 1075 * @tc.name: UnRegisterCredentialCallback_003 1076 * @tc.desc:The return value is ERR_DM_NO_PERMISSION 1077 * @tc.type: FUNC 1078 * @tc.require: AR000GHSJK 1079 */ 1080HWTEST_F(DeviceManagerServiceTest, UnRegisterCredentialCallback_003, testing::ext::TestSize.Level0) 1081{ 1082 const std::string pkgName = "pkgNametest"; 1083 DeletePermission(); 1084 int32_t ret = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(pkgName); 1085 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1086} 1087 1088/** 1089 * @tc.name: UninitSoftbusListener_001 1090 * @tc.desc: DeviceManagerService::GetInstance().softbusListener_ is nullptr 1091 * @tc.type: FUNC 1092 * @tc.require: AR000GHSJK 1093 */ 1094HWTEST_F(DeviceManagerServiceTest, UninitSoftbusListener_001, testing::ext::TestSize.Level0) 1095{ 1096 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 1097 DeviceManagerService::GetInstance().UninitSoftbusListener(); 1098 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 1099} 1100 1101/** 1102 * @tc.name: UninitDMServiceListener_001 1103 * @tc.desc: DeviceManagerService::GetInstance().listener_ is nullptr 1104 * @tc.type: FUNC 1105 * @tc.require: AR000GHSJK 1106 */ 1107HWTEST_F(DeviceManagerServiceTest, UninitDMServiceListener_001, testing::ext::TestSize.Level0) 1108{ 1109 DeviceManagerService::GetInstance().listener_ = std::make_shared<DeviceManagerServiceListener>(); 1110 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1111 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr); 1112} 1113 1114/** 1115 * @tc.name: IsDMServiceImplReady_001 1116 * @tc.desc: The return value is true 1117 * @tc.type: FUNC 1118 * @tc.require: AR000GHSJK 1119 */ 1120HWTEST_F(DeviceManagerServiceTest, IsDMServiceImplReady_001, testing::ext::TestSize.Level0) 1121{ 1122 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1123 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplReady(); 1124 EXPECT_EQ(ret, true); 1125} 1126 1127/** 1128 * @tc.name: GetDeviceInfo_001 1129 * @tc.desc: The return value is ERR_DM_INPUT_PARA_INVALID 1130 * @tc.type: FUNC 1131 * @tc.require: AR000GHSJK 1132 */ 1133HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_001, testing::ext::TestSize.Level0) 1134{ 1135 std::string networkId = ""; 1136 DmDeviceInfo info; 1137 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info); 1138 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1139} 1140 1141/** 1142 * @tc.name: GetDeviceInfo_002 1143 * @tc.desc: The return value is DM_OK 1144 * @tc.type: FUNC 1145 * @tc.require: AR000GHSJK 1146 */ 1147HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_002, testing::ext::TestSize.Level0) 1148{ 1149 std::string networkId = "networkIdTest"; 1150 DmDeviceInfo info; 1151 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info); 1152 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 1153} 1154 1155/** 1156 * @tc.name: GetDeviceInfo_004 1157 * @tc.desc: The return value is DM_OK 1158 * @tc.type: FUNC 1159 * @tc.require: AR000GHSJK 1160 */ 1161HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_004, testing::ext::TestSize.Level0) 1162{ 1163 std::string networkId = "networkIdTest4"; 1164 DmDeviceInfo info; 1165 DeletePermission(); 1166 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info); 1167 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1168} 1169 1170/** 1171 * @tc.name: CheckApiPermission_001 1172 * @tc.desc: The return value is DM_OK 1173 * @tc.type: FUNC 1174 */ 1175HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_001, testing::ext::TestSize.Level0) 1176{ 1177 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(0); 1178 EXPECT_EQ(ret, DM_OK); 1179} 1180 1181/** 1182 * @tc.name: RegisterCallerAppId_001 1183 * @tc.desc: Set pkgName null 1184 * @tc.type: FUNC 1185 */ 1186HWTEST_F(DeviceManagerServiceTest, RegisterCallerAppId_001, testing::ext::TestSize.Level0) 1187{ 1188 std::string pkgName; 1189 DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName); 1190 EXPECT_NE(DeviceManagerService::GetInstance().listener_, nullptr); 1191} 1192 1193/** 1194 * @tc.name: RegisterCallerAppId_002 1195 * @tc.desc: Set pkgName null 1196 * @tc.type: FUNC 1197 */ 1198HWTEST_F(DeviceManagerServiceTest, RegisterCallerAppId_002, testing::ext::TestSize.Level0) 1199{ 1200 std::string pkgName; 1201 DeviceManagerService::GetInstance().listener_ = nullptr; 1202 DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName); 1203 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr); 1204} 1205 1206/** 1207 * @tc.name: UnRegisterDeviceManagerListener_001 1208 * @tc.desc: Set pkgName null 1209 * @tc.type: FUNC 1210 */ 1211HWTEST_F(DeviceManagerServiceTest, UnRegisterCallerAppId_001, testing::ext::TestSize.Level0) 1212{ 1213 std::string pkgName; 1214 DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName); 1215 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr); 1216} 1217 1218/** 1219 * @tc.name: UnRegisterDeviceManagerListener_002 1220 * @tc.desc: Set pkgName null 1221 * @tc.type: FUNC 1222 */ 1223HWTEST_F(DeviceManagerServiceTest, UnRegisterCallerAppId_002, testing::ext::TestSize.Level0) 1224{ 1225 std::string pkgName; 1226 DeviceManagerService::GetInstance().listener_ = nullptr; 1227 DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName); 1228 EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr); 1229} 1230 1231HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0) 1232{ 1233 std::string pkgName; 1234 uint16_t subscribeId = 1; 1235 std::string filterOptions; 1236 int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions); 1237 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1238} 1239 1240HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0) 1241{ 1242 DeletePermission(); 1243 std::string pkgName = "com.ohos.test"; 1244 uint16_t subscribeId = 1; 1245 std::string filterOptions; 1246 int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions); 1247 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1248} 1249 1250HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_006, testing::ext::TestSize.Level0) 1251{ 1252 std::string pkgName; 1253 uint16_t subscribeId = 1; 1254 std::string filterOptions = "filterOptions"; 1255 int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions); 1256 EXPECT_NE(ret, ERR_DM_FAILED); 1257} 1258 1259HWTEST_F(DeviceManagerServiceTest, BindDevice_001, testing::ext::TestSize.Level0) 1260{ 1261 std::string pkgName; 1262 int32_t authType = 1; 1263 std::string deviceId; 1264 std::string bindParam; 1265 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam); 1266 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1267} 1268 1269HWTEST_F(DeviceManagerServiceTest, BindDevice_002, testing::ext::TestSize.Level0) 1270{ 1271 std::string pkgName = "com.ohos.test"; 1272 int32_t authType = 1; 1273 std::string deviceId; 1274 std::string bindParam; 1275 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam); 1276 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1277} 1278 1279HWTEST_F(DeviceManagerServiceTest, BindDevice_003, testing::ext::TestSize.Level0) 1280{ 1281 std::string pkgName = "com.ohos.test"; 1282 int32_t authType = 1; 1283 std::string deviceId = "1234"; 1284 std::string bindParam; 1285 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam); 1286 EXPECT_EQ(ret, ERR_DM_BIND_INPUT_PARA_INVALID); 1287} 1288 1289HWTEST_F(DeviceManagerServiceTest, BindDevice_004, testing::ext::TestSize.Level0) 1290{ 1291 std::string pkgName = "com.ohos.test"; 1292 int32_t authType = 1; 1293 std::string deviceId = "1234"; 1294 std::string bindParam; 1295 DeletePermission(); 1296 int32_t ret = DeviceManagerService::GetInstance().BindDevice(pkgName, authType, deviceId, bindParam); 1297 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1298} 1299 1300HWTEST_F(DeviceManagerServiceTest, UnBindDevice_001, testing::ext::TestSize.Level0) 1301{ 1302 std::string pkgName = "com.ohos.test"; 1303 std::string deviceId = "1234"; 1304 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId); 1305 EXPECT_EQ(ret, ERR_DM_FAILED); 1306} 1307 1308HWTEST_F(DeviceManagerServiceTest, UnBindDevice_002, testing::ext::TestSize.Level0) 1309{ 1310 std::string pkgName = "com.ohos.test"; 1311 std::string deviceId; 1312 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId); 1313 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1314} 1315 1316HWTEST_F(DeviceManagerServiceTest, UnBindDevice_003, testing::ext::TestSize.Level0) 1317{ 1318 std::string pkgName; 1319 std::string deviceId = "1234"; 1320 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId); 1321 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1322} 1323 1324HWTEST_F(DeviceManagerServiceTest, UnBindDevice_004, testing::ext::TestSize.Level0) 1325{ 1326 std::string pkgName = "com.ohos.test"; 1327 std::string deviceId = "1234"; 1328 DeletePermission(); 1329 int32_t ret = DeviceManagerService::GetInstance().UnBindDevice(pkgName, deviceId); 1330 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1331} 1332 1333HWTEST_F(DeviceManagerServiceTest, OnSessionOpened_001, testing::ext::TestSize.Level0) 1334{ 1335 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1336 int sessionId = 0; 1337 int result = 0; 1338 void *data = nullptr; 1339 unsigned int dataLen = 0; 1340 int ret = DeviceManagerService::GetInstance().OnSessionOpened(sessionId, result); 1341 DeviceManagerService::GetInstance().OnBytesReceived(sessionId, data, dataLen); 1342 DeviceManagerService::GetInstance().OnSessionClosed(sessionId); 1343 EXPECT_NE(ret, ERR_DM_NOT_INIT); 1344} 1345 1346HWTEST_F(DeviceManagerServiceTest, OnPinHolderSessionOpened_001, testing::ext::TestSize.Level0) 1347{ 1348 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1349 int sessionId = 0; 1350 int result = 0; 1351 void *data = nullptr; 1352 unsigned int dataLen = 0; 1353 int ret = DeviceManagerService::GetInstance().OnPinHolderSessionOpened(sessionId, result); 1354 DeviceManagerService::GetInstance().OnPinHolderBytesReceived(sessionId, data, dataLen); 1355 DeviceManagerService::GetInstance().OnPinHolderSessionClosed(sessionId); 1356 EXPECT_NE(ret, DM_OK); 1357} 1358 1359HWTEST_F(DeviceManagerServiceTest, MineRequestCredential_001, testing::ext::TestSize.Level0) 1360{ 1361 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1362 std::string pkgName; 1363 std::string returnJsonStr; 1364 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr); 1365 EXPECT_EQ(ret, DM_OK); 1366} 1367 1368HWTEST_F(DeviceManagerServiceTest, MineRequestCredential_002, testing::ext::TestSize.Level0) 1369{ 1370 std::string pkgName; 1371 std::string returnJsonStr; 1372 DeletePermission(); 1373 int32_t ret = DeviceManagerService::GetInstance().MineRequestCredential(pkgName, returnJsonStr); 1374 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1375} 1376 1377HWTEST_F(DeviceManagerServiceTest, CheckCredential_001, testing::ext::TestSize.Level0) 1378{ 1379 std::string pkgName; 1380 std::string returnJsonStr; 1381 std::string reqJsonStr; 1382 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1383 EXPECT_NE(ret, DM_OK); 1384} 1385 1386HWTEST_F(DeviceManagerServiceTest, CheckCredential_002, testing::ext::TestSize.Level0) 1387{ 1388 DeletePermission(); 1389 std::string pkgName; 1390 std::string returnJsonStr; 1391 std::string reqJsonStr; 1392 int32_t ret = DeviceManagerService::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1393 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1394} 1395 1396HWTEST_F(DeviceManagerServiceTest, ImportCredential_004, testing::ext::TestSize.Level0) 1397{ 1398 DeletePermission(); 1399 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1400 std::string pkgName; 1401 std::string returnJsonStr; 1402 std::string reqJsonStr; 1403 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1404 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1405} 1406 1407HWTEST_F(DeviceManagerServiceTest, ImportCredential_005, testing::ext::TestSize.Level0) 1408{ 1409 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1410 std::string pkgName; 1411 std::string returnJsonStr; 1412 std::string reqJsonStr; 1413 int32_t ret = DeviceManagerService::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1414 EXPECT_NE(ret, DM_OK); 1415} 1416 1417HWTEST_F(DeviceManagerServiceTest, DeleteCredential_004, testing::ext::TestSize.Level0) 1418{ 1419 DeletePermission(); 1420 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1421 std::string pkgName; 1422 std::string returnJsonStr; 1423 std::string reqJsonStr; 1424 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1425 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1426} 1427 1428HWTEST_F(DeviceManagerServiceTest, DeleteCredential_005, testing::ext::TestSize.Level0) 1429{ 1430 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1431 std::string pkgName; 1432 std::string returnJsonStr; 1433 std::string reqJsonStr; 1434 int32_t ret = DeviceManagerService::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1435 EXPECT_NE(ret, DM_OK); 1436} 1437 1438HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level0) 1439{ 1440 std::string pkgName; 1441 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName); 1442 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1443} 1444 1445HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level0) 1446{ 1447 std::string pkgName = "pkgName"; 1448 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName); 1449 EXPECT_EQ(ret, DM_OK); 1450} 1451 1452HWTEST_F(DeviceManagerServiceTest, RegisterUiStateCallback_003, testing::ext::TestSize.Level0) 1453{ 1454 std::string pkgName = "pkgName"; 1455 DeletePermission(); 1456 int32_t ret = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName); 1457 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1458} 1459 1460HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level0) 1461{ 1462 std::string pkgName; 1463 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName); 1464 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1465} 1466 1467HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level0) 1468{ 1469 std::string pkgName = "pkgName"; 1470 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName); 1471 EXPECT_EQ(ret, DM_OK); 1472} 1473 1474HWTEST_F(DeviceManagerServiceTest, UnRegisterUiStateCallback_003, testing::ext::TestSize.Level0) 1475{ 1476 std::string pkgName = "pkgName"; 1477 DeletePermission(); 1478 int32_t ret = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName); 1479 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1480} 1481 1482 1483HWTEST_F(DeviceManagerServiceTest, IsDMImplSoLoaded_001, testing::ext::TestSize.Level0) 1484{ 1485 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1486 bool ret = DeviceManagerService::GetInstance().IsDMImplSoLoaded(); 1487 EXPECT_FALSE(ret); 1488} 1489 1490HWTEST_F(DeviceManagerServiceTest, DmHiDumper_001, testing::ext::TestSize.Level0) 1491{ 1492 std::vector<std::string> args; 1493 std::string result; 1494 int32_t ret = DeviceManagerService::GetInstance().DmHiDumper(args, result); 1495 EXPECT_EQ(ret, DM_OK); 1496} 1497 1498HWTEST_F(DeviceManagerServiceTest, NotifyEvent_001, testing::ext::TestSize.Level0) 1499{ 1500 std::string pkgName; 1501 int32_t eventId = 0; 1502 std::string event; 1503 std::string msg = ""; 1504 DeviceManagerService::GetInstance().HandleDeviceNotTrust(msg); 1505 msg = R"( 1506 { 1507 "authType" : 1, 1508 "userId" : "123", 1509 "credentialData" : "cryptosupportData", 1510 "CRYPTOSUPPORT" : "cryptosupportTest", 1511 "credentialType" : 1, 1512 "credentialId" : "104", 1513 "NETWORK_ID" : "108", 1514 "authCode" : "1234567812345678123456781234567812345678123456781234567812345678", 1515 "serverPk" : "hello", 1516 "pkInfoSignature" : "world", 1517 "pkInfo" : "pkginfo", 1518 "peerDeviceId" : "3515656546" 1519 })"; 1520 DeviceManagerService::GetInstance().HandleDeviceNotTrust(msg); 1521 std::string commonEventType = "helloworld"; 1522 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1523 DeviceManagerService::GetInstance().ScreenCommonEventCallback(commonEventType); 1524 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event); 1525 EXPECT_NE(ret, DM_OK); 1526} 1527 1528HWTEST_F(DeviceManagerServiceTest, NotifyEvent_002, testing::ext::TestSize.Level0) 1529{ 1530 DeletePermission(); 1531 std::string pkgName; 1532 int32_t eventId = 0; 1533 std::string event; 1534 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event); 1535 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1536} 1537 1538HWTEST_F(DeviceManagerServiceTest, NotifyEvent_003, testing::ext::TestSize.Level0) 1539{ 1540 std::string pkgName; 1541 int32_t eventId = DM_NOTIFY_EVENT_ON_PINHOLDER_EVENT; 1542 std::string event; 1543 DeviceManagerService::GetInstance().InitDMServiceListener(); 1544 int32_t ret = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event); 1545 EXPECT_EQ(ret, ERR_DM_FAILED); 1546 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1547} 1548 1549HWTEST_F(DeviceManagerServiceTest, LoadHardwareFwkService_001, testing::ext::TestSize.Level0) 1550{ 1551 DeviceManagerService::GetInstance().LoadHardwareFwkService(); 1552 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 1553} 1554 1555HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_001, testing::ext::TestSize.Level0) 1556{ 1557 std::string pkgName; 1558 std::string networkId; 1559 std::string uuid; 1560 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid); 1561 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1562} 1563 1564HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_002, testing::ext::TestSize.Level0) 1565{ 1566 std::string pkgName = "pkgName"; 1567 std::string networkId; 1568 std::string uuid; 1569 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid); 1570 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 1571} 1572 1573HWTEST_F(DeviceManagerServiceTest, GetEncryptedUuidByNetworkId_003, testing::ext::TestSize.Level0) 1574{ 1575 std::string pkgName = "pkgName"; 1576 std::string networkId = "network_id"; 1577 std::string uuid = "13345689"; 1578 if (DeviceManagerService::GetInstance().softbusListener_ == nullptr) { 1579 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 1580 } 1581 int32_t ret = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid); 1582 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 1583 EXPECT_NE(ret, DM_OK); 1584} 1585 1586HWTEST_F(DeviceManagerServiceTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0) 1587{ 1588 std::string pkgName; 1589 std::string uuid; 1590 std::string appId; 1591 std::string encryptedUuid; 1592 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1593 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1594} 1595 1596HWTEST_F(DeviceManagerServiceTest, GenerateEncryptedUuid_002, testing::ext::TestSize.Level0) 1597{ 1598 std::string pkgName = "pkgName"; 1599 std::string uuid; 1600 std::string appId; 1601 std::string encryptedUuid; 1602 int32_t ret = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1603 EXPECT_EQ(ret, DM_OK); 1604} 1605 1606HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_002, testing::ext::TestSize.Level0) 1607{ 1608 DeletePermission(); 1609 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(0); 1610 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1611} 1612 1613HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_003, testing::ext::TestSize.Level0) 1614{ 1615 DeletePermission(); 1616 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(1); 1617 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1618} 1619 1620HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_004, testing::ext::TestSize.Level0) 1621{ 1622 DeletePermission(); 1623 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(2); 1624 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1625} 1626 1627HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_005, testing::ext::TestSize.Level0) 1628{ 1629 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(1); 1630 EXPECT_EQ(ret, DM_OK); 1631} 1632 1633HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_006, testing::ext::TestSize.Level0) 1634{ 1635 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(2); 1636 EXPECT_NE(ret, ERR_DM_FAILED); 1637} 1638 1639HWTEST_F(DeviceManagerServiceTest, CheckApiPermission_007, testing::ext::TestSize.Level0) 1640{ 1641 int32_t ret = DeviceManagerService::GetInstance().CheckApiPermission(3); 1642 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1643} 1644 1645HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0) 1646{ 1647 DeletePermission(); 1648 std::string pkgName; 1649 std::string netWorkId; 1650 int32_t networkType = 0; 1651 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType); 1652 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1653} 1654 1655HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_002, testing::ext::TestSize.Level0) 1656{ 1657 std::string pkgName; 1658 std::string netWorkId; 1659 int32_t networkType = 0; 1660 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType); 1661 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1662} 1663 1664HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_003, testing::ext::TestSize.Level0) 1665{ 1666 std::string pkgName = "pkgName"; 1667 std::string netWorkId = "netWorkId"; 1668 int32_t networkType = 0; 1669 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType); 1670 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 1671} 1672 1673HWTEST_F(DeviceManagerServiceTest, GetNetworkTypeByNetworkId_004, testing::ext::TestSize.Level0) 1674{ 1675 std::string pkgName = "pkgName"; 1676 std::string netWorkId = "netWorkId"; 1677 int32_t networkType = 0; 1678 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 1679 int32_t ret = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType); 1680 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 1681 EXPECT_NE(ret, DM_OK); 1682} 1683 1684HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_001, testing::ext::TestSize.Level0) 1685{ 1686 DeletePermission(); 1687 std::string pkgName; 1688 std::string authCode; 1689 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); 1690 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1691} 1692 1693HWTEST_F(DeviceManagerServiceTest, ImportAuthCode_002, testing::ext::TestSize.Level0) 1694{ 1695 std::string pkgName = "pkgName"; 1696 std::string authCode = "authCode"; 1697 int32_t ret = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode); 1698 EXPECT_NE(ret, DM_OK); 1699} 1700 1701HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_001, testing::ext::TestSize.Level0) 1702{ 1703 DeletePermission(); 1704 std::string authCode; 1705 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode); 1706 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1707} 1708 1709HWTEST_F(DeviceManagerServiceTest, ExportAuthCode_002, testing::ext::TestSize.Level0) 1710{ 1711 std::string authCode = "authCode"; 1712 int32_t ret = DeviceManagerService::GetInstance().ExportAuthCode(authCode); 1713 EXPECT_NE(ret, DM_OK); 1714} 1715 1716HWTEST_F(DeviceManagerServiceTest, UnloadDMServiceImplSo_001, testing::ext::TestSize.Level0) 1717{ 1718 DeviceManagerService::GetInstance().UnloadDMServiceImplSo(); 1719 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 1720} 1721 1722HWTEST_F(DeviceManagerServiceTest, IsDMServiceAdapterLoad_001, testing::ext::TestSize.Level0) 1723{ 1724 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 1725 DeviceManagerService::GetInstance().IsDMServiceAdapterLoad(); 1726 bool ret = DeviceManagerService::GetInstance().IsDMServiceImplReady(); 1727 EXPECT_EQ(ret, true); 1728} 1729 1730HWTEST_F(DeviceManagerServiceTest, UnloadDMServiceAdapter_001, testing::ext::TestSize.Level0) 1731{ 1732 DeviceManagerService::GetInstance().UnloadDMServiceAdapter(); 1733 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 1734} 1735 1736HWTEST_F(DeviceManagerServiceTest, UnloadDMServiceAdapter_002, testing::ext::TestSize.Level0) 1737{ 1738 DeviceManagerService::GetInstance().dmServiceImplExt_ = nullptr; 1739 DeviceManagerService::GetInstance().UnloadDMServiceAdapter(); 1740 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 1741} 1742 1743HWTEST_F(DeviceManagerServiceTest, StartDiscovering_001, testing::ext::TestSize.Level0) 1744{ 1745 DeletePermission(); 1746 std::string pkgName; 1747 std::map<std::string, std::string> discoverParam; 1748 std::map<std::string, std::string> filterOptions; 1749 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); 1750 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1751} 1752 1753HWTEST_F(DeviceManagerServiceTest, StartDiscovering_002, testing::ext::TestSize.Level0) 1754{ 1755 std::string pkgName; 1756 std::map<std::string, std::string> discoverParam; 1757 std::map<std::string, std::string> filterOptions; 1758 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); 1759 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1760} 1761 1762HWTEST_F(DeviceManagerServiceTest, StartDiscovering_003, testing::ext::TestSize.Level0) 1763{ 1764 std::string pkgName = "pkgName"; 1765 std::map<std::string, std::string> discoverParam; 1766 std::map<std::string, std::string> filterOptions; 1767 DeviceManagerService::GetInstance().InitDMServiceListener(); 1768 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); 1769 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL); 1770 DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); 1771 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1772} 1773 1774HWTEST_F(DeviceManagerServiceTest, StartDiscovering_004, testing::ext::TestSize.Level0) 1775{ 1776 std::string pkgName = "pkgName"; 1777 std::map<std::string, std::string> discoverParam; 1778 discoverParam[PARAM_KEY_META_TYPE] = "metaType"; 1779 discoverParam[PARAM_KEY_SUBSCRIBE_ID] = "123456"; 1780 discoverParam[PARAM_KEY_DISC_MEDIUM] = 1781 std::to_string(static_cast<int32_t>(DmExchangeMedium::DM_AUTO)); 1782 discoverParam[PARAM_KEY_DISC_FREQ] = 1783 std::to_string(static_cast<int32_t>(DmExchangeFreq::DM_LOW)); 1784 std::map<std::string, std::string> filterOptions; 1785 DeviceManagerService::GetInstance().InitDMServiceListener(); 1786 int32_t ret = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions); 1787 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == DM_OK || ret == SOFTBUS_DISCOVER_MANAGER_INNERFUNCTION_FAIL); 1788 DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); 1789 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1790} 1791 1792HWTEST_F(DeviceManagerServiceTest, StopDiscovering_001, testing::ext::TestSize.Level0) 1793{ 1794 DeletePermission(); 1795 std::string pkgName; 1796 std::map<std::string, std::string> discoverParam; 1797 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); 1798 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1799} 1800 1801HWTEST_F(DeviceManagerServiceTest, StopDiscovering_002, testing::ext::TestSize.Level0) 1802{ 1803 std::string pkgName; 1804 std::map<std::string, std::string> discoverParam; 1805 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); 1806 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1807} 1808 1809HWTEST_F(DeviceManagerServiceTest, StopDiscovering_003, testing::ext::TestSize.Level0) 1810{ 1811 std::string pkgName = "pkgName"; 1812 std::map<std::string, std::string> discoverParam; 1813 DeviceManagerService::GetInstance().InitDMServiceListener(); 1814 int32_t ret = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam); 1815 EXPECT_NE(ret, DM_OK); 1816 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1817} 1818 1819HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_001, testing::ext::TestSize.Level0) 1820{ 1821 DeletePermission(); 1822 std::string pkgName; 1823 std::map<std::string, std::string> discoverParam; 1824 std::map<std::string, std::string> filterOptions; 1825 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions); 1826 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1827} 1828 1829HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_002, testing::ext::TestSize.Level0) 1830{ 1831 std::string pkgName; 1832 std::map<std::string, std::string> discoverParam; 1833 std::map<std::string, std::string> filterOptions; 1834 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions); 1835 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1836} 1837 1838HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_003, testing::ext::TestSize.Level0) 1839{ 1840 std::string pkgName = "pkgName"; 1841 std::map<std::string, std::string> discoverParam; 1842 std::map<std::string, std::string> filterOptions; 1843 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions); 1844 EXPECT_NE(ret, DM_OK); 1845} 1846 1847HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_004, testing::ext::TestSize.Level0) 1848{ 1849 std::string pkgName = "pkgName"; 1850 std::map<std::string, std::string> discoverParam; 1851 std::map<std::string, std::string> filterOptions; 1852 DeviceManagerService::GetInstance().InitDMServiceListener(); 1853 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions); 1854 EXPECT_NE(ret, DM_OK); 1855 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1856} 1857 1858HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_001, testing::ext::TestSize.Level0) 1859{ 1860 DeletePermission(); 1861 std::string pkgName; 1862 std::map<std::string, std::string> extraParam; 1863 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); 1864 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1865} 1866 1867HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_002, testing::ext::TestSize.Level0) 1868{ 1869 std::string pkgName; 1870 std::map<std::string, std::string> extraParam; 1871 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); 1872 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1873} 1874 1875HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_003, testing::ext::TestSize.Level0) 1876{ 1877 std::string pkgName = "pkgName"; 1878 std::map<std::string, std::string> extraParam; 1879 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); 1880 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 1881} 1882 1883HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_004, testing::ext::TestSize.Level0) 1884{ 1885 std::string pkgName = "pkgName"; 1886 std::map<std::string, std::string> extraParam; 1887 DeviceManagerService::GetInstance().InitDMServiceListener(); 1888 int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); 1889 EXPECT_EQ(ret, SOFTBUS_ERR); 1890 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1891} 1892 1893HWTEST_F(DeviceManagerServiceTest, StartAdvertising_001, testing::ext::TestSize.Level0) 1894{ 1895 DeletePermission(); 1896 std::string pkgName; 1897 std::map<std::string, std::string> advertiseParam; 1898 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam); 1899 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1900} 1901 1902HWTEST_F(DeviceManagerServiceTest, StartAdvertising_002, testing::ext::TestSize.Level0) 1903{ 1904 std::string pkgName; 1905 std::map<std::string, std::string> advertiseParam; 1906 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam); 1907 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1908} 1909 1910HWTEST_F(DeviceManagerServiceTest, StartAdvertising_003, testing::ext::TestSize.Level0) 1911{ 1912 std::string pkgName = "com.ohos.test"; 1913 std::map<std::string, std::string> advertiseParam; 1914 advertiseParam[PARAM_KEY_META_TYPE] = "metaType"; 1915 advertiseParam[PARAM_KEY_PUBLISH_ID] = "123456"; 1916 advertiseParam[PARAM_KEY_DISC_MODE] = 1917 std::to_string(static_cast<int32_t>(DmDiscoverMode::DM_DISCOVER_MODE_PASSIVE)); 1918 DeviceManagerService::GetInstance().InitDMServiceListener(); 1919 int32_t ret = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam); 1920 EXPECT_NE(ret, ERR_DM_FAILED); 1921 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1922} 1923 1924HWTEST_F(DeviceManagerServiceTest, StopAdvertising_001, testing::ext::TestSize.Level0) 1925{ 1926 DeletePermission(); 1927 std::string pkgName; 1928 std::map<std::string, std::string> advertiseParam; 1929 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); 1930 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1931} 1932 1933HWTEST_F(DeviceManagerServiceTest, StopAdvertising_002, testing::ext::TestSize.Level0) 1934{ 1935 std::string pkgName; 1936 std::map<std::string, std::string> advertiseParam; 1937 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); 1938 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1939} 1940 1941HWTEST_F(DeviceManagerServiceTest, StopAdvertising_003, testing::ext::TestSize.Level0) 1942{ 1943 std::string pkgName = "pkgName"; 1944 std::map<std::string, std::string> advertiseParam; 1945 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); 1946 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 1947} 1948 1949HWTEST_F(DeviceManagerServiceTest, StopAdvertising_004, testing::ext::TestSize.Level0) 1950{ 1951 std::string pkgName = "StopAdvertising_004"; 1952 std::map<std::string, std::string> advertiseParam; 1953 DeviceManagerService::GetInstance().InitDMServiceListener(); 1954 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); 1955 EXPECT_TRUE(ret == SOFTBUS_IPC_ERR || ret == SOFTBUS_ERR); 1956 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1957} 1958 1959HWTEST_F(DeviceManagerServiceTest, StopAdvertising_005, testing::ext::TestSize.Level0) 1960{ 1961 std::string pkgName = "StopAdvertising_005"; 1962 std::map<std::string, std::string> advertiseParam; 1963 std::string key = PARAM_KEY_META_TYPE; 1964 std::string value = "125"; 1965 advertiseParam.insert(std::make_pair(key, value)); 1966 DeviceManagerService::GetInstance().InitDMServiceListener(); 1967 int32_t ret = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam); 1968 EXPECT_NE(ret, DM_OK); 1969 DeviceManagerService::GetInstance().UninitDMServiceListener(); 1970} 1971 1972HWTEST_F(DeviceManagerServiceTest, BindTarget_004, testing::ext::TestSize.Level0) 1973{ 1974 DeletePermission(); 1975 std::string pkgName; 1976 PeerTargetId targetId; 1977 std::map<std::string, std::string> bindParam; 1978 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam); 1979 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 1980} 1981 1982HWTEST_F(DeviceManagerServiceTest, BindTarget_005, testing::ext::TestSize.Level0) 1983{ 1984 std::string pkgName; 1985 PeerTargetId targetId; 1986 std::map<std::string, std::string> bindParam; 1987 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam); 1988 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1989} 1990 1991HWTEST_F(DeviceManagerServiceTest, BindTarget_006, testing::ext::TestSize.Level0) 1992{ 1993 std::string pkgName = "pkgName"; 1994 PeerTargetId targetId; 1995 std::map<std::string, std::string> bindParam; 1996 int32_t ret = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam); 1997 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1998} 1999 2000HWTEST_F(DeviceManagerServiceTest, UnbindTarget_004, testing::ext::TestSize.Level0) 2001{ 2002 DeletePermission(); 2003 std::string pkgName; 2004 PeerTargetId targetId; 2005 std::map<std::string, std::string> unbindParam; 2006 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam); 2007 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2008} 2009 2010HWTEST_F(DeviceManagerServiceTest, UnbindTarget_005, testing::ext::TestSize.Level0) 2011{ 2012 std::string pkgName; 2013 PeerTargetId targetId; 2014 std::map<std::string, std::string> unbindParam; 2015 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam); 2016 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2017} 2018 2019HWTEST_F(DeviceManagerServiceTest, UnbindTarget_006, testing::ext::TestSize.Level0) 2020{ 2021 std::string pkgName = "pkgName"; 2022 PeerTargetId targetId; 2023 std::map<std::string, std::string> unbindParam; 2024 int32_t ret = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam); 2025 EXPECT_NE(ret, DM_OK); 2026} 2027 2028HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0) 2029{ 2030 DeletePermission(); 2031 std::string pkgName; 2032 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName); 2033 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2034} 2035 2036HWTEST_F(DeviceManagerServiceTest, RegisterPinHolderCallback_002, testing::ext::TestSize.Level0) 2037{ 2038 std::string pkgName = "pkgName"; 2039 int32_t ret = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName); 2040 EXPECT_NE(ret, DM_OK); 2041} 2042 2043HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_001, testing::ext::TestSize.Level0) 2044{ 2045 DeletePermission(); 2046 std::string pkgName; 2047 PeerTargetId targetId; 2048 DmPinType pinType = DmPinType::QR_CODE; 2049 std::string payload; 2050 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2051 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2052} 2053 2054HWTEST_F(DeviceManagerServiceTest, CreatePinHolder_002, testing::ext::TestSize.Level0) 2055{ 2056 std::string pkgName = "pkgName"; 2057 PeerTargetId targetId; 2058 DmPinType pinType = DmPinType::QR_CODE; 2059 std::string payload; 2060 int32_t ret = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2061 EXPECT_NE(ret, DM_OK); 2062} 2063 2064HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_001, testing::ext::TestSize.Level0) 2065{ 2066 DeletePermission(); 2067 std::string pkgName; 2068 PeerTargetId targetId; 2069 DmPinType pinType = DmPinType::QR_CODE; 2070 std::string payload; 2071 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2072 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2073} 2074 2075HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_002, testing::ext::TestSize.Level0) 2076{ 2077 std::string pkgName = "pkgName"; 2078 PeerTargetId targetId; 2079 DmPinType pinType = DmPinType::QR_CODE; 2080 std::string payload; 2081 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2082 EXPECT_NE(ret, DM_OK); 2083} 2084 2085 2086HWTEST_F(DeviceManagerServiceTest, DpAclAdd_001, testing::ext::TestSize.Level0) 2087{ 2088 DeletePermission(); 2089 std::string udid; 2090 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid); 2091 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2092} 2093 2094HWTEST_F(DeviceManagerServiceTest, DpAclAdd_002, testing::ext::TestSize.Level0) 2095{ 2096 std::string udid = "udid"; 2097 int32_t ret = DeviceManagerService::GetInstance().DpAclAdd(udid); 2098 EXPECT_EQ(ret, DM_OK); 2099} 2100 2101HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0) 2102{ 2103 std::string pkgName; 2104 std::string networkId; 2105 int32_t securityLevel = -1; 2106 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, networkId, securityLevel); 2107 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2108} 2109 2110HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_002, testing::ext::TestSize.Level0) 2111{ 2112 std::string pkgName = "com.ohos.test"; 2113 std::string invalidNetworkId = "12345"; 2114 int32_t securityLevel = -1; 2115 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel); 2116 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 2117} 2118 2119HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_003, testing::ext::TestSize.Level0) 2120{ 2121 std::string pkgName = "com.ohos.test"; 2122 std::string invalidNetworkId = "12345"; 2123 int32_t securityLevel = -1; 2124 DeletePermission(); 2125 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel); 2126 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2127} 2128 2129HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_004, testing::ext::TestSize.Level0) 2130{ 2131 std::string pkgName = "com.ohos.test"; 2132 std::string invalidNetworkId; 2133 int32_t securityLevel = -1; 2134 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel); 2135 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2136} 2137 2138HWTEST_F(DeviceManagerServiceTest, GetDeviceSecurityLevel_005, testing::ext::TestSize.Level0) 2139{ 2140 std::string pkgName = "com.ohos.test"; 2141 std::string invalidNetworkId; 2142 int32_t securityLevel = 0; 2143 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2144 int32_t ret = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, invalidNetworkId, securityLevel); 2145 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2146 EXPECT_NE(ret, DM_OK); 2147} 2148 2149HWTEST_F(DeviceManagerServiceTest, IsSameAccount_001, testing::ext::TestSize.Level0) 2150{ 2151 std::string udid = ""; 2152 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid); 2153 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2154} 2155 2156HWTEST_F(DeviceManagerServiceTest, IsSameAccount_002, testing::ext::TestSize.Level0) 2157{ 2158 std::string udid = "udidTest"; 2159 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid); 2160 EXPECT_NE(ret, DM_OK); 2161} 2162 2163HWTEST_F(DeviceManagerServiceTest, IsSameAccount_003, testing::ext::TestSize.Level0) 2164{ 2165 std::string udid = "udidTest"; 2166 DeletePermission(); 2167 int32_t ret = DeviceManagerService::GetInstance().IsSameAccount(udid); 2168 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2169} 2170 2171HWTEST_F(DeviceManagerServiceTest, HandleDeviceStatusChange_001, testing::ext::TestSize.Level0) 2172{ 2173 DmDeviceState devState = DmDeviceState::DEVICE_INFO_READY; 2174 DmDeviceInfo devInfo; 2175 DeviceManagerService::GetInstance().HandleDeviceStatusChange(devState, devInfo); 2176 EXPECT_EQ(DeviceManagerService::GetInstance().softbusListener_, nullptr); 2177} 2178 2179HWTEST_F(DeviceManagerServiceTest, CheckIsSameAccount_001, testing::ext::TestSize.Level0) 2180{ 2181 DmAccessCaller caller; 2182 DmAccessCallee callee; 2183 DeletePermission(); 2184 int ret = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee); 2185 EXPECT_FALSE(ret); 2186} 2187 2188 2189HWTEST_F(DeviceManagerServiceTest, CheckAccessControl_001, testing::ext::TestSize.Level0) 2190{ 2191 DmAccessCaller caller; 2192 DmAccessCallee callee; 2193 DeletePermission(); 2194 int ret = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee); 2195 EXPECT_FALSE(ret); 2196} 2197 2198HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_001, testing::ext::TestSize.Level0) 2199{ 2200 std::string pkgName; 2201 std::map<std::string, std::string> policy; 2202 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy); 2203 EXPECT_NE(ret, DM_OK); 2204} 2205 2206HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_002, testing::ext::TestSize.Level0) 2207{ 2208 std::string pkgName = "openharmony123"; 2209 std::map<std::string, std::string> policy; 2210 DeletePermission(); 2211 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy); 2212 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2213} 2214 2215HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_003, testing::ext::TestSize.Level0) 2216{ 2217 std::string pkgName = "openharmony123"; 2218 std::map<std::string, std::string> policy; 2219 std::vector<std::string> peerUdids; 2220 int32_t userId = 1; 2221 uint64_t tokenId = 87; 2222 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, DEVICE); 2223 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, APP); 2224 DeviceManagerService::GetInstance().SendUnBindBroadCast(peerUdids, userId, tokenId, 2); 2225 DeviceManagerService::GetInstance().SendDeviceUnBindBroadCast(peerUdids, userId); 2226 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2227 DeviceManagerService::GetInstance().SendDeviceUnBindBroadCast(peerUdids, userId); 2228 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2229 int ret = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy); 2230 EXPECT_NE(ret, DM_OK); 2231} 2232 2233/** 2234 * @tc.name: StartDeviceDiscovery_007 2235 * @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return 2236 * ERR_DM_DISCOVERY_REPEATED 2237 * @tc.type: FUNC 2238 * @tc.require: AR000GHSJK 2239 */ 2240HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_007, testing::ext::TestSize.Level0) 2241{ 2242 std::string pkgName = "com.ohos.test7"; 2243 uint16_t subscribeId = 1; 2244 std::string extra = "test"; 2245 DeviceManagerService::GetInstance().InitDMServiceListener(); 2246 int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, extra); 2247 EXPECT_NE(ret, DM_OK); 2248 DeviceManagerService::GetInstance().UninitDMServiceListener(); 2249} 2250 2251HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_003, testing::ext::TestSize.Level0) 2252{ 2253 std::string pkgName = ""; 2254 PeerTargetId targetId; 2255 DmPinType pinType = DmPinType::QR_CODE; 2256 std::string payload; 2257 int32_t ret = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2258 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2259} 2260 2261HWTEST_F(DeviceManagerServiceTest, SendAppUnBindBroadCast_001, testing::ext::TestSize.Level0) 2262{ 2263 std::vector<std::string> peerUdids; 2264 int32_t userId = 12; 2265 uint64_t tokenId = 23; 2266 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2267 DeviceManagerService::GetInstance().SendAppUnBindBroadCast(peerUdids, userId, tokenId); 2268 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); 2269 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2270} 2271 2272HWTEST_F(DeviceManagerServiceTest, SendServiceUnBindBroadCast_001, testing::ext::TestSize.Level0) 2273{ 2274 std::vector<std::string> peerUdids; 2275 int32_t userId = 12; 2276 uint64_t tokenId = 23; 2277 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2278 DeviceManagerService::GetInstance().SendServiceUnBindBroadCast(peerUdids, userId, tokenId); 2279 EXPECT_NE(DeviceManagerService::GetInstance().softbusListener_, nullptr); 2280 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2281} 2282 2283HWTEST_F(DeviceManagerServiceTest, ClearDiscoveryCache_001, testing::ext::TestSize.Level0) 2284{ 2285 std::string pkgName = "pkgName001"; 2286 DeviceManagerService::GetInstance().InitDMServiceListener(); 2287 DeviceManagerService::GetInstance().ClearDiscoveryCache(pkgName); 2288 EXPECT_NE(DeviceManagerService::GetInstance().discoveryMgr_, nullptr); 2289 DeviceManagerService::GetInstance().UninitDMServiceListener(); 2290} 2291 2292HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_001, testing::ext::TestSize.Level0) 2293{ 2294 std::string pkgName; 2295 std::string networkId; 2296 int32_t screenStatus = 1; 2297 DeletePermission(); 2298 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2299 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2300} 2301 2302HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_002, testing::ext::TestSize.Level0) 2303{ 2304 std::string pkgName; 2305 std::string networkId; 2306 int32_t screenStatus = 1; 2307 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2308 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2309} 2310 2311HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_003, testing::ext::TestSize.Level0) 2312{ 2313 std::string pkgName = "pkgname"; 2314 std::string networkId = "networkId_003"; 2315 int32_t screenStatus = 1; 2316 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2317 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2318 EXPECT_NE(ret, DM_OK); 2319 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2320} 2321 2322HWTEST_F(DeviceManagerServiceTest, GetDeviceScreenStatus_004, testing::ext::TestSize.Level0) 2323{ 2324 std::string pkgName = "pkgname"; 2325 std::string networkId = "networkId_003"; 2326 int32_t screenStatus = 1; 2327 int ret = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2328 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 2329} 2330 2331HWTEST_F(DeviceManagerServiceTest, HandleDeviceScreenStatusChange_001, testing::ext::TestSize.Level0) 2332{ 2333 DmDeviceInfo deviceInfo; 2334 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 2335 DeviceManagerService::GetInstance().IsDMServiceImplReady(); 2336 DeviceManagerService::GetInstance().HandleDeviceScreenStatusChange(deviceInfo); 2337 EXPECT_NE(DeviceManagerService::GetInstance().dmServiceImpl_, nullptr); 2338} 2339 2340HWTEST_F(DeviceManagerServiceTest, EnableDiscoveryListener_005, testing::ext::TestSize.Level0) 2341{ 2342 std::string pkgName = "pkgName"; 2343 std::map<std::string, std::string> discoverParam; 2344 std::map<std::string, std::string> filterOptions; 2345 int32_t ret = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions); 2346 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 2347} 2348 2349HWTEST_F(DeviceManagerServiceTest, GetDeviceInfo_003, testing::ext::TestSize.Level0) 2350{ 2351 std::string networkId = "networkIdTest3"; 2352 DmDeviceInfo info; 2353 DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>(); 2354 int32_t ret = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, info); 2355 EXPECT_EQ(ret, DM_OK); 2356 DeviceManagerService::GetInstance().softbusListener_ = nullptr; 2357} 2358 2359HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0) 2360{ 2361 DmDeviceInfo info; 2362 DeletePermission(); 2363 std::string msg = ""; 2364 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg); 2365 DeviceManagerService::GetInstance().isImplsoLoaded_ = false; 2366 bool result = DeviceManagerService::GetInstance().IsDMServiceImplReady(); 2367 EXPECT_TRUE(result); 2368 msg = R"( 2369 { 2370 "type" : 0, 2371 "userId" : 123, 2372 "accountId" : "28776", 2373 "tokenId" : 16, 2374 "peerUdid" : "104", 2375 "accountName" : "account_xiao" 2376 })"; 2377 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg); 2378 msg = R"( 2379 { 2380 "type" : 1, 2381 "userId" : 128, 2382 "accountId" : "28778", 2383 "tokenId" : 17, 2384 "peerUdid" : "108", 2385 "accountName" : "account_li" 2386 })"; 2387 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg); 2388 msg = R"( 2389 { 2390 "type" : 2, 2391 "userId" : 124, 2392 "accountId" : "28779", 2393 "tokenId" : 18, 2394 "peerUdid" : "110", 2395 "accountName" : "account_wang" 2396 })"; 2397 DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg); 2398 int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info); 2399 EXPECT_EQ(ret, ERR_DM_POINT_NULL); 2400} 2401 2402HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_001, testing::ext::TestSize.Level0) 2403{ 2404 std::string pkgName; 2405 std::string udid; 2406 std::string networkId = "networkIdTest_001"; 2407 DeletePermission(); 2408 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId); 2409 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2410} 2411 2412HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_002, testing::ext::TestSize.Level0) 2413{ 2414 std::string pkgName; 2415 std::string udid; 2416 std::string networkId = "networkIdTest_002"; 2417 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId); 2418 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2419} 2420 2421HWTEST_F(DeviceManagerServiceTest, GetNetworkIdByUdid_003, testing::ext::TestSize.Level0) 2422{ 2423 std::string pkgName = "pkgName_003"; 2424 std::string udid = "sewdwed98897"; 2425 std::string networkId = "networkIdTest_003"; 2426 int32_t ret = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId); 2427 EXPECT_EQ(ret, ERR_DM_FAILED); 2428} 2429 2430HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_001, testing::ext::TestSize.Level0) 2431{ 2432 std::string pkgName; 2433 DeletePermission(); 2434 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName); 2435 EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); 2436} 2437 2438HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_002, testing::ext::TestSize.Level0) 2439{ 2440 std::string pkgName; 2441 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName); 2442 EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2443} 2444 2445HWTEST_F(DeviceManagerServiceTest, StopAuthenticateDevice_003, testing::ext::TestSize.Level0) 2446{ 2447 std::string pkgName = "pkgName_003"; 2448 int32_t ret = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName); 2449 EXPECT_EQ(ret, DM_OK); 2450} 2451} // namespace 2452} // namespace DistributedHardware 2453} // namespace OHOS 2454