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_impl.h" 17#include "dm_device_info.h" 18 19#include <unistd.h> 20#include "accesstoken_kit.h" 21#include "device_manager_notify.h" 22#include "dm_constants.h" 23#include "dm_log.h" 24#include "ipc_authenticate_device_req.h" 25#include "ipc_get_info_by_network_req.h" 26#include "ipc_get_info_by_network_rsp.h" 27#include "ipc_get_local_device_info_rsp.h" 28#include "ipc_get_trustdevice_req.h" 29#include "ipc_get_trustdevice_rsp.h" 30#include "ipc_req.h" 31#include "ipc_rsp.h" 32#include "ipc_set_useroperation_req.h" 33#include "ipc_skeleton.h" 34#include "ipc_start_discovery_req.h" 35#include "ipc_stop_discovery_req.h" 36#include "ipc_publish_req.h" 37#include "ipc_unpublish_req.h" 38#include "ipc_unauthenticate_device_req.h" 39#include "nativetoken_kit.h" 40#include "securec.h" 41#include "token_setproc.h" 42#include "softbus_error_code.h" 43 44namespace OHOS { 45namespace DistributedHardware { 46void DeviceManagerImplTest::SetUp() 47{ 48 const int32_t permsNum = 2; 49 const int32_t indexZero = 0; 50 const int32_t indexOne = 1; 51 uint64_t tokenId; 52 const char *perms[permsNum]; 53 perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM"; 54 perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC"; 55 NativeTokenInfoParams infoInstance = { 56 .dcapsNum = 0, 57 .permsNum = permsNum, 58 .aclsNum = 0, 59 .dcaps = NULL, 60 .perms = perms, 61 .acls = NULL, 62 .processName = "dsoftbus_service", 63 .aplStr = "system_core", 64 }; 65 tokenId = GetAccessTokenId(&infoInstance); 66 SetSelfTokenID(tokenId); 67 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); 68} 69 70void DeviceManagerImplTest::TearDown() 71{ 72} 73 74void DeviceManagerImplTest::SetUpTestCase() 75{ 76} 77 78void DeviceManagerImplTest::TearDownTestCase() 79{ 80} 81 82namespace { 83/** 84 * @tc.name: InitDeviceManager_001 85 * @tc.desc: 1. set packName not null 86 * set dmInitCallback not null 87 * 2. call DeviceManagerImpl::InitDeviceManager with parameter 88 * 4. check ret is DM_OK 89 * deviceTypeId 90 * @tc.type: FUNC 91 * @tc.require: AR000GHSJK 92 */ 93HWTEST_F(DeviceManagerImplTest, InitDeviceManager_101, testing::ext::TestSize.Level0) 94{ 95 // 1. set packName not null 96 std::string packName = "com.ohos.test"; 97 // set dmInitCallback not null 98 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 99 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 100 // 3. check ret is DM_OK 101 ASSERT_EQ(ret, DM_OK); 102 DeviceManager::GetInstance().UnInitDeviceManager(packName); 103} 104 105/** 106 * @tc.name: UnInitDeviceManager_101 107 * @tc.desc: 1. set packName not null 108 * 2. MOCK IpcClientProxy UnInit return DM_OK 109 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter 110 * 4. check ret is DM_OK 111 * deviceTypeId 112 * @tc.type: FUNC 113 * @tc.require: AR000GHSJK 114 */ 115HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_101, testing::ext::TestSize.Level0) 116{ 117 std::string packName = "com.ohos.test2"; 118 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 119 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 120 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 121 ASSERT_EQ(ret, DM_OK); 122} 123 124/** 125 * @tc.name: GetTrustedDeviceList_101 126 * @tc.desc: 1. set packName not null 127 * set extra null 128 * set deviceList null 129 * 2. MOCK IpcClientProxy SendRequest return DM_OK 130 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 131 * 4. check ret is DM_OK 132 * deviceTypeId 133 * @tc.type: FUNC 134 * @tc.require: AR000GHSJK 135 */ 136HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_101, testing::ext::TestSize.Level0) 137{ 138 // 1. set packName not null 139 std::string packName = "com.ohos.test"; 140 // set extra null 141 std::string extra = ""; 142 // set deviceList null 143 std::vector<DmDeviceInfo> deviceList; 144 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 145 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 146 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 147 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 148 // 3. check ret is DM_OK 149 ASSERT_EQ(ret, DM_OK); 150 DeviceManager::GetInstance().UnInitDeviceManager(packName); 151} 152 153/** 154 * @tc.name: GetAvailableDeviceList_101 155 * @tc.desc: 1. set packName null 156 * set deviceList null 157 * 2. call DeviceManagerImpl::GetAvailableDeviceList with parameter 158 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 159 * deviceTypeId 160 * @tc.type: FUNC 161 */ 162HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_101, testing::ext::TestSize.Level0) 163{ 164 std::string packName; 165 std::vector<DmDeviceBasicInfo> deviceList; 166 int32_t ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList); 167 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 168} 169 170/** 171 * @tc.name: GetAvailableDeviceList_102 172 * @tc.desc: 1. set packName not null 173 * set deviceList null 174 * 2. InitDeviceManager return DM_OK 175 * 3. call DeviceManagerImpl::GetAvailableDeviceList with parameter 176 * 4. check ret is DM_OK 177 * deviceTypeId 178 * @tc.type: FUNC 179 */ 180HWTEST_F(DeviceManagerImplTest, GetAvailableDeviceList_102, testing::ext::TestSize.Level0) 181{ 182 std::string packName = "com.ohos.test"; 183 std::vector<DmDeviceBasicInfo> deviceList; 184 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 185 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 186 ret = DeviceManager::GetInstance().GetAvailableDeviceList(packName, deviceList); 187 ASSERT_EQ(ret, DM_OK); 188 DeviceManager::GetInstance().UnInitDeviceManager(packName); 189} 190 191/** 192 * @tc.name: GetLocalDeviceNetWorkId_101 193 * @tc.desc: 1. set packName null 194 * set networkId null 195 * 2. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter 196 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 197 * deviceTypeId 198 * @tc.type: FUNC 199 */ 200HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_101, testing::ext::TestSize.Level0) 201{ 202 std::string packName; 203 std::string networkId; 204 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId); 205 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 206} 207 208/** 209 * @tc.name: GetLocalDeviceNetWorkId_102 210 * @tc.desc: 1. set packName not null 211 * set networkId not null 212 * 2. InitDeviceManager return DM_OK 213 * 3. call DeviceManagerImpl::GetLocalDeviceNetWorkId with parameter 214 * 4. check ret is DM_OK 215 * deviceTypeId 216 * @tc.type: FUNC 217 */ 218HWTEST_F(DeviceManagerImplTest, GetLocalDeviceNetWorkId_102, testing::ext::TestSize.Level0) 219{ 220 std::string packName = "com.ohos.test"; 221 std::string networkId = "networkId"; 222 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 223 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 224 ret = DeviceManager::GetInstance().GetLocalDeviceNetWorkId(packName, networkId); 225 ASSERT_EQ(ret, DM_OK); 226 DeviceManager::GetInstance().UnInitDeviceManager(packName); 227} 228 229/** 230 * @tc.name: GetLocalDeviceId_101 231 * @tc.desc: 1. set packName null 232 * set deviceId null 233 * 2. call DeviceManagerImpl::GetLocalDeviceId with parameter 234 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 235 * deviceTypeId 236 * @tc.type: FUNC 237 */ 238HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_101, testing::ext::TestSize.Level0) 239{ 240 std::string packName; 241 std::string deviceId; 242 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId); 243 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 244} 245 246/** 247 * @tc.name: GetLocalDeviceId_102 248 * @tc.desc: 1. set packName not null 249 * set deviceId not null 250 * 2. InitDeviceManager return DM_OK 251 * 3. call DeviceManagerImpl::GetLocalDeviceId with parameter 252 * 4. check ret is DM_OK 253 * deviceTypeId 254 * @tc.type: FUNC 255 */ 256HWTEST_F(DeviceManagerImplTest, GetLocalDeviceId_102, testing::ext::TestSize.Level0) 257{ 258 std::string packName = "com.ohos.test"; 259 std::string deviceId = "deviceId"; 260 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 261 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 262 ret = DeviceManager::GetInstance().GetLocalDeviceId(packName, deviceId); 263 ASSERT_EQ(ret, DM_OK); 264 DeviceManager::GetInstance().UnInitDeviceManager(packName); 265} 266 267/** 268 * @tc.name: GetLocalDeviceName_101 269 * @tc.desc: 1. set packName null 270 * set deviceName null 271 * 2. call DeviceManagerImpl::GetLocalDeviceName with parameter 272 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 273 * deviceTypeId 274 * @tc.type: FUNC 275 */ 276HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_101, testing::ext::TestSize.Level0) 277{ 278 std::string packName; 279 std::string deviceName; 280 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName); 281 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 282} 283 284/** 285 * @tc.name: GetLocalDeviceName_102 286 * @tc.desc: 1. set packName not null 287 * set deviceName not null 288 * 2. InitDeviceManager return DM_OK 289 * 3. call DeviceManagerImpl::GetLocalDeviceName with parameter 290 * 4. check ret is DM_OK 291 * deviceTypeId 292 * @tc.type: FUNC 293 */ 294HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_102, testing::ext::TestSize.Level0) 295{ 296 std::string packName = "com.ohos.test"; 297 std::string deviceName = "deviceName"; 298 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 299 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 300 ret = DeviceManager::GetInstance().GetLocalDeviceName(packName, deviceName); 301 ASSERT_EQ(ret, DM_OK); 302 DeviceManager::GetInstance().UnInitDeviceManager(packName); 303} 304 305 306/** 307 * @tc.name: GetLocalDeviceType_101 308 * @tc.desc: 1. set packName null 309 * set deviceType 0 310 * 2. call DeviceManagerImpl::GetLocalDeviceType with parameter 311 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 312 * deviceTypeId 313 * @tc.type: FUNC 314 */ 315HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_101, testing::ext::TestSize.Level0) 316{ 317 std::string packName; 318 int32_t deviceType = 0; 319 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType); 320 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 321} 322 323/** 324 * @tc.name: GetLocalDeviceType_102 325 * @tc.desc: 1. set packName not null 326 * set deviceType 0 327 * 2. InitDeviceManager return DM_OK 328 * 3. call DeviceManagerImpl::GetLocalDeviceType with parameter 329 * 4. check ret is DM_OK 330 * deviceTypeId 331 * @tc.type: FUNC 332 */ 333HWTEST_F(DeviceManagerImplTest, GetLocalDeviceType_102, testing::ext::TestSize.Level0) 334{ 335 std::string packName = "com.ohos.test"; 336 int32_t deviceType = 0; 337 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 338 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 339 ret = DeviceManager::GetInstance().GetLocalDeviceType(packName, deviceType); 340 ASSERT_EQ(ret, DM_OK); 341 DeviceManager::GetInstance().UnInitDeviceManager(packName); 342} 343 344/** 345 * @tc.name: GetDeviceName_101 346 * @tc.desc: 1. set packName null 347 * set networkId not null 348 * set deviceName null 349 * 3. call DeviceManagerImpl::GetDeviceName with parameter 350 * 4. check ret is ERR_DM_INPUT_PARA_INVALID 351 * deviceTypeId 352 * @tc.type: FUNC 353 */ 354HWTEST_F(DeviceManagerImplTest, GetDeviceName_101, testing::ext::TestSize.Level0) 355{ 356 std::string packName; 357 std::string networkId = "networkId"; 358 std::string deviceName; 359 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName); 360 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 361} 362 363/** 364 * @tc.name: GetDeviceName_102 365 * @tc.desc: 1. set packName not null 366 * set networkId null 367 * set deviceName null 368 * 2. call DeviceManagerImpl::GetDeviceName with parameter 369 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 370 * deviceTypeId 371 * @tc.type: FUNC 372 */ 373HWTEST_F(DeviceManagerImplTest, GetDeviceName_102, testing::ext::TestSize.Level0) 374{ 375 std::string packName = "com.ohos.test"; 376 std::string networkId; 377 std::string deviceName; 378 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName); 379 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 380} 381 382/** 383 * @tc.name: GetDeviceName_103 384 * @tc.desc: 1. set packName not null 385 * set networkId not null 386 * set deviceName null 387 * 2. call DeviceManagerImpl::GetDeviceName with parameter 388 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 389 * deviceTypeId 390 * @tc.type: FUNC 391 */ 392HWTEST_F(DeviceManagerImplTest, GetDeviceName_103, testing::ext::TestSize.Level0) 393{ 394 std::string packName = "com.ohos.test"; 395 std::string networkId = "networkId"; 396 std::string deviceName; 397 int32_t ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName); 398 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 399} 400 401/** 402 * @tc.name: GetDeviceName_104 403 * @tc.desc: 1. set packName not null 404 * set networkId not null 405 * set deviceName null 406 * 2. InitDeviceManager return DM_OK 407 * 3. call DeviceManagerImpl::GetDeviceName with parameter 408 * 4. check ret is DM_OK 409 * deviceTypeId 410 * @tc.type: FUNC 411 */ 412HWTEST_F(DeviceManagerImplTest, GetDeviceName_104, testing::ext::TestSize.Level0) 413{ 414 std::string packName = "com.ohos.test"; 415 std::string networkId = "networkId"; 416 std::string deviceName; 417 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 418 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 419 ret = DeviceManager::GetInstance().GetDeviceName(packName, networkId, deviceName); 420 ASSERT_EQ(ret, DM_OK); 421 DeviceManager::GetInstance().UnInitDeviceManager(packName); 422} 423 424/** 425 * @tc.name: GetDeviceType_101 426 * @tc.desc: 1. set packName null 427 * set deviceList not null 428 * set deviceType 0 429 * 2. call DeviceManagerImpl::GetDeviceType with parameter 430 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 431 * deviceTypeId 432 * @tc.type: FUNC 433 */ 434HWTEST_F(DeviceManagerImplTest, GetDeviceType_101, testing::ext::TestSize.Level0) 435{ 436 std::string packName; 437 std::string networkId = "networkId"; 438 int32_t deviceType = 0; 439 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType); 440 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 441} 442 443/** 444 * @tc.name: GetDeviceType_102 445 * @tc.desc: 1. set packName not null 446 * set networkId null 447 * set deviceType 0 448 * 2. call DeviceManagerImpl::GetDeviceType with parameter 449 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 450 * deviceTypeId 451 * @tc.type: FUNC 452 */ 453HWTEST_F(DeviceManagerImplTest, GetDeviceType_102, testing::ext::TestSize.Level0) 454{ 455 std::string packName = "com.ohos.test"; 456 std::string networkId; 457 int32_t deviceType = 0; 458 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType); 459 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 460} 461 462/** 463 * @tc.name: GetDeviceType_103 464 * @tc.desc: 1. set packName not null 465 * set networkId not null 466 * set deviceType 0 467 * 2. call DeviceManagerImpl::GetDeviceType with parameter 468 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 469 * deviceTypeId 470 * @tc.type: FUNC 471 */ 472HWTEST_F(DeviceManagerImplTest, GetDeviceType_103, testing::ext::TestSize.Level0) 473{ 474 std::string packName = "com.ohos.test"; 475 std::string networkId = "networkId"; 476 int32_t deviceType = 0; 477 int32_t ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType); 478 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 479} 480 481/** 482 * @tc.name: GetDeviceType_104 483 * @tc.desc: 1. set packName not null 484 * set networkId not null 485 * set deviceType 0 486 * 2. InitDeviceManager return DM_OK 487 * 3. call DeviceManagerImpl::GetDeviceType with parameter 488 * 4. check ret is DM_OK 489 * deviceTypeId 490 * @tc.type: FUNC 491 */ 492HWTEST_F(DeviceManagerImplTest, GetDeviceType_104, testing::ext::TestSize.Level0) 493{ 494 std::string packName = "com.ohos.test"; 495 std::string networkId = "networkId"; 496 int32_t deviceType = 0; 497 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 498 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 499 ret = DeviceManager::GetInstance().GetDeviceType(packName, networkId, deviceType); 500 ASSERT_EQ(ret, DM_OK); 501 DeviceManager::GetInstance().UnInitDeviceManager(packName); 502} 503 504/** 505 * @tc.name: UnBindDevice_101 506 * @tc.desc: 1. set packName null 507 * set deviceId not null 508 * 2. call DeviceManagerImpl::UnBindDevice with parameter 509 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 510 * deviceTypeId 511 * @tc.type: FUNC 512 */ 513HWTEST_F(DeviceManagerImplTest, UnBindDevice_101, testing::ext::TestSize.Level0) 514{ 515 std::string packName ; 516 std::string deviceId = "deviceId"; 517 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId); 518 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 519} 520 521/** 522 * @tc.name: UnBindDevice_102 523 * @tc.desc: 1. set packName not null 524 * set deviceId null 525 * 2. call DeviceManagerImpl::UnBindDevice with parameter 526 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 527 * deviceTypeId 528 * @tc.type: FUNC 529 */ 530HWTEST_F(DeviceManagerImplTest, UnBindDevice_102, testing::ext::TestSize.Level0) 531{ 532 std::string packName = "com.ohos.test"; 533 std::string deviceId; 534 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId); 535 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 536} 537 538/** 539 * @tc.name: UnBindDevice_103 540 * @tc.desc: 1. set packName not null 541 * set deviceId not null 542 * 2. call DeviceManagerImpl::UnBindDevice with parameter 543 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 544 * deviceTypeId 545 * @tc.type: FUNC 546 */ 547HWTEST_F(DeviceManagerImplTest, UnBindDevice_103, testing::ext::TestSize.Level0) 548{ 549 std::string packName = "com.ohos.test"; 550 std::string deviceId = "deviceId"; 551 int32_t ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId); 552 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 553} 554 555/** 556 * @tc.name: UnBindDevice_104 557 * @tc.desc: 1. set packName not null 558 * set deviceId not null 559 * 2. InitDeviceManager return DM_OK 560 * 3. call DeviceManagerImpl::UnBindDevice with parameter 561 * 4. check ret is ERR_DM_INPUT_PARA_INVALID 562 * deviceTypeId 563 * @tc.type: FUNC 564 */ 565HWTEST_F(DeviceManagerImplTest, UnBindDevice_104, testing::ext::TestSize.Level0) 566{ 567 std::string packName; 568 std::string deviceId; 569 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 570 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 571 ret = DeviceManager::GetInstance().UnBindDevice(packName, deviceId); 572 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 573 DeviceManager::GetInstance().UnInitDeviceManager(packName); 574} 575 576/** 577 * @tc.name: BindDevice_101 578 * @tc.desc: 1. set packName null 579 * set bindType 0 580 * set deviceId not null 581 * set bindParam null 582 * set callback null 583 * 2. call DeviceManagerImpl::BindDevice with parameter 584 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 585 * deviceTypeId 586 * @tc.type: FUNC 587 */ 588HWTEST_F(DeviceManagerImplTest, BindDevice_101, testing::ext::TestSize.Level0) 589{ 590 std::string packName ; 591 int32_t bindType = 0; 592 std::string deviceId = "deviceId"; 593 std::string bindParam; 594 std::shared_ptr<AuthenticateCallback> callback = nullptr; 595 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback); 596 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 597} 598 599/** 600 * @tc.name: BindDevice_102 601 * @tc.desc: 1. set packName not null 602 * set bindType 0 603 * set deviceId null 604 * set bindParam null 605 * set callback null 606 * 2. call DeviceManagerImpl::BindDevice with parameter 607 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 608 * deviceTypeId 609 * @tc.type: FUNC 610 */ 611HWTEST_F(DeviceManagerImplTest, BindDevice_102, testing::ext::TestSize.Level0) 612{ 613 std::string packName = "com.ohos.test"; 614 int32_t bindType = 0; 615 std::string deviceId; 616 std::string bindParam; 617 std::shared_ptr<AuthenticateCallback> callback = nullptr; 618 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback); 619 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 620} 621 622/** 623 * @tc.name: BindDevice_103 624 * @tc.desc: 1. set packName not null 625 * set bindType 0 626 * set deviceId not null 627 * set bindParam null 628 * set callback null 629 * 2. call DeviceManagerImpl::BindDevice with parameter 630 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 631 * deviceTypeId 632 * @tc.type: FUNC 633 */ 634HWTEST_F(DeviceManagerImplTest, BindDevice_103, testing::ext::TestSize.Level0) 635{ 636 std::string packName = "com.ohos.test"; 637 int32_t bindType = 0; 638 std::string deviceId = "deviceId"; 639 std::string bindParam = "{\"status\":1}"; 640 std::shared_ptr<AuthenticateCallback> callback = nullptr; 641 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback); 642 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 643} 644 645/** 646 * @tc.name: BindDevice_104 647 * @tc.desc: 1. set packName not null 648 * set bindType 0 649 * set deviceId not null 650 * set bindParam null 651 * set callback null 652 * 2. InitDeviceManager return DM_OK 653 * 3. call DeviceManagerImpl::BindDevice with parameter 654 * 4. check ret is not DM_OK 655 * deviceTypeId 656 * @tc.type: FUNC 657 */ 658HWTEST_F(DeviceManagerImplTest, BindDevice_104, testing::ext::TestSize.Level0) 659{ 660 std::string packName = "com.ohos.test"; 661 int32_t bindType = 0; 662 std::string deviceId = "deviceId"; 663 std::string bindParam; 664 std::shared_ptr<AuthenticateCallback> callback = nullptr; 665 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>(); 666 DeviceManager::GetInstance().InitDeviceManager(packName, initCallback); 667 int32_t ret = DeviceManager::GetInstance().BindDevice(packName, bindType, deviceId, bindParam, callback); 668 ASSERT_NE(ret, DM_OK); 669 DeviceManager::GetInstance().UnInitDeviceManager(packName); 670} 671 672/** 673 * @tc.name: RegisterDevStateCallback_101 674 * @tc.desc: 1. set packName not null 675 * set extra not null 676 * set callback not null 677 * 2. InitDeviceManager return DM_OK 678 * 3. call DeviceManagerImpl::RegisterDevStateCallback with parameter 679 * 4. check ret is DM_OK 680 * deviceTypeId 681 * @tc.type: FUNC 682 */ 683HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_101, testing::ext::TestSize.Level0) 684{ 685 std::string packName = "com.ohos.test"; 686 std::string extra = "extra"; 687 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(); 688 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>(); 689 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback); 690 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback); 691 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 692 DeviceManager::GetInstance().UnInitDeviceManager(packName); 693} 694 695/** 696 * @tc.name: RegisterDevStateCallback_102 697 * @tc.desc: 1. set packName null 698 * set extra not null 699 * set callback not null 700 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 701 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 702 * deviceTypeId 703 * @tc.type: FUNC 704 */ 705HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_102, testing::ext::TestSize.Level0) 706{ 707 std::string packName; 708 std::string extra = "extra"; 709 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(); 710 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback); 711 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 712} 713 714/** 715 * @tc.name: RegisterDevStateCallback_103 716 * @tc.desc: 1. set packName null 717 * set extra not null 718 * set callback not null 719 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 720 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 721 * deviceTypeId 722 * @tc.type: FUNC 723 */ 724HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_103, testing::ext::TestSize.Level0) 725{ 726 std::string packName = "com.ohos.test"; 727 std::string extra = "extra"; 728 std::shared_ptr<DeviceStateCallback> callback = nullptr; 729 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback); 730 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 731} 732 733/** 734 * @tc.name: UnRegisterDevStateCallback_101 735 * @tc.desc: 1. set packName not null 736 * 2. InitDeviceManager return DM_OK 737 * 3. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 738 * 4. check ret is DM_OK 739 * deviceTypeId 740 * @tc.type: FUNC 741 */ 742HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallbackk_101, testing::ext::TestSize.Level0) 743{ 744 std::string packName = "com.ohos.test"; 745 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>(); 746 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initCallback); 747 ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 748 ASSERT_EQ(ret, DM_OK); 749 DeviceManager::GetInstance().UnInitDeviceManager(packName); 750} 751 752/** 753 * @tc.name: UnRegisterDevStateCallback_102 754 * @tc.desc: 1. set packName null 755 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 756 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 757 * deviceTypeId 758 * @tc.type: FUNC 759 */ 760HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_102, testing::ext::TestSize.Level0) 761{ 762 std::string packName; 763 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 764 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 765} 766 767/** 768 * @tc.name: GetLocalDeviceInfo_101 769 * @tc.desc: 1. set packName null 770 * set extra null 771 * set deviceList null 772 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 773 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 774 * deviceTypeId 775 * @tc.type: FUNC 776 * @tc.require: AR000GHSJK 777 */ 778HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_101, testing::ext::TestSize.Level0) 779{ 780 // 1. set packName not null 781 std::string packName = "com.ohos.test"; 782 // set extra null 783 DmDeviceInfo info; 784 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED 785 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 786 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 787 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 788 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 789 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 790 ASSERT_EQ(ret, DM_OK); 791 DeviceManager::GetInstance().UnInitDeviceManager(packName); 792} 793 794/** 795 * @tc.name: StartDeviceDiscovery_101 796 * @tc.desc: 1. set packName not null 797 * set subscribeInfo null 798 * set callback not null 799 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 800 * 3. check ret is DM_OK 801 * deviceTypeId 802 * @tc.type: FUNC 803 * @tc.require: AR000GHSJK 804 */ 805HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_101, testing::ext::TestSize.Level0) 806{ 807 std::string packName = "com.ohos.helloworld"; 808 std::string extra = ""; 809 DmSubscribeInfo subscribeInfo; 810 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 811 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 812 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 813 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 814 ASSERT_EQ(ret, DM_OK); 815 DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId); 816 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 817} 818 819/** 820 * @tc.name: StartDeviceDiscovery_102 821 * @tc.desc: 1. set packName not null 822 * set subscribeInfo null 823 * set callback not null 824 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 825 * 3. check ret is DM_OK 826 * deviceTypeId 827 * @tc.type: FUNC 828 * @tc.require: AR000GHSJK 829 */ 830HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_102, testing::ext::TestSize.Level0) 831{ 832 std::string packName = "com.ohos.helloworld"; 833 std::string extra = "{\"findDeviceMode\":1}"; 834 DmSubscribeInfo subscribeInfo; 835 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 836 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 837 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 838 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 839 ASSERT_EQ(ret, DM_OK); 840 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId); 841 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 842} 843 844/** 845 * @tc.name: StartDeviceDiscovery_103 846 * @tc.desc: 1. set packName not null 847 * set subscribeId 0 848 * set filterOptions null 849 * set callback not null 850 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 851 * 3. check ret is DM_OK 852 * deviceTypeId 853 * @tc.type: FUNC 854 * @tc.require: AR000GHSJK 855 */ 856HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_103, testing::ext::TestSize.Level0) 857{ 858 std::string packName = "com.ohos.helloworld"; 859 uint16_t subscribeId = 0; 860 std::string filterOptions; 861 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 862 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 863 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 864 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback); 865 ASSERT_EQ(ret, DM_OK); 866 DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 867 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 868} 869 870/** 871 * @tc.name: StartDeviceDiscovery_104 872 * @tc.desc: 1. set packName not null 873 * set subscribeId 0 874 * set filterOptions null 875 * set callback not null 876 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 877 * 3. check ret is ERR_DM_DISCOVERY_REPEATED 878 * deviceTypeId 879 * @tc.type: FUNC 880 * @tc.require: AR000GHSJK 881 */ 882HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize.Level0) 883{ 884 std::string packName = "com.ohos.helloworld"; 885 uint16_t subscribeId = 0; 886 std::string filterOptions; 887 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 888 DmDeviceInfo deviceInfo; 889 callback->OnDeviceFound(subscribeId, deviceInfo); 890 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback); 891 ASSERT_EQ(ret, ERR_DM_DISCOVERY_REPEATED); 892} 893 894/** 895 * @tc.name: StopDeviceDiscovery_101 896 * @tc.desc: 1. set packName not null 897 * set subscribeInfo null 898 * set callback not null 899 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter 900 * 3. check ret is DM_OK 901 * deviceTypeId 902 * @tc.type: FUNC 903 * @tc.require: AR000GHSJK 904 */ 905HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.Level0) 906{ 907 std::string packName = "com.ohos.test"; 908 std::string extra = ""; 909 DmSubscribeInfo subscribeInfo; 910 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 911 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 912 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 913 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId); 914 ASSERT_EQ(ret, DM_OK); 915 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 916} 917 918/** 919 * @tc.name: StopDeviceDiscovery_102 920 * @tc.desc: 1. set packName not null 921 * set subscribeId is 0 922 * 2. InitDeviceManager return DM_OK 923 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 924 * 4. check ret is DM_OK 925 * deviceTypeId 926 * @tc.type: FUNC 927 * @tc.require: AR000GHSJK 928 */ 929HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_102, testing::ext::TestSize.Level0) 930{ 931 // 1. set packName not null 932 std::string packName = "com.ohos.test"; 933 // set subscribeInfo is 0 934 uint16_t subscribeId = 0; 935 // 2. InitDeviceManager return DM_OK 936 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 937 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 938 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 939 ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 940 // 4. check ret is DM_OK 941 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 942 DeviceManager::GetInstance().UnInitDeviceManager(packName); 943} 944 945/** 946 * @tc.name: PublishDeviceDiscovery_101 947 * @tc.desc: 1. set packName not null 948 * set publishInfo null 949 * set callback not null 950 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 951 * 3. check ret is DM_OK 952 * deviceTypeId 953 * @tc.type: FUNC 954 * @tc.require: I5N1K3 955 */ 956HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_101, testing::ext::TestSize.Level0) 957{ 958 std::string packName = "com.ohos.helloworld"; 959 DmPublishInfo publishInfo; 960 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>(); 961 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 962 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 963 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 964 ASSERT_EQ(ret, DM_OK); 965 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 966} 967 968/** 969 * @tc.name: UnPublishDeviceDiscovery_101 970 * @tc.desc: 1. set packName not null 971 * set publishId is 0 972 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 973 * 3. check ret is DM_OK 974 * deviceTypeId 975 * @tc.type: FUNC 976 * @tc.require: I5N1K3 977 */ 978HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_101, testing::ext::TestSize.Level0) 979{ 980 std::string packName = "com.ohos.test"; 981 int32_t publishId = 0; 982 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 983 auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 984 DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>(); 985 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 986 ASSERT_EQ(ret, DM_OK); 987 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 988} 989 990/** 991 * @tc.name: AuthenticateDevice_101 992 * @tc.desc: 1. set packName not null 993 * set dmDeviceInfo null 994 * set dmAppImageInfo null 995 * set extra null 996 * set callback null 997 * 2. InitDeviceManager return DM_OK 998 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 999 * 4. check ret is ERR_DM_INPUT_PARA_INVALID 1000 * deviceTypeId 1001 * @tc.type: FUNC 1002 * @tc.require: AR000GHSJK 1003 */ 1004HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_101, testing::ext::TestSize.Level0) 1005{ 1006 // 1. set packName not null 1007 std::string packName = "com.ohos.helloworld"; 1008 // set dmDeviceInfo null 1009 int32_t authType = 1; 1010 // set dmAppImageInfo null 1011 DmDeviceInfo dmDeviceInfo; 1012 strcpy_s(dmDeviceInfo.deviceId, DM_MAX_DEVICE_ID_LEN, "123XXXX"); 1013 strcpy_s(dmDeviceInfo.deviceName, DM_MAX_DEVICE_NAME_LEN, "234"); 1014 dmDeviceInfo.deviceTypeId = 0; 1015 // set extra null 1016 std::string extra = "test"; 1017 // set callback null 1018 std::shared_ptr<AuthenticateCallback> callback = nullptr; 1019 // 2.InitDeviceManager return DM_OK 1020 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>(); 1021 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback); 1022 ASSERT_EQ(ret, DM_OK); 1023 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 1024 ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 1025 // 4. check ret is DM_OK 1026 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1027 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1028} 1029 1030/** 1031 * @tc.name: UnAuthenticateDevice_101 1032 * @tc.desc: 1. set packName not null 1033 * set dmDeviceInfo null 1034 * set dmAppImageInfo null 1035 * set extra null 1036 * set callback null 1037 * 2. InitDeviceManager return DM_OK 1038 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 1039 * 4. check ret is DM_OK 1040 * deviceTypeId 1041 * @tc.type: FUNC 1042 * @tc.require: AR000GHSJK 1043 */ 1044HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize.Level0) 1045{ 1046 // 1. set packName not null 1047 std::string packName = "com.ohos.helloworld"; 1048 DmDeviceInfo deviceInfo; 1049 deviceInfo.networkId[0] = '1'; 1050 deviceInfo.networkId[1] = '2'; 1051 deviceInfo.networkId[2] = '\0'; 1052 // set callback null 1053 std::shared_ptr<AuthenticateCallback> callback = nullptr; 1054 // 2. InitDeviceManager return DM_OK 1055 std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>(); 1056 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback); 1057 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 1058 ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 1059 // 4. check ret is ERR_DM_FAILED 1060 ASSERT_EQ(ret, ERR_DM_FAILED); 1061 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1062} 1063 1064/** 1065 * @tc.name: SetUserOperation_101 1066 * @tc.desc: 1. set packName not null 1067 * set action null 1068 * 2. InitDeviceManager return DM_OK 1069 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1070 * 4. check ret is DM_OK 1071 * deviceTypeId 1072 * @tc.type: FUNC 1073 * @tc.require: AR000GHSJK 1074 */ 1075HWTEST_F(DeviceManagerImplTest, SetUserOperation_101, testing::ext::TestSize.Level0) 1076{ 1077 // 1. set packName not null 1078 std::string packName = "com.ohos.test"; 1079 // set authParam null 1080 int32_t action = 0; 1081 const std::string param = "extra"; 1082 // 2. InitDeviceManager return DM_OK 1083 std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>(); 1084 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1085 // 3. call DeviceManagerImpl::SetUserOperation with parameter 1086 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 1087 // 4. check ret is DM_OK 1088 ASSERT_EQ(ret, DM_OK); 1089 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1090} 1091 1092/** 1093 * @tc.name: InitDeviceManager_001 1094 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt 1095 * 2. check ret is ERR_DM_INPUT_PARA_INVALID 1096 * deviceTypeId 1097 * @tc.type: FUNC 1098 * @tc.require: AR000GHSJK 1099 */ 1100HWTEST_F(DeviceManagerImplTest, InitDeviceManager_001, testing::ext::TestSize.Level0) 1101{ 1102 // 1. call DeviceManagerImpl::InitDeviceManager with packName = null, dmInitCallback = nullprt 1103 std::string packName = ""; 1104 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr; 1105 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, dmInitCallback); 1106 // 2. check ret is ERR_DM_INPUT_PARA_INVALID 1107 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1108} 1109 1110/** 1111 * @tc.name: InitDeviceManager_002 1112 * @tc.desc: 1. set packName not null 1113 * set dmInitCallback not null 1114 * 2. call DeviceManagerImpl::InitDeviceManager with parameter 1115 * 3. check ret is DM_OK 1116 * deviceTypeId 1117 * @tc.type: FUNC 1118 * @tc.require: AR000GHSJK 1119 */ 1120HWTEST_F(DeviceManagerImplTest, InitDeviceManager_002, testing::ext::TestSize.Level0) 1121{ 1122 // 1. set packName not null 1123 std::string packName = "com.ohos.test"; 1124 // set dmInitCallback not null 1125 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1126 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1127 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1128 // 3. check ret is DM_OK 1129 ASSERT_EQ(ret, DM_OK); 1130} 1131 1132/** 1133 * @tc.name: InitDeviceManager_003 1134 * @tc.desc: 1. set packName not null 1135 * set dmInitCallback not null 1136 * 2. MOCK IpcClientProxy Init return ERR_DM_INIT_FAILED 1137 * 3. call DeviceManagerImpl::InitDeviceManager with parameter 1138 * 4. check ret is ERR_DM_INIT_FAILED 1139 * deviceTypeId 1140 * @tc.type: FUNC 1141 * @tc.require: AR000GHSJK 1142 */ 1143HWTEST_F(DeviceManagerImplTest, InitDeviceManager_003, testing::ext::TestSize.Level0) 1144{ 1145 // 1. set packName not null 1146 std::string packName = "com.ohos.test"; 1147 // set dmInitCallback not null 1148 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1149 // 2. MOCK IpcClientProxy Init return ERR_DM_FAILED 1150 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1151 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1152 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1153 // 3. call DeviceManagerImpl::InitDeviceManager with parameter 1154 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1155 // 4. check ret is DM_OK 1156 ASSERT_EQ(ret, DM_OK); 1157 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1158} 1159 1160/** 1161 * @tc.name: InitDeviceManager_004 1162 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt 1163 * 2. check ret is ERR_DM_INPUT_PARA_INVALID 1164 * deviceTypeId 1165 * @tc.type: FUNC 1166 * @tc.require: AR000GHSJK 1167 */ 1168HWTEST_F(DeviceManagerImplTest, InitDeviceManager_004, testing::ext::TestSize.Level0) 1169{ 1170 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt 1171 std::string packName = "com.ohos.test"; 1172 std::shared_ptr<DmInitCallbackTest> callback = nullptr; 1173 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1174 // 2. check ret is ERR_DM_INPUT_PARA_INVALID 1175 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1176} 1177 1178/** 1179 * @tc.name: InitDeviceManager_005 1180 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt 1181 * 2. check ret is ERR_DM_INPUT_PARA_INVALID 1182 * deviceTypeId 1183 * @tc.type: FUNC 1184 * @tc.require: AR000GHSJK 1185 */ 1186HWTEST_F(DeviceManagerImplTest, InitDeviceManager_005, testing::ext::TestSize.Level0) 1187{ 1188 // 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt 1189 std::string packName = ""; 1190 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1191 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1192 // 2. check ret is ERR_DM_INPUT_PARA_INVALID 1193 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1194} 1195 1196/** 1197 * @tc.name: UnInitDeviceManager_001 1198 * @tc.desc: 1. call DeviceManagerImpl::InitDeviceManager with packName not null, dmInitCallback = nullprt 1199 * 2. check ret is ERR_DM_INPUT_PARA_INVALID 1200 * deviceTypeId 1201 * @tc.type: FUNC 1202 * @tc.require: AR000GHSJK 1203 */ 1204HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_001, testing::ext::TestSize.Level0) 1205{ 1206 // 1. set packName not null 1207 std::string packName = ""; 1208 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1209 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 1210 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1211 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1212} 1213 1214/** 1215 * @tc.name: UnInitDeviceManager_002 1216 * @tc.desc: 1. set packName not null 1217 * 2. MOCK IpcClientProxy UnInit return ERR_DM_FAILED 1218 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter 1219 * 4. check ret is ERR_DM_FAILED 1220 * deviceTypeId 1221 * @tc.type: FUNC 1222 * @tc.require: AR000GHSJK 1223 */ 1224HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_002, testing::ext::TestSize.Level0) 1225{ 1226 // 1. set packName not null 1227 std::string packName = "com.ohos.test"; 1228 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1229 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1230 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1231 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1232 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 1233 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 1234 // 3. check ret is ERR_DM_FAILED 1235 ASSERT_EQ(ret, ERR_DM_FAILED); 1236 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1237} 1238 1239/** 1240 * @tc.name: UnInitDeviceManager_003 1241 * @tc.desc: 1. set packName not null 1242 * 2. MOCK IpcClientProxy UnInit return DM_OK 1243 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter 1244 * 4. check ret is DM_OK 1245 * deviceTypeId 1246 * @tc.type: FUNC 1247 * @tc.require: AR000GHSJK 1248 */ 1249HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_003, testing::ext::TestSize.Level0) 1250{ 1251 // 1. set packName not null 1252 std::string packName = "com.ohos.test"; 1253 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1254 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1255 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1256 ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 1257 // 3. check ret is DM_OK 1258 ASSERT_EQ(ret, DM_OK); 1259} 1260 1261/** 1262 * @tc.name: UnInitDeviceManager_004 1263 * @tc.desc: 1. set packName not null 1264 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED 1265 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter 1266 * 4. check ret is ERR_DM_FAILED 1267 * deviceTypeId 1268 * @tc.type: FUNC 1269 * @tc.require: AR000GHSJK 1270 */ 1271HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_004, testing::ext::TestSize.Level0) 1272{ 1273 // 1. set packNamen not null 1274 std::string packName = "com.ohos.test"; 1275 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1276 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1277 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1278 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1279 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1280 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 1281 // 3. check ret is ERR_DM_FAILED 1282 ASSERT_EQ(ret, ERR_DM_FAILED); 1283 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1284} 1285 1286/** 1287 * @tc.name: UnInitDeviceManager_005 1288 * @tc.desc: 1. set packName not null 1289 * 2. MOCK IpcClientProxy UnInit return ERR_DM_INIT_FAILED 1290 * 3. call DeviceManagerImpl::UnInitDeviceManager with parameter 1291 * 4. check ret is ERR_DM_FAILED 1292 * deviceTypeId 1293 * @tc.type: FUNC 1294 * @tc.require: AR000GHSJK 1295 */ 1296HWTEST_F(DeviceManagerImplTest, UnInitDeviceManager_005, testing::ext::TestSize.Level0) 1297{ 1298 // 1. set packName not null 1299 std::string packName = "com.ohos.test"; 1300 // 2. call DeviceManagerImpl::InitDeviceManager with parameter 1301 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1302 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1303 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1304 EXPECT_CALL(*mockInstance, UnInit(testing::_)).Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1305 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(packName); 1306 // 3. check ret is ERR_DM_FAILED 1307 ASSERT_EQ(ret, ERR_DM_FAILED); 1308 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1309} 1310 1311/** 1312 * @tc.name: GetTrustedDeviceList_001 1313 * @tc.desc: 1. set packName null 1314 * set extra null 1315 * set deviceList null 1316 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1317 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1318 * deviceTypeId 1319 * @tc.type: FUNC 1320 * @tc.require: AR000GHSJK 1321 */ 1322HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0) 1323{ 1324 // 1. set packName null 1325 std::string packName = ""; 1326 // set extra null 1327 std::string extra = ""; 1328 // set deviceList null 1329 std::vector<DmDeviceInfo> deviceList; 1330 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1331 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 1332 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1333 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1334} 1335 1336/** 1337 * @tc.name: GetTrustedDeviceList_002 1338 * @tc.desc: 1. set packName not null 1339 * set extra null 1340 * set deviceList null 1341 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED 1342 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1343 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1344 * deviceTypeId 1345 * @tc.type: FUNC 1346 * @tc.require: AR000GHSJK 1347 */ 1348HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0) 1349{ 1350 // 1. set packName not null 1351 std::string packName = "com.ohos.test"; 1352 // set extra null 1353 std::string extra = ""; 1354 // set deviceList null 1355 std::vector<DmDeviceInfo> deviceList; 1356 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED 1357 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1358 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1359 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1360 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 1361 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1362 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1363 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 1364 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1365 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1366 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1367} 1368 1369/** 1370 * @tc.name: GetTrustedDeviceList_003 1371 * @tc.desc: 1. set packName not null 1372 * set extra null 1373 * set deviceList null 1374 * 2. MOCK IpcClientProxy SendRequest return DM_OK 1375 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1376 * 4. check ret is DM_OK 1377 * deviceTypeId 1378 * @tc.type: FUNC 1379 * @tc.require: AR000GHSJK 1380 */ 1381HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_003, testing::ext::TestSize.Level0) 1382{ 1383 // 1. set packName not null 1384 std::string packName = "com.ohos.test"; 1385 // set extra null 1386 std::string extra = ""; 1387 // set deviceList null 1388 std::vector<DmDeviceInfo> deviceList; 1389 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1390 DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1391 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 1392 // 3. check ret is DM_OK 1393 ASSERT_EQ(ret, DM_OK); 1394 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1395} 1396 1397/** 1398 * @tc.name: GetTrustedDeviceList_004 1399 * @tc.desc: 1. set packName not null 1400 * set extra null 1401 * set deviceList null 1402 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1403 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1404 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1405 * deviceTypeId 1406 * @tc.type: FUNC 1407 * @tc.require: AR000GHSJK 1408 */ 1409HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_004, testing::ext::TestSize.Level0) 1410{ 1411 // 1. set packName not null 1412 std::string packName = "com.ohos.test"; 1413 // set extra null 1414 std::string extra = "test"; 1415 // set deviceList null 1416 std::vector<DmDeviceInfo> deviceList; 1417 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1418 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1419 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1420 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1421 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 1422 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1423 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1424 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 1425 // 3. check ret is DEVICEMANAGER_IPC_FAILED 1426 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1427 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1428} 1429 1430/** 1431 * @tc.name: GetTrustedDeviceList_005 1432 * @tc.desc: 1. set packName null 1433 * set extra null 1434 * set deviceList null 1435 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1436 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1437 * deviceTypeId 1438 * @tc.type: FUNC 1439 * @tc.require: AR000GHSJK 1440 */ 1441HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_005, testing::ext::TestSize.Level0) 1442{ 1443 // 1. set packName null 1444 std::string packName = ""; 1445 // set extra null 1446 std::string extra = "test"; 1447 // set deviceList null 1448 std::vector<DmDeviceInfo> deviceList; 1449 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1450 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, deviceList); 1451 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1452 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1453} 1454 1455/** 1456 * @tc.name: GetTrustedDeviceList_006 1457 * @tc.desc: 1. set packName null 1458 * set extra null 1459 * set deviceList null 1460 * set isRefresh true 1461 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1462 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1463 * deviceTypeId 1464 * @tc.type: FUNC 1465 */ 1466HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_006, testing::ext::TestSize.Level0) 1467{ 1468 std::string packName = ""; 1469 std::string extra = ""; 1470 bool isRefresh = true; 1471 std::vector<DmDeviceInfo> deviceList; 1472 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList); 1473 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1474} 1475 1476/** 1477 * @tc.name: GetTrustedDeviceList_007 1478 * @tc.desc: 1. set packName not null 1479 * set extra null 1480 * set deviceList null 1481 * set isRefresh true 1482 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1483 * 3. check ret is DM_OK 1484 * deviceTypeId 1485 * @tc.type: FUNC 1486 */ 1487HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_007, testing::ext::TestSize.Level0) 1488{ 1489 std::string packName = "com.ohos.test"; 1490 std::string extra = ""; 1491 bool isRefresh = true; 1492 std::vector<DmDeviceInfo> deviceList; 1493 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, extra, isRefresh, deviceList); 1494 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 1495} 1496 1497/** 1498 * @tc.name: GetTrustedDeviceList_008 1499 * @tc.desc: 1. set packName not null 1500 * set extra null 1501 * set deviceList null 1502 * set isRefresh true 1503 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1504 * 3. check ret is DM_OK 1505 * deviceTypeId 1506 * @tc.type: FUNC 1507 */ 1508HWTEST_F(DeviceManagerImplTest, GetTrustedDeviceList_008, testing::ext::TestSize.Level0) 1509{ 1510 std::string packName = ""; 1511 std::map<std::string, std::string> filterOptions; 1512 bool isRefresh = false; 1513 std::vector<DmDeviceInfo> deviceList; 1514 int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList); 1515 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1516 packName = "packNameTest"; 1517 ret = DeviceManager::GetInstance().GetTrustedDeviceList(packName, filterOptions, isRefresh, deviceList); 1518 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1519} 1520 1521/** 1522 * @tc.name: ImportCredential_001 1523 * @tc.desc: 1. set pkgName not null 1524 * set reqJsonStr null 1525 * set returnJsonStr null 1526 * 2. call DeviceManagerImpl::ImportCredential with parameter 1527 * 3. check ret is DM_OK 1528 * deviceTypeId 1529 * @tc.type: FUNC 1530 */ 1531HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Level0) 1532{ 1533 std::string pkgName = ""; 1534 std::string reqJsonStr = ""; 1535 std::string returnJsonStr = ""; 1536 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1537 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1538 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1539 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1540 pkgName = "pkgNameTest"; 1541 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1542 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1543 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1544 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1545 pkgName = ""; 1546 reqJsonStr = "reqJsonStrTest"; 1547 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1548 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1549 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1550 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1551 pkgName = "pkgNameTest"; 1552 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1553 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1554 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1555 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1556 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1557 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1558 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1559 ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr); 1560 ASSERT_EQ(ret, DM_OK); 1561 ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr); 1562 ASSERT_EQ(ret, DM_OK); 1563} 1564 1565/** 1566 * @tc.name: RequestCredential_001 1567 * @tc.desc: 1. set pkgName not null 1568 * set reqJsonStr null 1569 * set returnJsonStr null 1570 * 2. call DeviceManagerImpl::RequestCredential with parameter 1571 * 3. check ret is DM_OK 1572 * deviceTypeId 1573 * @tc.type: FUNC 1574 */ 1575HWTEST_F(DeviceManagerImplTest, RequestCredential_001, testing::ext::TestSize.Level0) 1576{ 1577 std::string pkgName = ""; 1578 std::string reqJsonStr = ""; 1579 std::string returnJsonStr = ""; 1580 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr); 1581 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1582 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1583 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1584 pkgName = "pkgNameTest"; 1585 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr); 1586 ASSERT_EQ(ret, DM_OK); 1587 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1588 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1589 pkgName = ""; 1590 reqJsonStr = "reqJsonStrTest"; 1591 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr); 1592 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1593 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1594 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1595 pkgName = "pkgNameTest"; 1596 ret = DeviceManager::GetInstance().RequestCredential(pkgName, returnJsonStr); 1597 ASSERT_EQ(ret, DM_OK); 1598 ret = DeviceManager::GetInstance().CheckCredential(pkgName, reqJsonStr, returnJsonStr); 1599 ASSERT_EQ(ret, DM_OK); 1600} 1601 1602/** 1603 * @tc.name: GenerateEncryptedUuid_001 1604 * @tc.desc: 1. set packName null 1605 * set extra null 1606 * set deviceList null 1607 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1608 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1609 * deviceTypeId 1610 * @tc.type: FUNC 1611 */ 1612HWTEST_F(DeviceManagerImplTest, GenerateEncryptedUuid_001, testing::ext::TestSize.Level0) 1613{ 1614 std::string pkgName = ""; 1615 std::string uuid = ""; 1616 std::string appId = ""; 1617 std::string encryptedUuid = ""; 1618 int32_t ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1619 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1620 pkgName = "pkgNameTest"; 1621 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1622 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1623 pkgName = ""; 1624 uuid = "uuidTest"; 1625 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1626 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1627 pkgName = "pkgNameTest"; 1628 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1629 ASSERT_EQ(ret, DM_OK); 1630 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1631 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1632 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1633 ret = DeviceManager::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); 1634 ASSERT_EQ(ret, DM_OK); 1635} 1636 1637/** 1638 * @tc.name: GetNetworkTypeByNetworkId_001 1639 * @tc.desc: 1. set pkgName null 1640 * set networkId null 1641 * set networkType null 1642 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1643 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1644 * deviceTypeId 1645 * @tc.type: FUNC 1646 */ 1647HWTEST_F(DeviceManagerImplTest, GetNetworkTypeByNetworkId_001, testing::ext::TestSize.Level0) 1648{ 1649 std::string pkgName = ""; 1650 std::string networkId = ""; 1651 int32_t netWorkType = 0; 1652 int32_t ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType); 1653 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1654 pkgName = "pkgNameTest"; 1655 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType); 1656 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1657 pkgName = ""; 1658 networkId = "networkIdTest"; 1659 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType); 1660 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1661 pkgName = "pkgNameTest"; 1662 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType); 1663 ASSERT_EQ(ret, DM_OK); 1664 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1665 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1666 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1667 ret = DeviceManager::GetInstance().GetNetworkTypeByNetworkId(pkgName, networkId, netWorkType); 1668 ASSERT_EQ(ret, DM_OK); 1669} 1670 1671/** 1672 * @tc.name: ImportAuthCode_001 1673 * @tc.desc: 1. set packName null 1674 * set authCode null 1675 * 2. call DeviceManagerImpl::ImportAuthCode with parameter 1676 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1677 * deviceTypeId 1678 * @tc.type: FUNC 1679 */ 1680HWTEST_F(DeviceManagerImplTest, ImportAuthCode_001, testing::ext::TestSize.Level0) 1681{ 1682 std::string pkgName = ""; 1683 std::string authCode = ""; 1684 int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1685 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1686 pkgName = "pkgNameTest"; 1687 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1688 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1689 pkgName = ""; 1690 authCode = "authCodeTest"; 1691 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1692 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1693 pkgName = "pkgNameTest"; 1694 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1695 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1696 authCode = "authoCo"; 1697 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1698 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1699} 1700 1701/** 1702 * @tc.name: RegisterDiscoveryCallback_001 1703 * @tc.desc: 1. set packName null 1704 * set discoverParam null 1705 * set filterOptions null 1706 * set callback null 1707 * 2. call DeviceManagerImpl::RegisterDiscoveryCallback with parameter 1708 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1709 * deviceTypeId 1710 * @tc.type: FUNC 1711 */ 1712HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0) 1713{ 1714 std::string pkgName = ""; 1715 std::map<std::string, std::string> discoverParam; 1716 std::map<std::string, std::string> filterOptions; 1717 std::shared_ptr<DiscoveryCallback> callback = nullptr; 1718 int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, 1719 discoverParam, filterOptions, callback); 1720 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1721 ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback); 1722 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1723 ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName); 1724 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1725 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam); 1726 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1727 pkgName = "pkgNameTest"; 1728 ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, callback); 1729 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1730 ret = DeviceManager::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions, callback); 1731 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1732 callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 1733 ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName); 1734 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1735 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, discoverParam); 1736 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1737} 1738 1739/** 1740 * @tc.name: StartAdvertising_001 1741 * @tc.desc: 1. set packName null 1742 * set discoverParam null 1743 * set filterOptions null 1744 * set callback null 1745 * 2. call DeviceManagerImpl::StartAdvertising with parameter 1746 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1747 * deviceTypeId 1748 * @tc.type: FUNC 1749 */ 1750HWTEST_F(DeviceManagerImplTest, StartAdvertising_001, testing::ext::TestSize.Level0) 1751{ 1752 std::string pkgName = ""; 1753 std::map<std::string, std::string> advertiseParam; 1754 std::shared_ptr<PublishCallback> callback = nullptr; 1755 int32_t ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback); 1756 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1757 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam); 1758 pkgName = "pkgNameTest"; 1759 ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback); 1760 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1761 ret = DeviceManager::GetInstance().StopDiscovering(pkgName, advertiseParam); 1762 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1763 callback = std::make_shared<DevicePublishCallbackTest>(); 1764 ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback); 1765 ASSERT_EQ(ret, DM_OK); 1766} 1767 1768/** 1769 * @tc.name: BindTarget_001 1770 * @tc.desc: 1. set packName null 1771 * set targetId null 1772 * set unbindParam null 1773 * set callback null 1774 * 2. call DeviceManagerImpl::BindTarget with parameter 1775 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1776 * deviceTypeId 1777 * @tc.type: FUNC 1778 */ 1779HWTEST_F(DeviceManagerImplTest, BindTarget_001, testing::ext::TestSize.Level0) 1780{ 1781 std::string pkgName = ""; 1782 PeerTargetId targetId; 1783 std::map<std::string, std::string> unbindParam; 1784 std::shared_ptr<BindTargetCallback> callback = nullptr; 1785 std::shared_ptr<UnbindTargetCallback> uncallback = nullptr; 1786 int32_t ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback); 1787 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1788 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback); 1789 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1790 targetId.deviceId = "deviceIdTest"; 1791 targetId.brMac = "brMacTest"; 1792 targetId.bleMac = "bleMacTest"; 1793 targetId.wifiIp = "wifiIpTest"; 1794 ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback); 1795 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1796 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback); 1797 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1798 pkgName = "pkgNameTest"; 1799 ret = DeviceManager::GetInstance().BindTarget(pkgName, targetId, unbindParam, callback); 1800 ASSERT_EQ(ret, DM_OK); 1801 ret = DeviceManager::GetInstance().UnbindTarget(pkgName, targetId, unbindParam, uncallback); 1802 ASSERT_EQ(ret, DM_OK); 1803} 1804 1805/** 1806 * @tc.name: GetLocalDeviceInfo_001 1807 * @tc.desc: 1. set packName null 1808 * set extra null 1809 * set deviceList null 1810 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1811 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1812 * deviceTypeId 1813 * @tc.type: FUNC 1814 * @tc.require: AR000GHSJK 1815 */ 1816HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0) 1817{ 1818 // 1. set packName not null 1819 std::string packName = "com.ohos.test"; 1820 DmDeviceInfo info; 1821 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1822 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1823 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 1824 ASSERT_EQ(ret, DM_OK); 1825 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1826} 1827 1828/** 1829 * @tc.name: GetLocalDeviceInfo_002 1830 * @tc.desc: 1. set packName not null 1831 * set extra null 1832 * set deviceList null 1833 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED 1834 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1835 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1836 * deviceTypeId 1837 * @tc.type: FUNC 1838 * @tc.require: AR000GHSJK 1839 */ 1840HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0) 1841{ 1842 // 1. set packName not null 1843 std::string packName = "com.ohos.test"; 1844 // set extra null 1845 DmDeviceInfo info; 1846 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_IPC_SEND_REQUEST_FAILED 1847 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1848 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1849 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1850 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 1851 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1852 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1853 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 1854 // 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1855 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1856 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1857} 1858 1859/** 1860 * @tc.name: GetLocalDeviceInfo_003 1861 * @tc.desc: 1. set packName not null 1862 * set extra null 1863 * set deviceList null 1864 * 2. MOCK IpcClientProxy SendRequest return DM_OK 1865 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1866 * 4. check ret is DM_OK 1867 * deviceTypeId 1868 * @tc.type: FUNC 1869 * @tc.require: AR000GHSJK 1870 */ 1871HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_003, testing::ext::TestSize.Level0) 1872{ 1873 // 1. set packName not null 1874 std::string packName = "com.ohos.test"; 1875 // set extra null 1876 DmDeviceInfo info; 1877 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1878 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1879 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1880 ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 1881 // 3. check ret is DM_OK 1882 ASSERT_EQ(ret, DM_OK); 1883 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1884} 1885 1886/** 1887 * @tc.name: GetLocalDeviceInfo_004 1888 * @tc.desc: 1. set packName not null 1889 * set extra null 1890 * set deviceList null 1891 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1892 * 3. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1893 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1894 * deviceTypeId 1895 * @tc.type: FUNC 1896 * @tc.require: AR000GHSJK 1897 */ 1898HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_004, testing::ext::TestSize.Level0) 1899{ 1900 // 1. set packName not null 1901 std::string packName = "com.ohos.test"; 1902 // set extra null 1903 DmDeviceInfo info; 1904 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1905 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1906 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1907 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1908 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 1909 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1910 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1911 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 1912 // 3. check ret is DEVICEMANAGER_IPC_FAILED 1913 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1914 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1915} 1916 1917/** 1918 * @tc.name: GetLocalDeviceInfo_005 1919 * @tc.desc: 1. set packName null 1920 * set extra null 1921 * set deviceList null 1922 * 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1923 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1924 * deviceTypeId 1925 * @tc.type: FUNC 1926 * @tc.require: AR000GHSJK 1927 */ 1928HWTEST_F(DeviceManagerImplTest, GetLocalDeviceInfo_005, testing::ext::TestSize.Level0) 1929{ 1930 // 1. set packName not null 1931 std::string packName = ""; 1932 // set extra null 1933 DmDeviceInfo info; 1934 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1935 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 1936 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 1937 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 1938 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 1939 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1940 // 2. call DeviceManagerImpl::GetTrustedDeviceList with parameter 1941 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(packName, info); 1942 // 3. check ret is DEVICEMANAGER_IPC_FAILED 1943 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1944 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 1945} 1946 1947/** 1948 * @tc.name: RegisterDevStateCallback_001 1949 * @tc.desc: 1. set packName null 1950 * set extra null 1951 * set callback null 1952 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 1953 * 3. check ret is DEVICEMANAGER_INVALID_VALUE 1954 * deviceTypeId 1955 * @tc.type: FUNC 1956 * @tc.require: AR000GHSJK 1957 */ 1958HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_001, testing::ext::TestSize.Level0) 1959{ 1960 // 1. set packName null 1961 std::string packName = ""; 1962 // set extra null 1963 std::string extra = ""; 1964 // set callback nullptr 1965 std::shared_ptr<DeviceStateCallback> callback = nullptr; 1966 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 1967 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, callback); 1968 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1969 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1970} 1971 1972/** 1973 * @tc.name: RegisterDevStateCallback_002 1974 * @tc.desc: 1. set packName not null 1975 * set extra null 1976 * set callback not null 1977 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 1978 * 3. check ret is DM_OK 1979 * deviceTypeId 1980 * @tc.type: FUNC 1981 * @tc.require: AR000GHSJK 1982 */ 1983HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_002, testing::ext::TestSize.Level0) 1984{ 1985 // 1. set packName null 1986 std::string packName = "com.ohos.test"; 1987 // set extra null 1988 std::string extra = ""; 1989 // set callback not null 1990 std::shared_ptr<DeviceStateCallback> dsCallback =std::make_shared<DeviceStateCallbackTest>(); 1991 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 1992 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 1993 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 1994 ret = DeviceManager::GetInstance().RegisterDevStateCallback(packName, extra, dsCallback); 1995 // 3. check ret is DM_OK 1996 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 1997 DeviceManager::GetInstance().UnInitDeviceManager(packName); 1998} 1999 2000/** 2001 * @tc.name: RegisterDevStateCallback_003 2002 * @tc.desc: 1. set packName null 2003 * set extra not null 2004 * set callback null 2005 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 2006 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2007 * deviceTypeId 2008 * @tc.type: FUNC 2009 * @tc.require: AR000GHSJK 2010 */ 2011HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_003, testing::ext::TestSize.Level0) 2012{ 2013 // 1. set packName null 2014 std::string pkgName = ""; 2015 // set extra null 2016 std::string extra = "test"; 2017 // set callback nullptr 2018 std::shared_ptr<DeviceStateCallback> callback = nullptr; 2019 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2020 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback); 2021 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2022 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2023} 2024 2025/** 2026 * @tc.name: RegisterDevStateCallback_004 2027 * @tc.desc: 1. set packName not null 2028 * set extra not null 2029 * set callback not null 2030 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 2031 * 3. check ret is DM_OK 2032 * deviceTypeId 2033 * @tc.type: FUNC 2034 * @tc.require: AR000GHSJK 2035 */ 2036HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_004, testing::ext::TestSize.Level0) 2037{ 2038 // 1. set packName null 2039 std::string pkgName = "com.ohos.test"; 2040 // set extra null 2041 std::string extra = "test"; 2042 // set callback nullptr 2043 std::shared_ptr<DeviceStateCallback> callback = nullptr; 2044 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2045 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback); 2046 // 3. check ret is DM_OK 2047 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2048} 2049 2050/** 2051 * @tc.name: RegisterDevStateCallback_005 2052 * @tc.desc: 1. set packName not null 2053 * set extra not null 2054 * set callback null 2055 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 2056 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2057 * deviceTypeId 2058 * @tc.type: FUNC 2059 * @tc.require: AR000GHSJK 2060 */ 2061HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_005, testing::ext::TestSize.Level0) 2062{ 2063 // 1. set packName null 2064 std::string pkgName = "com.ohos.test"; 2065 // set extra null 2066 std::string extra = "test1"; 2067 // set callback nullptr 2068 std::shared_ptr<DeviceStateCallback> callback = nullptr; 2069 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2070 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra, callback); 2071 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2072 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2073} 2074 2075/** 2076 * @tc.name: RegisterDevStateCallback_006 2077 * @tc.desc: 1. set packName not null 2078 * set extra not null 2079 * set callback null 2080 * 2. call DeviceManagerImpl::RegisterDevStateCallback with parameter 2081 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2082 * deviceTypeId 2083 * @tc.type: FUNC 2084 * @tc.require: AR000GHSJK 2085 */ 2086HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_006, testing::ext::TestSize.Level0) 2087{ 2088 std::string pkgName = ""; 2089 std::map<std::string, std::string> extraParam; 2090 std::shared_ptr<DeviceStateCallback> callback = nullptr; 2091 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback); 2092 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2093 pkgName = "pkgNameTest"; 2094 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback); 2095 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2096 callback = std::make_shared<DeviceStateCallbackTest>(); 2097 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback); 2098 ASSERT_EQ(ret, DM_OK); 2099 pkgName = ""; 2100 ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extraParam, callback); 2101 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2102} 2103 2104/** 2105 * @tc.name: UnRegisterDevStateCallback_001 2106 * @tc.desc: 1. set packName null 2107 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 2108 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2109 * deviceTypeId 2110 * @tc.type: FUNC 2111 * @tc.require: AR000GHSJK 2112 */ 2113HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_001, testing::ext::TestSize.Level0) 2114{ 2115 // 1. set packName null 2116 std::string packName = ""; 2117 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2118 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 2119 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2120 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2121} 2122 2123/** 2124 * @tc.name: UnRegisterDevStateCallback_002 2125 * @tc.desc: 1. set packName null 2126 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 2127 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2128 * deviceTypeId 2129 * @tc.type: FUNC 2130 * @tc.require: AR000GHSJK 2131 */ 2132HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_002, testing::ext::TestSize.Level0) 2133{ 2134 // 1. set packName null 2135 std::string packName = ""; 2136 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2137 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 2138 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2139 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2140} 2141 2142/** 2143 * @tc.name: UnRegisterDevStateCallback_003 2144 * @tc.desc: 1. set packName null 2145 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 2146 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2147 * deviceTypeId 2148 * @tc.type: FUNC 2149 * @tc.require: AR000GHSJK 2150 */ 2151HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_003, testing::ext::TestSize.Level0) 2152{ 2153 // 1. set packName null 2154 std::string packName = ""; 2155 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2156 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 2157 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2158 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2159} 2160 2161/** 2162 * @tc.name: UnRegisterDevStateCallback_004 2163 * @tc.desc: 1. set packName null 2164 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 2165 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2166 * deviceTypeId 2167 * @tc.type: FUNC 2168 * @tc.require: AR000GHSJK 2169 */ 2170HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_004, testing::ext::TestSize.Level0) 2171{ 2172 // 1. set packName null 2173 std::string packName = ""; 2174 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2175 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 2176 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2177 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2178} 2179 2180/** 2181 * @tc.name: UnRegisterDevStateCallback_005 2182 * @tc.desc: 1. set packName null 2183 * 2. call DeviceManagerImpl::UnRegisterDevStateCallback with parameter 2184 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2185 * deviceTypeId 2186 * @tc.type: FUNC 2187 * @tc.require: AR000GHSJK 2188 */ 2189HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_005, testing::ext::TestSize.Level0) 2190{ 2191 // 1. set packName null 2192 std::string packName = ""; 2193 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 2194 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(packName); 2195 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2196 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2197} 2198 2199/** 2200 * @tc.name: StartDeviceDiscovery_001 2201 * @tc.desc: 1. set packName null 2202 * set subscribeInfo null 2203 * set callback null 2204 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2205 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2206 * deviceTypeId 2207 * @tc.type: FUNC 2208 * @tc.require: AR000GHSJK 2209 */ 2210HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0) 2211{ 2212 // 1. set packName null 2213 std::string packName = ""; 2214 // set subscribeInfo null 2215 std::string extra = "test"; 2216 DmSubscribeInfo subscribeInfo; 2217 // set callback null 2218 std::shared_ptr<DiscoveryCallback> callback = nullptr; 2219 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2220 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 2221 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2222 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2223} 2224 2225/** 2226 * @tc.name: StartDeviceDiscovery_002 2227 * @tc.desc: 1. set packName null 2228 * set subscribeInfo null 2229 * set callback null 2230 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2231 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 2232 * deviceTypeId 2233 * @tc.type: FUNC 2234 * @tc.require: AR000GHSJK 2235 */ 2236HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0) 2237{ 2238 // 1. set packName null 2239 std::string packName = "com.ohos.helloworld"; 2240 std::string extra = "test"; 2241 // set subscribeInfo null 2242 DmSubscribeInfo subscribeInfo; 2243 // set callback null 2244 std::shared_ptr<DiscoveryCallback> callback = nullptr; 2245 // 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2246 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 2247 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 2248 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2249} 2250 2251/** 2252 * @tc.name: StartDeviceDiscovery_003 2253 * @tc.desc: 1. set packName null 2254 * set subscribeInfo null 2255 * set callback null 2256 * 2. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2257 * 3. check ret is DEVICEMANAGER_INVALID_VALUE 2258 * deviceTypeId 2259 * @tc.type: FUNC 2260 * @tc.require: AR000GHSJK 2261 */ 2262HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0) 2263{ 2264 // 1. set packName not null 2265 std::string packName = "com.ohos.test"; 2266 // set subscribeInfo is 0 2267 DmSubscribeInfo subscribeInfo; 2268 std::string extra = "test"; 2269 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 2270 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 2271 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2272 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2273 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2274 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 2275 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 2276 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 2277 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 2278 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 2279 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2280 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 2281} 2282 2283/** 2284 * @tc.name: StartDeviceDiscovery_004 2285 * @tc.desc: 1. set packName not null 2286 * set subscribeInfo null 2287 * set callback not null 2288 * 2. MOCK IpcClientProxy SendRequest return DM_OK 2289 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2290 * 4. check ret is DM_OK 2291 * deviceTypeId 2292 * @tc.type: FUNC 2293 * @tc.require: AR000GHSJK 2294 */ 2295HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0) 2296{ 2297 // 1. set packName not null 2298 std::string packName = "com.ohos.helloworld"; 2299 std::string extra = "test"; 2300 // set subscribeInfo null 2301 DmSubscribeInfo subscribeInfo; 2302 // set callback not null 2303 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 2304 // 2. MOCK IpcClientProxy SendRequest return DM_OK 2305 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2306 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2307 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2308 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 2309 .Times(1).WillOnce(testing::Return(DM_OK)); 2310 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2311 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 2312 // 4. check ret is DM_OK 2313 ASSERT_EQ(ret, DM_OK); 2314 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 2315} 2316 2317/** 2318 * @tc.name: StartDeviceDiscovery_005 2319 * @tc.desc: 1. set packName not null 2320 * set subscribeInfo null 2321 * set callback not null 2322 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 2323 * 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2324 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 2325 * deviceTypeId 2326 * @tc.type: FUNC 2327 * @tc.require: AR000GHSJK 2328 */ 2329HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0) 2330{ 2331 // 1. set packName not null 2332 std::string packName = "com.ohos.helloworld"; 2333 std::string extra = "test"; 2334 // set subscribeInfo null 2335 DmSubscribeInfo subscribeInfo; 2336 // set callback not null 2337 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 2338 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 2339 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2340 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2341 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2342 EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) 2343 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 2344 // 3. call DeviceManagerImpl::StartDeviceDiscovery with parameter 2345 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); 2346 // 4. check ret is DEVICEMANAGER_IPC_FAILED 2347 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2348 DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; 2349} 2350 2351/** 2352 * @tc.name: IsSameAccount_001 2353 * @tc.desc: 1. set udid or bundleName null 2354 * 2. call DeviceManagerImpl::IsSameAccount with parameter 2355 * 3. check ret is false 2356 * @tc.type: FUNC 2357 */ 2358HWTEST_F(DeviceManagerImplTest, IsSameAccount_001, testing::ext::TestSize.Level0) 2359{ 2360 std::string udid = ""; 2361 bool ret = DeviceManager::GetInstance().IsSameAccount(udid); 2362 ASSERT_EQ(ret, false); 2363} 2364 2365/** 2366 * @tc.name: IsSameAccount_002 2367 * @tc.desc: 1. set udid and bundleName not null 2368 * 2. call DeviceManagerImpl::IsSameAccount with parameter 2369 * 3. check ret is true 2370 * @tc.type: FUNC 2371 */ 2372HWTEST_F(DeviceManagerImplTest, IsSameAccount_002, testing::ext::TestSize.Level0) 2373{ 2374 std::string udid = "udidTest"; 2375 std::string pkgName = "com.ohos.sameaccounttest"; 2376 std::shared_ptr<DmInitCallback> initCallback = std::make_shared<DmInitCallbackTest>(); 2377 DeviceManager::GetInstance().InitDeviceManager(pkgName, initCallback); 2378 bool ret = DeviceManager::GetInstance().IsSameAccount(udid); 2379 ASSERT_EQ(ret, true); 2380} 2381 2382/** 2383 * @tc.name: AddPublishCallback_001 2384 * @tc.desc: 1. set udid and bundleName not null 2385 * 2. call DeviceManagerImpl::AddPublishCallback with parameter 2386 * 3. check ret is true 2387 * @tc.type: FUNC 2388 */ 2389HWTEST_F(DeviceManagerImplTest, AddPublishcCllback_001, testing::ext::TestSize.Level0) 2390{ 2391 std::string pkgName = "com.ohos.test"; 2392 int32_t ret = DeviceManagerImpl::GetInstance().AddPublishCallback(pkgName); 2393 ASSERT_NE(ret, 0); 2394 ret = DeviceManagerImpl::GetInstance().RemovePublishCallback(pkgName); 2395 ASSERT_NE(ret, 0); 2396} 2397 2398/** 2399 * @tc.name: RegisterPinHolderCallback_001 2400 * @tc.desc: 1. set udid and bundleName not null 2401 * 2. call DeviceManagerImpl::RegisterPinHolderCallback with parameter 2402 * 3. check ret is true 2403 * @tc.type: FUNC 2404 */ 2405HWTEST_F(DeviceManagerImplTest, RegisterPinHolderCallback_001, testing::ext::TestSize.Level0) 2406{ 2407 std::string pkgName = ""; 2408 std::shared_ptr<PinHolderCallback> callback = nullptr; 2409 int32_t ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback); 2410 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2411 pkgName = "pkgNameTest"; 2412 ret = DeviceManager::GetInstance().RegisterPinHolderCallback(pkgName, callback); 2413 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2414} 2415 2416/** 2417 * @tc.name: CreatePinHolder_001 2418 * @tc.desc: 1. set udid and bundleName not null 2419 * 2. call DeviceManagerImpl::CreatePinHolder with parameter 2420 * 3. check ret is true 2421 * @tc.type: FUNC 2422 */ 2423HWTEST_F(DeviceManagerImplTest, CreatePinHolder_001, testing::ext::TestSize.Level0) 2424{ 2425 std::string pkgName = ""; 2426 PeerTargetId targetId; 2427 DmPinType pinType = DmPinType::QR_CODE; 2428 std::string payload = "payload"; 2429 int32_t ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2430 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2431 pkgName = "com.ohos.test"; 2432 targetId.deviceId = "deviceIdTest"; 2433 targetId.brMac = "brMacTest"; 2434 targetId.bleMac = "bleMacTest"; 2435 targetId.wifiIp = "wifiIpTest"; 2436 pinType = static_cast<DmPinType>(6); 2437 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2438 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2439 pinType = DmPinType::QR_CODE; 2440 payload.resize(DM_STRING_LENGTH_MAX * 2); 2441 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2442 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2443 payload.resize(10); 2444 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2445 ASSERT_EQ(ret, DM_OK); 2446 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2447 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2448 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2449 ret = DeviceManager::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload); 2450 ASSERT_EQ(ret, DM_OK); 2451} 2452 2453/** 2454 * @tc.name: DestroyPinHolder_001 2455 * @tc.desc: 1. set udid and bundleName not null 2456 * 2. call DeviceManagerImpl::DestroyPinHolder with parameter 2457 * 3. check ret is true 2458 * @tc.type: FUNC 2459 */ 2460HWTEST_F(DeviceManagerImplTest, DestoryPinHolder_001, testing::ext::TestSize.Level0) 2461{ 2462 std::string pkgName = ""; 2463 PeerTargetId targetId; 2464 DmPinType pinType = DmPinType::QR_CODE; 2465 std::string payload = "payload"; 2466 int32_t ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2467 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2468 pkgName = "com.ohos.test"; 2469 targetId.deviceId = "deviceIdTest"; 2470 targetId.brMac = "brMacTest"; 2471 targetId.bleMac = "bleMacTest"; 2472 targetId.wifiIp = "wifiIpTest"; 2473 pinType = static_cast<DmPinType>(6); 2474 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2475 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2476 pinType = DmPinType::QR_CODE; 2477 payload.resize(DM_STRING_LENGTH_MAX * 2); 2478 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2479 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2480 payload.resize(10); 2481 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2482 ASSERT_EQ(ret, DM_OK); 2483 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2484 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2485 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2486 ret = DeviceManager::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload); 2487 ASSERT_EQ(ret, DM_OK); 2488} 2489 2490/** 2491 * @tc.name: DpAclAdd_001 2492 * @tc.desc: 1. set DpAclAdd and Udid not null 2493 * 2. call DeviceManagerImpl::DpAclAdd with parameter 2494 * 3. check ret is true 2495 * @tc.type: FUNC 2496 */ 2497HWTEST_F(DeviceManagerImplTest, DpAclAdd_001, testing::ext::TestSize.Level0) 2498{ 2499 int64_t accessControlId = 0; 2500 std::string udid = "udidTest"; 2501 int32_t bindType = PEER_TO_PEER; 2502 int32_t ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType); 2503 ASSERT_EQ(ret, DM_OK); 2504 bindType = IDENTICAL_ACCOUNT; 2505 ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType); 2506 ASSERT_EQ(ret, DM_OK); 2507 std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>(); 2508 std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; 2509 DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; 2510 ret = DeviceManager::GetInstance().DpAclAdd(accessControlId, udid, bindType); 2511 ASSERT_EQ(ret, DM_OK); 2512} 2513 2514/** 2515 * @tc.name: GetDeviceSecurityLevel_001 2516 * @tc.desc: 1. set DpAclAdd and Udid not null 2517 * 2. call DeviceManagerImpl::GetDeviceSecurityLevel with parameter 2518 * 3. check ret is true 2519 * @tc.type: FUNC 2520 */ 2521HWTEST_F(DeviceManagerImplTest, GetDeviceSecurityLevel_001, testing::ext::TestSize.Level0) 2522{ 2523 int32_t securityLevel = 3; 2524 std::string pkgName = ""; 2525 std::string netWorkId = ""; 2526 int32_t ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel); 2527 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2528 pkgName = "com.ohos.test"; 2529 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel); 2530 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2531 netWorkId = "netWorkIdTest"; 2532 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel); 2533 ASSERT_EQ(ret, DM_OK); 2534 pkgName = ""; 2535 ret = DeviceManager::GetInstance().GetDeviceSecurityLevel(pkgName, netWorkId, securityLevel); 2536 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2537} 2538} // namespace 2539} // namespace DistributedHardware 2540} // namespace OHOS