1 /* 2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "UTTest_device_manager_impl.h" 17 #include "dm_device_info.h" 18 19 #include <memory> 20 #include <unistd.h> 21 #include "accesstoken_kit.h" 22 #include "device_manager_notify.h" 23 #include "dm_constants.h" 24 #include "dm_log.h" 25 #include "ipc_authenticate_device_req.h" 26 #include "ipc_get_info_by_network_req.h" 27 #include "ipc_get_info_by_network_rsp.h" 28 #include "ipc_get_local_device_info_rsp.h" 29 #include "ipc_get_trustdevice_req.h" 30 #include "ipc_get_trustdevice_rsp.h" 31 #include "ipc_req.h" 32 #include "ipc_rsp.h" 33 #include "ipc_set_useroperation_req.h" 34 #include "ipc_skeleton.h" 35 #include "ipc_publish_req.h" 36 #include "ipc_unpublish_req.h" 37 #include "ipc_unauthenticate_device_req.h" 38 #include "nativetoken_kit.h" 39 #include "securec.h" 40 #include "token_setproc.h" 41 #include "dm_anonymous.h" 42 43 using namespace testing; 44 using namespace testing::ext; 45 namespace OHOS { 46 namespace DistributedHardware { 47 namespace { 48 /** 49 * @tc.name: StopDeviceDiscovery_001 50 * @tc.desc: 1. set packName null 51 * set subscribeId is 0 52 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter 53 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 54 * deviceTypeId 55 * @tc.type: FUNC 56 * @tc.require: AR000GHSJK 57 */ 58 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0) 59 { 60 // 1. set packName null 61 std::string packName = ""; 62 // set subscribeInfo is 0 63 uint16_t subscribeId = 0; 64 // 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter 65 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 66 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 67 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 68 } 69 70 /** 71 * @tc.name: StopDeviceDiscovery_002 72 * @tc.desc: 1. set packName not null 73 * set subscribeId is 0 74 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 75 * 2. call DeviceManagerImpl::StopDeviceDiscovery with parameter 76 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 77 * deviceTypeId 78 * @tc.type: FUNC 79 * @tc.require: AR000GHSJK 80 */ 81 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0) 82 { 83 // 1. set packName not null 84 std::string packName = "com.ohos.test"; 85 // set subscribeInfo is 1 86 uint16_t subscribeId = 1; 87 std::string pkgNameTemp = ComposeStr(packName, 1); 88 DeviceManagerImpl::GetInstance().pkgName2SubIdMap_[pkgNameTemp] = 10; 89 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 90 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 91 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 92 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 93 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 94 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 95 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 96 } 97 98 /** 99 * @tc.name: StopDeviceDiscovery_003 100 * @tc.desc: 1. set packName not null 101 * set subscribeId is 0 102 * 2. MOCK IpcClientProxy SendRequest return DM_OK 103 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 104 * 4. check ret is DM_OK 105 * deviceTypeId 106 * @tc.type: FUNC 107 * @tc.require: AR000GHSJK 108 */ 109 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0) 110 { 111 // 1. set packName not null 112 std::string packName = "com.ohos.test"; 113 // set subscribeInfo is 1 114 uint16_t subscribeId = 1; 115 std::string pkgNameTemp = ComposeStr(packName, 1); 116 DeviceManagerImpl::GetInstance().pkgName2SubIdMap_[pkgNameTemp] = 10; 117 // 2. MOCK IpcClientProxy SendRequest return DM_OK 118 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 119 .Times(1).WillOnce(testing::Return(DM_OK)); 120 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 121 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 122 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 123 // 4. check ret is DM_OK 124 ASSERT_EQ(ret, DM_OK); 125 } 126 127 /** 128 * @tc.name: StopDeviceDiscovery_004 129 * @tc.desc: 1. set packName not null 130 * set subscribeId is 0 131 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 132 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 133 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 134 * deviceTypeId 135 * @tc.type: FUNC 136 * @tc.require: AR000GHSJK 137 */ 138 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.Level0) 139 { 140 // 1. set packName not null 141 std::string packName = "com.ohos.test"; 142 // set subscribeInfo is 0 143 uint16_t subscribeId = 0; 144 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 145 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 146 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 147 // 4. check ret is DM_OK 148 ASSERT_EQ(ret, DM_OK); 149 } 150 151 /** 152 * @tc.name: StopDeviceDiscovery_005 153 * @tc.desc: 1. set packName not null 154 * set subscribeId is 0 155 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 156 * 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 157 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 158 * deviceTypeId 159 * @tc.type: FUNC 160 * @tc.require: AR000GHSJK 161 */ 162 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.Level0) 163 { 164 // 1. set packName not null 165 std::string packName = "com.ohos.test"; 166 // set subscribeInfo is 0 167 uint16_t subscribeId = 0; 168 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 169 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 170 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId); 171 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 172 ASSERT_NE(ret, DM_OK); 173 } 174 175 /** 176 * @tc.name: PublishDeviceDiscovery_001 177 * @tc.desc: 1. set packName null 178 * set subscribeInfo null 179 * set callback null 180 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 181 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 182 * deviceTypeId 183 * @tc.type: FUNC 184 * @tc.require: I5N1K3 185 */ 186 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_001, testing::ext::TestSize.Level0) 187 { 188 // 1. set packName null 189 std::string packName = ""; 190 // set publishInfo null 191 DmPublishInfo publishInfo; 192 // set callback null 193 std::shared_ptr<PublishCallback> callback = nullptr; 194 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 195 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 196 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 197 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 198 } 199 200 /** 201 * @tc.name: PublishDeviceDiscovery_002 202 * @tc.desc: 1. set packName null 203 * set subscribeInfo null 204 * set callback null 205 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 206 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 207 * deviceTypeId 208 * @tc.type: FUNC 209 * @tc.require: I5N1K3 210 */ 211 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_002, testing::ext::TestSize.Level0) 212 { 213 // 1. set packName null 214 std::string packName = "com.ohos.helloworld"; 215 // set publishInfo null 216 DmPublishInfo publishInfo; 217 // set callback null 218 std::shared_ptr<PublishCallback> callback = nullptr; 219 // 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 220 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 221 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 222 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 223 } 224 225 /** 226 * @tc.name: PublishDeviceDiscovery_003 227 * @tc.desc: 1. set packName null 228 * set publishInfo null 229 * set callback null 230 * 2. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 231 * 3. check ret is DEVICEMANAGER_INVALID_VALUE 232 * deviceTypeId 233 * @tc.type: FUNC 234 * @tc.require: I5N1K3 235 */ 236 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_003, testing::ext::TestSize.Level0) 237 { 238 // 1. set packName not null 239 std::string packName = "com.ohos.test"; 240 // set publishInfo is 0 241 DmPublishInfo publishInfo; 242 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>(); 243 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 244 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 245 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 246 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 247 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 248 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 249 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 250 } 251 252 /** 253 * @tc.name: PublishDeviceDiscovery_004 254 * @tc.desc: 1. set packName not null 255 * set publishInfo null 256 * set callback not null 257 * 2. MOCK IpcClientProxy SendRequest return DM_OK 258 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 259 * 4. check ret is DM_OK 260 * deviceTypeId 261 * @tc.type: FUNC 262 * @tc.require: I5N1K3 263 */ 264 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_004, testing::ext::TestSize.Level0) 265 { 266 // 1. set packName not null 267 std::string packName = "com.ohos.helloworld"; 268 // set publishInfo null 269 DmPublishInfo publishInfo; 270 // set callback not null 271 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>(); 272 // 2. MOCK IpcClientProxy SendRequest return DM_OK 273 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 274 .Times(1).WillOnce(testing::Return(DM_OK)); 275 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 276 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 277 // 4. check ret is DM_OK 278 ASSERT_EQ(ret, DM_OK); 279 } 280 281 /** 282 * @tc.name:PublishDeviceDiscovery_005 283 * @tc.desc: 1. set packName not null 284 * set subscribeInfo null 285 * set callback not null 286 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 287 * 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 288 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 289 * deviceTypeId 290 * @tc.type: FUNC 291 * @tc.require: I5N1K3 292 */ 293 HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery_005, testing::ext::TestSize.Level0) 294 { 295 // 1. set packName not null 296 std::string packName = "com.ohos.helloworld"; 297 // set publishInfo null 298 DmPublishInfo publishInfo; 299 // set callback not null 300 std::shared_ptr<PublishCallback> callback = std::make_shared<DevicePublishCallbackTest>(); 301 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 302 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 303 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 304 // 3. call DeviceManagerImpl::PublishDeviceDiscovery with parameter 305 int32_t ret = DeviceManager::GetInstance().PublishDeviceDiscovery(packName, publishInfo, callback); 306 // 4. check ret is DEVICEMANAGER_IPC_FAILED 307 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 308 } 309 310 /** 311 * @tc.name: UnPublishDeviceDiscovery_001 312 * @tc.desc: 1. set packName null 313 * set publishId is 0 314 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 315 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 316 * deviceTypeId 317 * @tc.type: FUNC 318 * @tc.require: I5N1K3 319 */ 320 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_001, testing::ext::TestSize.Level0) 321 { 322 // 1. set packName null 323 std::string packName = ""; 324 // set publishId is 0 325 int32_t publishId = 0; 326 // 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 327 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 328 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 329 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 330 } 331 332 /** 333 * @tc.name: UnPublishDeviceDiscovery_002 334 * @tc.desc: 1. set packName not null 335 * set publishId is 0 336 * 2. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 337 * 3. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 338 * deviceTypeId 339 * @tc.type: FUNC 340 * @tc.require: I5N1K3 341 */ 342 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_002, testing::ext::TestSize.Level0) 343 { 344 // 1. set packName not null 345 std::string packName = "com.ohos.test"; 346 // set subscribeInfo is 0 347 int32_t publishId = 0; 348 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 349 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 350 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 351 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 352 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 353 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 354 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 355 } 356 357 /** 358 * @tc.name: UnPublishDeviceDiscovery_003 359 * @tc.desc: 1. set packName not null 360 * set publishId is 0 361 * 2. MOCK IpcClientProxy SendRequest return DM_OK 362 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 363 * 4. check ret is DM_OK 364 * deviceTypeId 365 * @tc.type: FUNC 366 * @tc.require: I5N1K3 367 */ 368 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_003, testing::ext::TestSize.Level0) 369 { 370 // 1. set packName not null 371 std::string packName = "com.ohos.test"; 372 // set subscribeInfo is 0 373 int32_t publishId = 0; 374 // 2. MOCK IpcClientProxy SendRequest return DM_OK 375 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 376 .Times(1).WillOnce(testing::Return(DM_OK)); 377 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 378 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 379 // 4. check ret is DM_OK 380 ASSERT_EQ(ret, DM_OK); 381 } 382 383 /** 384 * @tc.name: UnPublishDeviceDiscovery_004 385 * @tc.desc: 1. set packName not null 386 * set publishId is 0 387 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 388 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 389 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 390 * deviceTypeId 391 * @tc.type: FUNC 392 * @tc.require: I5N1K3 393 */ 394 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_004, testing::ext::TestSize.Level0) 395 { 396 // 1. set packName not null 397 std::string packName = "com.ohos.test"; 398 // set publishId is 0 399 int32_t publishId = 0; 400 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 401 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 402 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 403 // 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 404 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 405 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 406 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 407 } 408 409 /** 410 * @tc.name: UnPublishDeviceDiscovery_005 411 * @tc.desc: 1. set packName not null 412 * set publishId is 0 413 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 414 * 3. call DeviceManagerImpl::UnPublishDeviceDiscovery with parameter 415 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 416 * deviceTypeId 417 * @tc.type: FUNC 418 * @tc.require: I5N1K3 419 */ 420 HWTEST_F(DeviceManagerImplTest, UnPublishDeviceDiscovery_005, testing::ext::TestSize.Level0) 421 { 422 // 1. set packName not null 423 std::string packName = "com.ohos.test"; 424 // set publishId is 0 425 int32_t publishId = 0; 426 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 427 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 428 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 429 // 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter 430 int32_t ret = DeviceManager::GetInstance().UnPublishDeviceDiscovery(packName, publishId); 431 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 432 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 433 } 434 435 /** 436 * @tc.name: AuthenticateDevice_001 437 * @tc.desc: 1. set packName = null 438 * set dmDeviceInfo = null 439 * set dmAppImageInfo = null 440 * set extra = null 441 * set callback = nullptr 442 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter 443 * 3. check ret is DEVICEMANAGER_INVALID_VALUE 444 * deviceTypeId 445 * @tc.type: FUNC 446 * @tc.require: AR000GHSJK 447 */ 448 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_001, testing::ext::TestSize.Level0) 449 { 450 // 1. set packName = null 451 std::string packName = ""; 452 int32_t authType = 1; 453 // set dmDeviceInfo = null 454 DmDeviceInfo dmDeviceInfo; 455 // set extra = null 456 std::string extra = ""; 457 // set callback = nullptr 458 std::shared_ptr<AuthenticateCallback> callback = nullptr; 459 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 460 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 461 // 3. check ret is DEVICEMANAGER_INVALID_VALUE 462 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 463 } 464 465 /** 466 * @tc.name: AuthenticateDevice_002 467 * @tc.desc: 1. set packName not null 468 * set dmDeviceInfo null 469 * set dmAppImageInfo null 470 * set extra null 471 * set callback null 472 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 473 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 474 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 475 * deviceTypeId 476 * @tc.type: FUNC 477 * @tc.require: AR000GHSJK 478 */ 479 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_002, testing::ext::TestSize.Level0) 480 { 481 // 1. set packName not null 482 std::string packName = "com.ohos.helloworld"; 483 int32_t authType = 1; 484 // set dmDeviceInfo null 485 DmDeviceInfo dmDeviceInfo; 486 // set extra null 487 std::string extra = "{\"status\":1}"; 488 // set callback null 489 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(); 490 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 491 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 492 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 493 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 494 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 495 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 496 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 497 } 498 499 /** 500 * @tc.name: AuthenticateDevice_003 501 * @tc.desc: 1. set packName not null 502 * set dmDeviceInfo null 503 * set dmAppImageInfo null 504 * set extra null 505 * set callback null 506 * 2. MOCK IpcClientProxy SendRequest return DM_OK 507 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 508 * 4. check ret is DM_OK 509 * deviceTypeId 510 * @tc.type: FUNC 511 * @tc.require: AR000GHSJK 512 */ 513 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_003, testing::ext::TestSize.Level0) 514 { 515 // 1. set packName not null 516 std::string packName = "com.ohos.helloworld"; 517 // set dmDeviceInfo null 518 int32_t authType = 1; 519 // set dmAppImageInfo null 520 DmDeviceInfo dmDeviceInfo; 521 // set extra null 522 std::string extra = "{\"status\":1}"; 523 // set callback null 524 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(); 525 // 2. MOCK IpcClientProxy SendRequest return DM_OK 526 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 527 .Times(1).WillOnce(testing::Return(DM_OK)); 528 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 529 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 530 // 4. check ret is DM_OK 531 ASSERT_EQ(ret, DM_OK); 532 } 533 534 /** 535 * @tc.name: AuthenticateDevice_004 536 * @tc.desc: 1. set packName not null 537 * set dmDeviceInfo null 538 * set dmAppImageInfo null 539 * set extra null 540 * set callback null 541 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 542 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 543 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 544 * deviceTypeId 545 * @tc.type: FUNC 546 * @tc.require: AR000GHSJK 547 */ 548 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_004, testing::ext::TestSize.Level0) 549 { 550 // 1. set packName not null 551 std::string packName = "com.ohos.helloworld"; 552 // set dmDeviceInfo null 553 int32_t authType = 1; 554 // set dmAppImageInfo null 555 DmDeviceInfo dmDeviceInfo; 556 // set extra null 557 std::string extra = "{\"status\":1}"; 558 // set callback null 559 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(); 560 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 561 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 562 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 563 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 564 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 565 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 566 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 567 } 568 569 /** 570 * @tc.name: AuthenticateDevice_005 571 * @tc.desc: 1. set packName not null 572 * set dmDeviceInfo null 573 * set dmAppImageInfo null 574 * set extra null 575 * set callback null 576 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 577 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 578 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 579 * deviceTypeId 580 * @tc.type: FUNC 581 * @tc.require: AR000GHSJK 582 */ 583 HWTEST_F(DeviceManagerImplTest, AuthenticateDevice_005, testing::ext::TestSize.Level0) 584 { 585 // 1. set packName not null 586 std::string packName = "com.ohos.helloworld"; 587 // set dmDeviceInfo null 588 int32_t authType = 1; 589 // set dmAppImageInfo null 590 DmDeviceInfo dmDeviceInfo; 591 // set extra null 592 std::string extra = "{\"status\":1}"; 593 // set callback null 594 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(); 595 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 596 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 597 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 598 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 599 int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); 600 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 601 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 602 } 603 604 /** 605 * @tc.name: UnAuthenticateDevice_001 606 * @tc.desc: 1. set packName = null 607 * set dmDeviceInfo = null 608 * set dmAppImageInfo = null 609 * set extra = null 610 * set callback = nullptr 611 * 2. call DeviceManagerImpl::AuthenticateDevice with parameter 612 * 3. check ret is DEVICEMANAGER_INVALID_VALUE 613 * deviceTypeId 614 * @tc.type: FUNC 615 * @tc.require: AR000GHSJK 616 */ 617 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0) 618 { 619 // 1. set packName = null 620 std::string packName = ""; 621 DmDeviceInfo deviceInfo; 622 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 623 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 624 // 3. check ret is DEVICEMANAGER_INVALID_VALUE 625 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 626 } 627 628 /** 629 * @tc.name: UnAuthenticateDevice_002 630 * @tc.desc: 1. set packName not null 631 * set dmDeviceInfo null 632 * set dmAppImageInfo null 633 * set extra null 634 * set callback null 635 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 636 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 637 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 638 * deviceTypeId 639 * @tc.type: FUNC 640 * @tc.require: AR000GHSJK 641 */ 642 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0) 643 { 644 // 1. set packName = null 645 std::string packName = "com.ohos.helloworld"; 646 DmDeviceInfo deviceInfo; 647 deviceInfo.deviceId[0] = '\0'; 648 // 2. call DeviceManagerImpl::AuthenticateDevice with parameter 649 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 650 // 3. check ret is DEVICEMANAGER_INVALID_VALUE 651 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 652 } 653 654 /** 655 * @tc.name: UnAuthenticateDevice_003 656 * @tc.desc: 1. set packName not null 657 * set dmDeviceInfo null 658 * set dmAppImageInfo null 659 * set extra null 660 * set callback null 661 * 2. MOCK IpcClientProxy SendRequest return DM_OK 662 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 663 * 4. check ret is DM_OK 664 * deviceTypeId 665 * @tc.type: FUNC 666 * @tc.require: AR000GHSJK 667 */ 668 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0) 669 { 670 // 1. set packName not null 671 std::string packName = "com.ohos.helloworld"; 672 DmDeviceInfo deviceInfo; 673 deviceInfo.networkId[0] = '1'; 674 deviceInfo.networkId[1] = '2'; 675 deviceInfo.networkId[2] = '\0'; 676 // set callback null 677 std::shared_ptr<AuthenticateCallback> callback = nullptr; 678 // 2. MOCK IpcClientProxy SendRequest return DM_OK 679 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 680 .Times(1).WillOnce(testing::Return(DM_OK)); 681 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 682 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 683 // 4. check ret is DM_OK 684 ASSERT_EQ(ret, DM_OK); 685 } 686 687 /** 688 * @tc.name: UnAuthenticateDevice_004 689 * @tc.desc: 1. set packName not null 690 * set dmDeviceInfo null 691 * set dmAppImageInfo null 692 * set extra null 693 * set callback null 694 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 695 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 696 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 697 * deviceTypeId 698 * @tc.type: FUNC 699 * @tc.require: AR000GHSJK 700 */ 701 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0) 702 { 703 // 1. set packName not null 704 std::string packName = "com.ohos.helloworld"; 705 // set dmDeviceInfo null 706 DmDeviceInfo deviceInfo; 707 deviceInfo.networkId[0] = '1'; 708 deviceInfo.networkId[1] = '2'; 709 deviceInfo.networkId[2] = '\0'; 710 std::shared_ptr<AuthenticateCallback> callback = nullptr; 711 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 712 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 713 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 714 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 715 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 716 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 717 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 718 } 719 720 /** 721 * @tc.name: UnAuthenticateDevice_005 722 * @tc.desc: 1. set packName not null 723 * set dmDeviceInfo null 724 * set dmAppImageInfo null 725 * set extra null 726 * set callback null 727 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 728 * 3. call DeviceManagerImpl::AuthenticateDevice with parameter 729 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 730 * deviceTypeId 731 * @tc.type: FUNC 732 * @tc.require: AR000GHSJK 733 */ 734 HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0) 735 { 736 // 1. set packName not null 737 std::string packName = "com.ohos.helloworld"; 738 // set dmDeviceInfo null 739 DmDeviceInfo deviceInfo; 740 deviceInfo.networkId[0] = '1'; 741 deviceInfo.networkId[1] = '2'; 742 deviceInfo.networkId[2] = '\0'; 743 std::shared_ptr<AuthenticateCallback> callback = nullptr; 744 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 745 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 746 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 747 // 3. call DeviceManagerImpl::AuthenticateDevice with parameter 748 int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo); 749 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 750 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 751 } 752 753 /** 754 * @tc.name: SetUserOperation_001 755 * @tc.desc: 1. set packName null 756 * set action null 757 * 2. call DeviceManagerImpl::SetUserOperation with parameter 758 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 759 * deviceTypeId 760 * @tc.type: FUNC 761 * @tc.require: AR000GHSJK 762 */ 763 HWTEST_F(DeviceManagerImplTest, SetUserOperation_001, testing::ext::TestSize.Level0) 764 { 765 // 1. set packName null 766 std::string packName = ""; 767 // set authParam null 768 int32_t action = 0; 769 const std::string param = R"({"test":"extra"})"; 770 // 2. call DeviceManagerImpl::SetUserOperation with parameter 771 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 772 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 773 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 774 } 775 776 /** 777 * @tc.name: SetUserOperation_002 778 * @tc.desc: 1. set packName not null 779 * set action null 780 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 781 * 3. call DeviceManagerImpl::SetUserOperation with parameter 782 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 783 * deviceTypeId 784 * @tc.type: FUNC 785 * @tc.require: AR000GHSJK 786 */ 787 HWTEST_F(DeviceManagerImplTest, SetUserOperation_002, testing::ext::TestSize.Level0) 788 { 789 // 1. set packName null 790 std::string packName = "com.ohos.test"; 791 // set authParam null 792 int32_t action = 0; 793 const std::string param = R"({"test":"extra"})"; 794 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 795 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 796 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 797 // 3. call DeviceManagerImpl::SetUserOperation with parameter 798 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 799 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 800 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 801 } 802 803 /** 804 * @tc.name: SetUserOperation_003 805 * @tc.desc: 1. set packName not null 806 * set action null 807 * 2. MOCK IpcClientProxy SendRequest return DM_OK 808 * 3. call DeviceManagerImpl::SetUserOperation with parameter 809 * 4. check ret is DM_OK 810 * deviceTypeId 811 * @tc.type: FUNC 812 * @tc.require: AR000GHSJK 813 */ 814 HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Level0) 815 { 816 // 1. set packName not null 817 std::string packName = "com.ohos.test"; 818 // set authParam null 819 int32_t action = 0; 820 const std::string param = R"({"test":"extra"})"; 821 // 2. MOCK IpcClientProxy SendRequest return DM_OK 822 std::shared_ptr<DmInitCallbackTest> callback = std::make_shared<DmInitCallbackTest>(); 823 int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, callback); 824 // 3. call DeviceManagerImpl::SetUserOperation with parameter 825 ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 826 // 4. check ret is DM_OK 827 ASSERT_NE(ret, ERR_DM_TIME_OUT); 828 DeviceManager::GetInstance().UnInitDeviceManager(packName); 829 } 830 831 /** 832 * @tc.name: SetUserOperation_004 833 * @tc.desc: 1. set packName not null 834 * set action null 835 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 836 * 3. call DeviceManagerImpl::SetUserOperation with parameter 837 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 838 * deviceTypeId 839 * @tc.type: FUNC 840 * @tc.require: AR000GHSJK 841 */ 842 HWTEST_F(DeviceManagerImplTest, SetUserOperation_004, testing::ext::TestSize.Level0) 843 { 844 // 1. set packName null 845 std::string packName = "com.ohos.test"; 846 // set authParam null 847 int32_t action = 0; 848 const std::string param = R"({"test":"extra"})"; 849 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 850 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 851 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 852 // 3. call DeviceManagerImpl::SetUserOperation with parameter 853 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 854 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 855 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 856 } 857 858 /** 859 * @tc.name: SetUserOperation_005 860 * @tc.desc: 1. set packName not null 861 * set action null 862 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 863 * 3. call DeviceManagerImpl::SetUserOperation with parameter 864 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 865 * deviceTypeId 866 * @tc.type: FUNC 867 * @tc.require: AR000GHSJK 868 */ 869 HWTEST_F(DeviceManagerImplTest, SetUserOperation_005, testing::ext::TestSize.Level0) 870 { 871 // 1. set packName null 872 std::string packName = "com.ohos.test"; 873 // set authParam null 874 int32_t action = 0; 875 const std::string param = R"({"test":"extra"})"; 876 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 877 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 878 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 879 // 3. call DeviceManagerImpl::SetUserOperation with parameter 880 int32_t ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param); 881 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 882 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 883 } 884 885 /** 886 * @tc.name: GetUdidByNetworkId_001 887 * @tc.desc: 1. set packName null 888 * set action null 889 * 2. call DeviceManagerImpl::SetUserOperation with parameter 890 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 891 * deviceTypeId 892 * @tc.type: FUNC 893 * @tc.require: AR000GHSJK 894 */ 895 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_001, testing::ext::TestSize.Level0) 896 { 897 // 1. set packName null 898 std::string packName = ""; 899 // set authParam null 900 std::string netWorkId = "111"; 901 std::string udid = "222"; 902 // 2. call DeviceManagerImpl::SetUserOperation with parameter 903 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid); 904 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 905 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 906 } 907 908 /** 909 * @tc.name: GetUdidByNetworkId_002 910 * @tc.desc: 1. set packName not null 911 * set action null 912 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 913 * 3. call DeviceManagerImpl::SetUserOperation with parameter 914 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 915 * deviceTypeId 916 * @tc.type: FUNC 917 * @tc.require: AR000GHSJK 918 */ 919 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_002, testing::ext::TestSize.Level0) 920 { 921 // 1. set packName null 922 std::string packName = "com.ohos.test"; 923 // set authParam null 924 std::string netWorkId = "111"; 925 std::string udid = "222"; 926 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 927 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 928 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 929 // 3. call DeviceManagerImpl::SetUserOperation with parameter 930 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid); 931 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 932 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 933 } 934 935 /** 936 * @tc.name: GetUdidByNetworkId_003 937 * @tc.desc: 1. set packName not null 938 * set action null 939 * 2. MOCK IpcClientProxy SendRequest return DM_OK 940 * 3. call DeviceManagerImpl::SetUserOperation with parameter 941 * 4. check ret is DM_OK 942 * deviceTypeId 943 * @tc.type: FUNC 944 * @tc.require: AR000GHSJK 945 */ 946 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_003, testing::ext::TestSize.Level0) 947 { 948 // 1. set packName not null 949 std::string packName = "com.ohos.test"; 950 // set authParam null 951 std::string netWorkId = "111"; 952 std::string udid = "222"; 953 // 2. MOCK IpcClientProxy SendRequest return DM_OK 954 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 955 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 956 // 3. call DeviceManagerImpl::GetUdidByNetworkId with parameter 957 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid); 958 // 4. check ret is DM_OK 959 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 960 // DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; 961 } 962 963 /** 964 * @tc.name: GetUdidByNetworkId_004 965 * @tc.desc: 1. set packName not null 966 * set action null 967 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 968 * 3. call DeviceManagerImpl::SetUserOperation with parameter 969 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 970 * deviceTypeId 971 * @tc.type: FUNC 972 * @tc.require: AR000GHSJK 973 */ 974 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_004, testing::ext::TestSize.Level0) 975 { 976 // 1. set packName null 977 std::string packName = "com.ohos.test"; 978 // set authParam null 979 std::string netWorkId = "111"; 980 std::string udid = "222"; 981 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 982 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 983 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 984 // 3. call DeviceManagerImpl::SetUserOperation with parameter 985 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid); 986 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 987 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 988 } 989 990 /** 991 * @tc.name: GetUdidByNetworkId_005 992 * @tc.desc: 1. set packName not null 993 * set action null 994 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 995 * 3. call DeviceManagerImpl::SetUserOperation with parameter 996 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 997 * deviceTypeId 998 * @tc.type: FUNC 999 * @tc.require: AR000GHSJK 1000 */ 1001 HWTEST_F(DeviceManagerImplTest, GetUdidByNetworkId_005, testing::ext::TestSize.Level0) 1002 { 1003 // 1. set packName null 1004 std::string packName = "com.ohos.test"; 1005 // set authParam null 1006 std::string netWorkId = "111"; 1007 std::string udid = "222"; 1008 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 1009 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1010 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 1011 // 3. call DeviceManagerImpl::SetUserOperation with parameter 1012 int32_t ret = DeviceManager::GetInstance().GetUdidByNetworkId(packName, netWorkId, udid); 1013 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1014 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1015 } 1016 1017 /** 1018 * @tc.name: GetUuidByNetworkId_001 1019 * @tc.desc: 1. set packName null 1020 * set action null 1021 * 2. call DeviceManagerImpl::SetUserOperation with parameter 1022 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1023 * deviceTypeId 1024 * @tc.type: FUNC 1025 * @tc.require: AR000GHSJK 1026 */ 1027 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_001, testing::ext::TestSize.Level0) 1028 { 1029 // 1. set packName null 1030 std::string packName = ""; 1031 // set authParam null 1032 std::string netWorkId = "111"; 1033 std::string uuid = "222"; 1034 // 2. call DeviceManagerImpl::SetUserOperation with parameter 1035 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid); 1036 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1037 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1038 } 1039 1040 /** 1041 * @tc.name: GetUuidByNetworkId_002 1042 * @tc.desc: 1. set packName not null 1043 * set action null 1044 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 1045 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1046 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1047 * deviceTypeId 1048 * @tc.type: FUNC 1049 * @tc.require: AR000GHSJK 1050 */ 1051 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_002, testing::ext::TestSize.Level0) 1052 { 1053 // 1. set packName null 1054 std::string packName = "com.ohos.test"; 1055 // set authParam null 1056 std::string netWorkId = "111"; 1057 std::string uuid = "222"; 1058 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_FAILED 1059 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1060 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 1061 // 3. call DeviceManagerImpl::SetUserOperation with parameter 1062 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid); 1063 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1064 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1065 } 1066 1067 /** 1068 * @tc.name: GetUuidByNetworkId_003 1069 * @tc.desc: 1. set packName not null 1070 * set action null 1071 * 2. MOCK IpcClientProxy SendRequest return DM_OK 1072 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1073 * 4. check ret is DM_OK 1074 * deviceTypeId 1075 * @tc.type: FUNC 1076 * @tc.require: AR000GHSJK 1077 */ 1078 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_003, testing::ext::TestSize.Level0) 1079 { 1080 // 1. set packName not null 1081 std::string packName = "com.ohos.test"; 1082 // set authParam null 1083 std::string netWorkId = "111"; 1084 std::string uuid = "222"; 1085 // 2. MOCK IpcClientProxy SendRequest return DM_OK 1086 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1087 .Times(1).WillOnce(testing::Return(ERR_DM_FAILED)); 1088 // 3. call DeviceManagerImpl::GetUuidByNetworkId with parameter 1089 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid); 1090 // 4. check ret is DM_OK 1091 ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID); 1092 } 1093 1094 /** 1095 * @tc.name: GetUuidByNetworkId_004 1096 * @tc.desc: 1. set packName not null 1097 * set action null 1098 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1099 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1100 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1101 * deviceTypeId 1102 * @tc.type: FUNC 1103 * @tc.require: AR000GHSJK 1104 */ 1105 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_004, testing::ext::TestSize.Level0) 1106 { 1107 // 1. set packName null 1108 std::string packName = "com.ohos.test"; 1109 // set authParam null 1110 std::string netWorkId = "111"; 1111 std::string uuid = "222"; 1112 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_INIT_FAILED 1113 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1114 .Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED)); 1115 // 3. call DeviceManagerImpl::SetUserOperation with parameter 1116 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid); 1117 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1118 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1119 } 1120 1121 /** 1122 * @tc.name: GetUuidByNetworkId_005 1123 * @tc.desc: 1. set packName not null 1124 * set action null 1125 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 1126 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1127 * 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1128 * deviceTypeId 1129 * @tc.type: FUNC 1130 * @tc.require: AR000GHSJK 1131 */ 1132 HWTEST_F(DeviceManagerImplTest, GetUuidByNetworkId_005, testing::ext::TestSize.Level0) 1133 { 1134 // 1. set packName null 1135 std::string packName = "com.ohos.test"; 1136 // set authParam null 1137 std::string netWorkId = "111"; 1138 std::string uuid = "222"; 1139 // 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 1140 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1141 .Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL)); 1142 // 3. call DeviceManagerImpl::SetUserOperation with parameter 1143 int32_t ret = DeviceManager::GetInstance().GetUuidByNetworkId(packName, netWorkId, uuid); 1144 // 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED 1145 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1146 } 1147 1148 /** 1149 * @tc.name: RegisterDeviceManagerFaCallback_001 1150 * @tc.desc: 1. set packName not null 1151 * set action null 1152 * 2. MOCK IpcClientProxy SendRequest return ERR_DM_POINT_NULL 1153 * 3. call DeviceManagerImpl::SetUserOperation with parameter 1154 * 4. check ret is ERR_DM_INPUT_PARA_INVALID 1155 * deviceTypeId 1156 * @tc.type: FUNC 1157 * @tc.require: AR000GHSJK 1158 */ 1159 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0) 1160 { 1161 // 1. set packName null 1162 std::string packName = ""; 1163 // set callback null 1164 std::shared_ptr<DeviceManagerUiCallback> callback = nullptr; 1165 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1166 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback); 1167 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1168 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1169 } 1170 1171 /** 1172 * @tc.name: RegisterDeviceManagerFaCallback_002 1173 * @tc.desc: 1. set packName not null 1174 * set callback not null 1175 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1176 * 3. check ret is DM_OK 1177 * deviceTypeId 1178 * @tc.type: FUNC 1179 * @tc.require: AR000GHSJK 1180 */ 1181 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0) 1182 { 1183 // 1. set packName null 1184 std::string packName = "com.ohos.test"; 1185 // set callback null 1186 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>(); 1187 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1188 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1189 .Times(1).WillOnce(testing::Return(DM_OK)); 1190 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback); 1191 // 3. check ret is DM_OK 1192 ASSERT_EQ(ret, DM_OK); 1193 } 1194 1195 /** 1196 * @tc.name: RegisterDeviceManagerFaCallback_003 1197 * @tc.desc: 1. set packName not null 1198 * set callback not null 1199 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1200 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1201 * deviceTypeId 1202 * @tc.type: FUNC 1203 * @tc.require: AR000GHSJK 1204 */ 1205 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0) 1206 { 1207 // 1. set packName null 1208 std::string packName = "com.ohos.test"; 1209 // set callback null 1210 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr; 1211 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1212 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback); 1213 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1214 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1215 } 1216 1217 /** 1218 * @tc.name: RegisterDeviceManagerFaCallback_004 1219 * @tc.desc: 1. set packName not null 1220 * set callback not null 1221 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1222 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1223 * deviceTypeId 1224 * @tc.type: FUNC 1225 * @tc.require: AR000GHSJK 1226 */ 1227 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0) 1228 { 1229 // 1. set packName null 1230 std::string packName = ""; 1231 // set callback null 1232 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>(); 1233 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1234 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback); 1235 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1236 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1237 } 1238 1239 /** 1240 * @tc.name: RegisterDeviceManagerFaCallback_005 1241 * @tc.desc: 1. set packName not null 1242 * set callback not null 1243 * 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1244 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1245 * deviceTypeId 1246 * @tc.type: FUNC 1247 * @tc.require: AR000GHSJK 1248 */ 1249 HWTEST_F(DeviceManagerImplTest, RegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0) 1250 { 1251 // 1. set packName null 1252 std::string packName (""); 1253 // set callback null 1254 std::shared_ptr<DeviceManagerFaCallbackTest> callback = nullptr; 1255 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1256 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(packName, callback); 1257 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1258 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1259 } 1260 1261 /** 1262 * @tc.name: UnRegisterDeviceManagerFaCallback_001 1263 * @tc.desc: 1. set packName null 1264 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter 1265 * 3. check ret is ERR_DM_INPUT_PARA_INVALID 1266 * deviceTypeId 1267 * @tc.type: FUNC 1268 * @tc.require: AR000GHSJK 1269 */ 1270 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_001, testing::ext::TestSize.Level0) 1271 { 1272 // 1. set packName null 1273 std::string packName = ""; 1274 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1275 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName); 1276 // 3. check ret is ERR_DM_INPUT_PARA_INVALID 1277 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1278 } 1279 1280 /** 1281 * @tc.name: UnRegisterDeviceManagerFaCallback_002 1282 * @tc.desc: 1. set packName not null 1283 * 2. call DeviceManagerImpl::UnRegisterDeviceManagerFaCallback with parameter 1284 * 3. check ret is DM_OK 1285 * deviceTypeId 1286 * @tc.type: FUNC 1287 * @tc.require: AR000GHSJK 1288 */ 1289 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_002, testing::ext::TestSize.Level0) 1290 { 1291 // 1. set packName null 1292 std::string packName = "com.ohos.test"; 1293 // 2. call DeviceManagerImpl::RegisterDeviceManagerFaCallback with parameter 1294 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1295 .Times(1).WillOnce(testing::Return(DM_OK)); 1296 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(packName); 1297 // 3. check ret is DM_OK 1298 ASSERT_EQ(ret, DM_OK); 1299 } 1300 1301 /** 1302 * @tc.name: UnRegisterDeviceManagerFaCallback_003 1303 * @tc.desc: 1. set packName not null 1304 * set callback not null 1305 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter 1306 * 3. check ret is DM_OK 1307 * 4. set checkMap null 1308 * 5. Get checkMap from DeviceManagerNotify 1309 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter 1310 * 7. Get checkMap from pkgName 1311 * 8. check checkMap null 1312 * deviceTypeId 1313 * @tc.type: FUNC 1314 * @tc.require: AR000GHSJK 1315 */ 1316 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_003, testing::ext::TestSize.Level0) 1317 { 1318 // 1. set pkgName not null 1319 std::string pkgName = "com.ohos.test"; 1320 // set callback not null 1321 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>(); 1322 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter 1323 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1324 .Times(1).WillOnce(testing::Return(DM_OK)); 1325 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback); 1326 // 3. check ret is DM_OK 1327 ASSERT_EQ(ret, DM_OK); 1328 // 4. set checkMap null 1329 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr; 1330 // 5. Get checkMap from DeviceManagerNotify 1331 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1332 // 5. check checkMap not null 1333 ASSERT_NE(checkMap, nullptr); 1334 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter 1335 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1336 .Times(1).WillOnce(testing::Return(DM_OK)); 1337 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName); 1338 // 7. Get checkMap from pkgName 1339 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1340 // 8 check checkMap null 1341 ASSERT_EQ(checkMap, nullptr); 1342 } 1343 1344 /** 1345 * @tc.name: UnRegisterDeviceManagerFaCallback_004 1346 * @tc.desc: 1. set packName not null 1347 * set callback not null 1348 * 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter 1349 * 3. check ret is DM_OK 1350 * 4. set checkMap null 1351 * 5. Get checkMap from DeviceManagerNotify 1352 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter 1353 * 7. Get checkMap from pkgName 1354 * 8. check checkMap null 1355 * deviceTypeId 1356 * @tc.type: FUNC 1357 * @tc.require: AR000GHSJK 1358 */ 1359 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_004, testing::ext::TestSize.Level0) 1360 { 1361 // 1. set pkgName not null 1362 std::string pkgName = "com.ohos.test"; 1363 // set callback not null 1364 std::shared_ptr<DeviceManagerFaCallbackTest> callback = std::make_shared<DeviceManagerFaCallbackTest>(); 1365 // 2. call DeviceManager RegisterDeviceManagerFaCallback with parameter 1366 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1367 .Times(testing::AtLeast(1)).WillOnce(testing::Return(DM_OK)); 1368 int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback); 1369 // 3. check ret is DM_OK 1370 ASSERT_EQ(ret, DM_OK); 1371 // 4. set checkMap null 1372 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr; 1373 // 5. Get checkMap from DeviceManagerNotify 1374 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1375 // 5. check checkMap not null 1376 ASSERT_NE(checkMap, nullptr); 1377 // 6. set unRegisterPkgNamr different from pkgName 1378 std::string unRegisterPkgName = "com.ohos.test1"; 1379 // 7. call DeviceManager UnRegisterDeviceManagerFaCallback with unRegisterPkgName 1380 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName); 1381 // 7. Get checkMap from pkgName 1382 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1383 // 8 check checkMap not null 1384 ASSERT_NE(checkMap, nullptr); 1385 } 1386 1387 /** 1388 * @tc.name: UnRegisterDeviceManagerFaCallback_005 1389 * @tc.desc: 1. set packName not null 1390 * 2. Set checkMap null 1391 * 3. Get checkMap from DeviceManagerNotify 1392 * 4. check checkMap not null 1393 * 5. Set unRegisterPkgName is different from register pkgName 1394 * 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter 1395 * 7. Get checkMap from DeviceManagerNotify 1396 * 8. check checkMap not null 1397 * deviceTypeId 1398 * @tc.type: FUNC 1399 * @tc.require: AR000GHSJK 1400 */ 1401 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::ext::TestSize.Level0) 1402 { 1403 // 1. set pkgName not null 1404 std::string pkgName = "com.ohos.test"; 1405 // 2. Set checkMap null 1406 std::shared_ptr<DeviceManagerUiCallback> checkMap = nullptr; 1407 // 3. Get checkMap from DeviceManagerNotify 1408 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1409 // 4. check checkMap not null 1410 ASSERT_NE(checkMap, nullptr); 1411 // 5. Set unRegisterPkgName is different from register pkgName 1412 std::string unRegisterPkgName = "com.ohos.test1"; 1413 // 6. call DeviceManager UnRegisterDeviceManagerFaCallback with parameter 1414 DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(unRegisterPkgName); 1415 // 7. Get checkMap from DeviceManagerNotify 1416 checkMap = DeviceManagerNotify::GetInstance().dmUiCallback_[pkgName]; 1417 // 8. check checkMap not null 1418 ASSERT_NE(checkMap, nullptr); 1419 } 1420 1421 HWTEST_F(DeviceManagerImplTest, RegisterDevStatusCallback_201, testing::ext::TestSize.Level0) 1422 { 1423 std::string pkgName = "pkgName"; 1424 std::string extra = "extra"; 1425 std::shared_ptr<DeviceStatusCallback> callback = nullptr; 1426 int32_t ret = DeviceManager::GetInstance().RegisterDevStatusCallback(pkgName, extra, callback); 1427 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1428 } 1429 1430 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStatusCallback_201, testing::ext::TestSize.Level0) 1431 { 1432 std::string pkgName = ""; 1433 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(pkgName); 1434 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1435 1436 pkgName = "pkgName"; 1437 ret = DeviceManager::GetInstance().UnRegisterDevStatusCallback(pkgName); 1438 ASSERT_EQ(ret, DM_OK); 1439 } 1440 1441 HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_201, testing::ext::TestSize.Level0) 1442 { 1443 std::string pkgName = ""; 1444 uint64_t tokenId = 1; 1445 std::string filterOptions = "filterOptions"; 1446 std::shared_ptr<DiscoveryCallback> callback = nullptr; 1447 int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(pkgName, tokenId, filterOptions, callback); 1448 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1449 } 1450 1451 HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_201, testing::ext::TestSize.Level0) 1452 { 1453 uint64_t tokenId = 1; 1454 std::string pkgName = ""; 1455 int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(tokenId, pkgName); 1456 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1457 1458 pkgName = "pkgName"; 1459 ret = DeviceManager::GetInstance().StopDeviceDiscovery(tokenId, pkgName); 1460 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1461 } 1462 1463 HWTEST_F(DeviceManagerImplTest, StopAuthenticateDevice_201, testing::ext::TestSize.Level0) 1464 { 1465 std::string pkgName = ""; 1466 int32_t ret = DeviceManager::GetInstance().StopAuthenticateDevice(pkgName); 1467 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1468 1469 pkgName = "pkgName"; 1470 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1471 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1472 ret = DeviceManager::GetInstance().StopAuthenticateDevice(pkgName); 1473 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1474 } 1475 1476 HWTEST_F(DeviceManagerImplTest, VerifyAuthentication_201, testing::ext::TestSize.Level0) 1477 { 1478 std::string pkgName = ""; 1479 std::string authPara = "authPara"; 1480 std::shared_ptr<VerifyAuthCallback> callback = nullptr; 1481 int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(pkgName, authPara, callback); 1482 ASSERT_EQ(ret, DM_OK); 1483 } 1484 1485 HWTEST_F(DeviceManagerImplTest, GetFaParam_201, testing::ext::TestSize.Level0) 1486 { 1487 std::string pkgName = ""; 1488 DmAuthParam dmFaParam; 1489 int32_t ret = DeviceManager::GetInstance().GetFaParam(pkgName, dmFaParam); 1490 ASSERT_EQ(ret, DM_OK); 1491 } 1492 1493 HWTEST_F(DeviceManagerImplTest, RegisterDevStateCallback_201, testing::ext::TestSize.Level0) 1494 { 1495 std::string pkgName = ""; 1496 std::string extra = ""; 1497 int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(pkgName, extra); 1498 ASSERT_EQ(ret, DM_OK); 1499 } 1500 1501 HWTEST_F(DeviceManagerImplTest, UnRegisterDevStateCallback_201, testing::ext::TestSize.Level0) 1502 { 1503 std::string pkgName = ""; 1504 std::string extra = ""; 1505 int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(pkgName, extra); 1506 ASSERT_EQ(ret, DM_OK); 1507 } 1508 1509 HWTEST_F(DeviceManagerImplTest, RegisterUiStateCallback_201, testing::ext::TestSize.Level0) 1510 { 1511 std::string pkgName = ""; 1512 int32_t ret = DeviceManagerImpl::GetInstance().RegisterUiStateCallback(pkgName); 1513 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1514 } 1515 1516 HWTEST_F(DeviceManagerImplTest, UnRegisterUiStateCallback_201, testing::ext::TestSize.Level0) 1517 { 1518 std::string pkgName = ""; 1519 int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterUiStateCallback(pkgName); 1520 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1521 } 1522 1523 HWTEST_F(DeviceManagerImplTest, RequestCredential_201, testing::ext::TestSize.Level0) 1524 { 1525 std::string pkgName = "pkgName"; 1526 std::string reqJsonStr = "reqJsonStr"; 1527 std::string returnJsonStr = ""; 1528 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1529 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1530 int32_t ret = DeviceManager::GetInstance().RequestCredential(pkgName, reqJsonStr, returnJsonStr); 1531 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1532 } 1533 1534 HWTEST_F(DeviceManagerImplTest, ImportCredential_201, testing::ext::TestSize.Level0) 1535 { 1536 std::string pkgName = "pkgName"; 1537 std::string credentialInfo = "credentialInfo"; 1538 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1539 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1540 int32_t ret = DeviceManager::GetInstance().ImportCredential(pkgName, credentialInfo); 1541 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1542 } 1543 1544 HWTEST_F(DeviceManagerImplTest, DeleteCredential_201, testing::ext::TestSize.Level0) 1545 { 1546 std::string pkgName = "pkgName"; 1547 std::string deleteInfo = "deleteInfo"; 1548 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1549 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1550 int32_t ret = DeviceManager::GetInstance().DeleteCredential(pkgName, deleteInfo); 1551 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1552 } 1553 1554 HWTEST_F(DeviceManagerImplTest, RegisterCredentialCallback_201, testing::ext::TestSize.Level0) 1555 { 1556 std::string pkgName = ""; 1557 std::shared_ptr<CredentialCallback> callback = std::make_shared<CredentialCallbackTest>(); 1558 int32_t ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback); 1559 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1560 1561 pkgName = "pkgName"; 1562 callback = nullptr; 1563 ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback); 1564 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1565 1566 pkgName = "pkgName"; 1567 callback = std::make_shared<CredentialCallbackTest>(); 1568 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1569 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1570 ret = DeviceManager::GetInstance().RegisterCredentialCallback(pkgName, callback); 1571 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1572 } 1573 1574 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialCallback_201, testing::ext::TestSize.Level0) 1575 { 1576 std::string pkgName = ""; 1577 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName); 1578 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1579 1580 pkgName = "pkgName"; 1581 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1582 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1583 ret = DeviceManager::GetInstance().UnRegisterCredentialCallback(pkgName); 1584 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1585 } 1586 1587 HWTEST_F(DeviceManagerImplTest, NotifyEvent_201, testing::ext::TestSize.Level0) 1588 { 1589 std::string pkgName = ""; 1590 int32_t eventId = 1; 1591 std::string event = ""; 1592 int32_t ret = DeviceManager::GetInstance().NotifyEvent(pkgName, eventId, event); 1593 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1594 1595 pkgName = "pkgName"; 1596 eventId = DM_NOTIFY_EVENT_START; 1597 ret = DeviceManager::GetInstance().NotifyEvent(pkgName, eventId, event); 1598 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1599 1600 eventId = DM_NOTIFY_EVENT_ONDEVICEREADY; 1601 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1602 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1603 ret = DeviceManager::GetInstance().NotifyEvent(pkgName, eventId, event); 1604 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1605 } 1606 1607 HWTEST_F(DeviceManagerImplTest, OnDmServiceDied_201, testing::ext::TestSize.Level0) 1608 { 1609 int32_t ret = DeviceManagerImpl::GetInstance().OnDmServiceDied(); 1610 ASSERT_EQ(ret, DM_OK); 1611 } 1612 1613 HWTEST_F(DeviceManagerImplTest, CheckAPIAccessPermission_201, testing::ext::TestSize.Level0) 1614 { 1615 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1616 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1617 int32_t ret = DeviceManager::GetInstance().CheckAPIAccessPermission(); 1618 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1619 } 1620 1621 HWTEST_F(DeviceManagerImplTest, CheckNewAPIAccessPermission_201, testing::ext::TestSize.Level0) 1622 { 1623 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1624 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1625 int32_t ret = DeviceManager::GetInstance().CheckNewAPIAccessPermission(); 1626 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1627 } 1628 1629 HWTEST_F(DeviceManagerImplTest, UnBindDevice_201, testing::ext::TestSize.Level0) 1630 { 1631 std::string pkgName = "pkgName_201"; 1632 std::string deviceId = "deviceId201"; 1633 std::string extra = "extra"; 1634 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1635 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1636 int32_t ret = DeviceManager::GetInstance().UnBindDevice(pkgName, deviceId, extra); 1637 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1638 } 1639 1640 HWTEST_F(DeviceManagerImplTest, ImportAuthCode_201, testing::ext::TestSize.Level0) 1641 { 1642 std::string pkgName = "pkgName_201"; 1643 std::string authCode = "asdsedwe"; 1644 int32_t ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1645 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1646 1647 authCode = "123456"; 1648 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1649 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1650 ret = DeviceManager::GetInstance().ImportAuthCode(pkgName, authCode); 1651 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1652 } 1653 1654 HWTEST_F(DeviceManagerImplTest, StartAdvertising_201, testing::ext::TestSize.Level0) 1655 { 1656 std::string pkgName = ""; 1657 std::map<std::string, std::string> advertiseParam; 1658 std::shared_ptr<PublishCallback> callback = nullptr; 1659 int32_t ret = DeviceManager::GetInstance().StartAdvertising(pkgName, advertiseParam, callback); 1660 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1661 } 1662 1663 HWTEST_F(DeviceManagerImplTest, CheckAccessToTarget_201, testing::ext::TestSize.Level0) 1664 { 1665 uint64_t tokenId = 1; 1666 std::string targetId = ""; 1667 int32_t ret = DeviceManager::GetInstance().CheckAccessToTarget(tokenId, targetId); 1668 ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD); 1669 } 1670 1671 HWTEST_F(DeviceManagerImplTest, AddDiscoveryCallback_201, testing::ext::TestSize.Level0) 1672 { 1673 std::string pkgName = "pkgName"; 1674 std::map<std::string, std::string> discoverParam; 1675 std::shared_ptr<DiscoveryCallback> callback = nullptr; 1676 int32_t ret = DeviceManagerImpl::GetInstance().AddDiscoveryCallback(pkgName, discoverParam, callback); 1677 ASSERT_EQ(ret, DM_OK); 1678 } 1679 1680 HWTEST_F(DeviceManagerImplTest, SetDnPolicy_201, testing::ext::TestSize.Level0) 1681 { 1682 std::string pkgName = ""; 1683 std::map<std::string, std::string> policy; 1684 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(pkgName, policy); 1685 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1686 } 1687 1688 HWTEST_F(DeviceManagerImplTest, RegDevTrustChangeCallback_201, testing::ext::TestSize.Level0) 1689 { 1690 std::string pkgName = ""; 1691 std::shared_ptr<DevTrustChangeCallback> callback = nullptr; 1692 int32_t ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback); 1693 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1694 1695 pkgName = "pkgName"; 1696 callback = std::make_shared<DevTrustChangeCallbackTest>(); 1697 ret = DeviceManager::GetInstance().RegDevTrustChangeCallback(pkgName, callback); 1698 ASSERT_EQ(ret, DM_OK); 1699 } 1700 1701 HWTEST_F(DeviceManagerImplTest, RegisterDeviceScreenStatusCallback_201, testing::ext::TestSize.Level0) 1702 { 1703 std::string pkgName = ""; 1704 std::shared_ptr<DeviceScreenStatusCallback> callback = nullptr; 1705 int32_t ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(pkgName, callback); 1706 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1707 1708 pkgName = "pkgName"; 1709 callback = std::make_shared<DeviceScreenStatusCallbackTest>(); 1710 ret = DeviceManager::GetInstance().RegisterDeviceScreenStatusCallback(pkgName, callback); 1711 ASSERT_EQ(ret, DM_OK); 1712 } 1713 1714 HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceScreenStatusCallback_201, testing::ext::TestSize.Level0) 1715 { 1716 std::string pkgName = ""; 1717 int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(pkgName); 1718 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1719 1720 pkgName = "pkgName"; 1721 ret = DeviceManager::GetInstance().UnRegisterDeviceScreenStatusCallback(pkgName); 1722 ASSERT_EQ(ret, DM_OK); 1723 } 1724 1725 HWTEST_F(DeviceManagerImplTest, GetNetworkIdByUdid_201, testing::ext::TestSize.Level0) 1726 { 1727 std::string pkgName = ""; 1728 std::string udid = ""; 1729 std::string networkId = ""; 1730 int32_t ret = DeviceManager::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId); 1731 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1732 } 1733 1734 HWTEST_F(DeviceManagerImplTest, RegisterCredentialAuthStatusCallback_201, testing::ext::TestSize.Level0) 1735 { 1736 std::string pkgName = ""; 1737 std::shared_ptr<CredentialAuthStatusCallback> callback = nullptr; 1738 int32_t ret = DeviceManager::GetInstance().RegisterCredentialAuthStatusCallback(pkgName, callback); 1739 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1740 } 1741 1742 HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_201, testing::ext::TestSize.Level0) 1743 { 1744 std::string pkgName = ""; 1745 int32_t ret = DeviceManager::GetInstance().UnRegisterCredentialAuthStatusCallback(pkgName); 1746 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1747 1748 DmCommonNotifyEvent dmCommonNotifyEvent = DmCommonNotifyEvent::REG_DEVICE_SCREEN_STATE; 1749 pkgName = ""; 1750 DeviceManagerImpl::GetInstance().SyncCallbackToService(dmCommonNotifyEvent, pkgName); 1751 1752 pkgName = "pkgName"; 1753 dmCommonNotifyEvent = DmCommonNotifyEvent::MIN; 1754 DeviceManagerImpl::GetInstance().SyncCallbackToService(dmCommonNotifyEvent, pkgName); 1755 1756 dmCommonNotifyEvent = DmCommonNotifyEvent::REG_DEVICE_SCREEN_STATE; 1757 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1758 .Times(1).WillOnce(testing::Return(DM_OK)); 1759 DeviceManagerImpl::GetInstance().SyncCallbackToService(dmCommonNotifyEvent, pkgName); 1760 } 1761 1762 HWTEST_F(DeviceManagerImplTest, RegisterSinkBindCallback_201, testing::ext::TestSize.Level0) 1763 { 1764 std::string pkgName = ""; 1765 std::shared_ptr<BindTargetCallback> callback = nullptr; 1766 int32_t ret = DeviceManager::GetInstance().RegisterSinkBindCallback(pkgName, callback); 1767 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1768 1769 pkgName = "pkgName"; 1770 callback = std::make_shared<BindTargetCallbackTest>(); 1771 ret = DeviceManager::GetInstance().RegisterSinkBindCallback(pkgName, callback); 1772 ASSERT_EQ(ret, DM_OK); 1773 } 1774 1775 HWTEST_F(DeviceManagerImplTest, UnRegisterSinkBindCallback_201, testing::ext::TestSize.Level0) 1776 { 1777 std::string pkgName = ""; 1778 int32_t ret = DeviceManager::GetInstance().UnRegisterSinkBindCallback(pkgName); 1779 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 1780 1781 pkgName = "pkgName"; 1782 ret = DeviceManager::GetInstance().UnRegisterSinkBindCallback(pkgName); 1783 ASSERT_EQ(ret, DM_OK); 1784 } 1785 1786 HWTEST_F(DeviceManagerImplTest, GetDeviceProfileInfoList_201, testing::ext::TestSize.Level0) 1787 { 1788 std::string pkgName = "pkgName"; 1789 DmDeviceProfileInfoFilterOptions filterOptions; 1790 std::shared_ptr<GetDeviceProfileInfoListCallback> callback = 1791 std::make_shared<GetDeviceProfileInfoListCallbackTest>(); 1792 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceProfileInfoListCallback(_, _)) 1793 .WillOnce(Return(ERR_DM_FAILED)); 1794 int32_t ret = DeviceManager::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions, callback); 1795 ASSERT_EQ(ret, ERR_DM_FAILED); 1796 1797 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceProfileInfoListCallback(_, _)) 1798 .WillOnce(Return(DM_OK)); 1799 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1800 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1801 ret = DeviceManager::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions, callback); 1802 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1803 } 1804 1805 HWTEST_F(DeviceManagerImplTest, GetDeviceProfileInfoList_202, testing::ext::TestSize.Level0) 1806 { 1807 std::string pkgName = "pkgName"; 1808 DmDeviceProfileInfoFilterOptions filterOptions; 1809 std::shared_ptr<GetDeviceProfileInfoListCallback> callback = 1810 std::make_shared<GetDeviceProfileInfoListCallbackTest>(); 1811 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceProfileInfoListCallback(_, _)) 1812 .WillOnce(Return(DM_OK)); 1813 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1814 .Times(1).WillOnce(testing::Return(DM_OK)); 1815 int32_t ret = DeviceManager::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions, callback); 1816 ASSERT_EQ(ret, DM_OK); 1817 } 1818 1819 HWTEST_F(DeviceManagerImplTest, GetDeviceIconInfo_201, testing::ext::TestSize.Level0) 1820 { 1821 std::string pkgName = "pkgName"; 1822 DmDeviceIconInfoFilterOptions filterOptions; 1823 std::shared_ptr<GetDeviceIconInfoCallback> callback = std::make_shared<GetDeviceIconInfoCallbackTest>(); 1824 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceIconInfoCallback(_, _, _)) 1825 .WillOnce(Return(ERR_DM_FAILED)); 1826 int32_t ret = DeviceManager::GetInstance().GetDeviceIconInfo(pkgName, filterOptions, callback); 1827 ASSERT_EQ(ret, ERR_DM_FAILED); 1828 1829 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceIconInfoCallback(_, _, _)) 1830 .WillOnce(Return(DM_OK)); 1831 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1832 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1833 ret = DeviceManager::GetInstance().GetDeviceIconInfo(pkgName, filterOptions, callback); 1834 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1835 } 1836 1837 HWTEST_F(DeviceManagerImplTest, GetDeviceIconInfo_202, testing::ext::TestSize.Level0) 1838 { 1839 std::string pkgName = "pkgName"; 1840 DmDeviceIconInfoFilterOptions filterOptions; 1841 std::shared_ptr<GetDeviceIconInfoCallback> callback = std::make_shared<GetDeviceIconInfoCallbackTest>(); 1842 EXPECT_CALL(*deviceManagerNotifyMock_, RegisterGetDeviceIconInfoCallback(_, _, _)) 1843 .WillOnce(Return(DM_OK)); 1844 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1845 .Times(1).WillOnce(testing::Return(DM_OK)); 1846 int32_t ret = DeviceManager::GetInstance().GetDeviceIconInfo(pkgName, filterOptions, callback); 1847 ASSERT_EQ(ret, DM_OK); 1848 } 1849 1850 HWTEST_F(DeviceManagerImplTest, StopAuthenticateDevice_202, testing::ext::TestSize.Level0) 1851 { 1852 std::string pkgName = "pkgName"; 1853 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1854 .Times(1).WillOnce(testing::Return(DM_OK)); 1855 int32_t ret = DeviceManager::GetInstance().StopAuthenticateDevice(pkgName); 1856 ASSERT_EQ(ret, DM_OK); 1857 } 1858 1859 HWTEST_F(DeviceManagerImplTest, UnBindDevice_202, testing::ext::TestSize.Level0) 1860 { 1861 std::string pkgName = "pkgName_201"; 1862 std::string deviceId = "deviceId201"; 1863 std::string extra = "extra"; 1864 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1865 .Times(1).WillOnce(testing::Return(DM_OK)); 1866 int32_t ret = DeviceManager::GetInstance().UnBindDevice(pkgName, deviceId, extra); 1867 ASSERT_EQ(ret, DM_OK); 1868 } 1869 1870 HWTEST_F(DeviceManagerImplTest, UnBindDevice_203, testing::ext::TestSize.Level0) 1871 { 1872 std::string pkgName = "pkgName_201"; 1873 std::string deviceId = "deviceId201"; 1874 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1875 .Times(1).WillOnce(testing::Return(DM_OK)); 1876 int32_t ret = DeviceManager::GetInstance().UnBindDevice(pkgName, deviceId); 1877 ASSERT_EQ(ret, DM_OK); 1878 } 1879 1880 HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_201, testing::ext::TestSize.Level0) 1881 { 1882 std::string pkgName = "pkgName_2036"; 1883 std::map<std::string, std::string> discoverParam; 1884 std::map<std::string, std::string> filterOptions; 1885 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 1886 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1887 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1888 int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, 1889 callback); 1890 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1891 } 1892 1893 HWTEST_F(DeviceManagerImplTest, RegisterDiscoveryCallback_202, testing::ext::TestSize.Level0) 1894 { 1895 std::string pkgName = "pkgName_2053"; 1896 std::map<std::string, std::string> discoverParam; 1897 std::map<std::string, std::string> filterOptions; 1898 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>(); 1899 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1900 .Times(1).WillOnce(testing::Return(DM_OK)); 1901 int32_t ret = DeviceManager::GetInstance().RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions, 1902 callback); 1903 ASSERT_EQ(ret, DM_OK); 1904 } 1905 1906 HWTEST_F(DeviceManagerImplTest, UnRegisterDiscoveryCallback_201, testing::ext::TestSize.Level0) 1907 { 1908 std::string pkgName = "pkgName"; 1909 std::string pkgNameTemp = ComposeStr(pkgName, 0); 1910 DeviceManagerImpl::GetInstance().pkgName2SubIdMap_[pkgNameTemp] = 10; 1911 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1912 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 1913 int32_t ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName); 1914 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1915 } 1916 1917 HWTEST_F(DeviceManagerImplTest, UnRegisterDiscoveryCallback_202, testing::ext::TestSize.Level0) 1918 { 1919 std::string pkgName = "pkgName"; 1920 std::string pkgNameTemp = ComposeStr(pkgName, 0); 1921 DeviceManagerImpl::GetInstance().pkgName2SubIdMap_[pkgNameTemp] = 10; 1922 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1923 .Times(1).WillOnce(testing::Return(DM_OK)); 1924 int32_t ret = DeviceManager::GetInstance().UnRegisterDiscoveryCallback(pkgName); 1925 ASSERT_EQ(ret, DM_OK); 1926 } 1927 1928 HWTEST_F(DeviceManagerImplTest, StopAdvertising_201, testing::ext::TestSize.Level0) 1929 { 1930 std::string packName = "pkgName"; 1931 std::map<std::string, std::string> advertiseParam; 1932 advertiseParam[PARAM_KEY_PUBLISH_ID] = "10"; 1933 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1934 .Times(1).WillOnce(testing::Return(ERR_DM_INPUT_PARA_INVALID)); 1935 int32_t ret = DeviceManager::GetInstance().StopAdvertising(packName, advertiseParam); 1936 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1937 } 1938 1939 HWTEST_F(DeviceManagerImplTest, StopAdvertising_202, testing::ext::TestSize.Level0) 1940 { 1941 std::string packName = "pkgName"; 1942 std::map<std::string, std::string> advertiseParam; 1943 advertiseParam[PARAM_KEY_PUBLISH_ID] = "10"; 1944 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1945 .Times(1).WillOnce(testing::Return(DM_OK)); 1946 int32_t ret = DeviceManager::GetInstance().StopAdvertising(packName, advertiseParam); 1947 ASSERT_EQ(ret, DM_OK); 1948 } 1949 1950 HWTEST_F(DeviceManagerImplTest, CheckIsSameAccount_201, testing::ext::TestSize.Level0) 1951 { 1952 DmAccessCaller caller; 1953 DmAccessCallee callee; 1954 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1955 .Times(1).WillOnce(testing::Return(ERR_DM_INPUT_PARA_INVALID)); 1956 bool ret = DeviceManager::GetInstance().CheckIsSameAccount(caller, callee); 1957 ASSERT_FALSE(ret); 1958 } 1959 1960 HWTEST_F(DeviceManagerImplTest, CheckIsSameAccount_202, testing::ext::TestSize.Level0) 1961 { 1962 DmAccessCaller caller; 1963 DmAccessCallee callee; 1964 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1965 .Times(1).WillOnce(testing::Return(DM_OK)); 1966 bool ret = DeviceManager::GetInstance().CheckIsSameAccount(caller, callee); 1967 ASSERT_FALSE(ret); 1968 } 1969 1970 HWTEST_F(DeviceManagerImplTest, SetDnPolicy_202, testing::ext::TestSize.Level0) 1971 { 1972 std::string pkgName = "pkgName_202"; 1973 std::map<std::string, std::string> policy; 1974 policy["policy01"] = "101"; 1975 policy["policy02"] = "102"; 1976 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1977 .Times(1).WillOnce(testing::Return(ERR_DM_INPUT_PARA_INVALID)); 1978 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(pkgName, policy); 1979 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 1980 } 1981 1982 HWTEST_F(DeviceManagerImplTest, SetDnPolicy_203, testing::ext::TestSize.Level0) 1983 { 1984 std::string pkgName = "pkgName_202"; 1985 std::map<std::string, std::string> policy; 1986 policy["policy01"] = "101"; 1987 policy["policy02"] = "102"; 1988 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 1989 .Times(1).WillOnce(testing::Return(DM_OK)); 1990 int32_t ret = DeviceManager::GetInstance().SetDnPolicy(pkgName, policy); 1991 ASSERT_EQ(ret, DM_OK); 1992 } 1993 1994 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_201, testing::ext::TestSize.Level0) 1995 { 1996 std::string pkgName = ""; 1997 std::string networkId = ""; 1998 int32_t screenStatus = 1; 1999 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2000 ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); 2001 } 2002 2003 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_202, testing::ext::TestSize.Level0) 2004 { 2005 std::string pkgName = "pkgName"; 2006 std::string networkId = "networkId"; 2007 int32_t screenStatus = 1; 2008 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2009 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 2010 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2011 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2012 } 2013 2014 HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_203, testing::ext::TestSize.Level0) 2015 { 2016 std::string pkgName = "pkgName"; 2017 std::string networkId = "networkId"; 2018 int32_t screenStatus = 1; 2019 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2020 .Times(1).WillOnce(testing::Return(DM_OK)); 2021 int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus); 2022 ASSERT_EQ(ret, DM_OK); 2023 } 2024 2025 HWTEST_F(DeviceManagerImplTest, GetNetworkIdByUdid_202, testing::ext::TestSize.Level0) 2026 { 2027 std::string pkgName = "pkgName"; 2028 std::string udid = "udid"; 2029 std::string networkId = "networkId"; 2030 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2031 .Times(testing::AtLeast(1)).WillOnce(testing::Return(DM_OK)); 2032 int32_t ret = DeviceManager::GetInstance().GetNetworkIdByUdid(pkgName, udid, networkId); 2033 ASSERT_EQ(ret, DM_OK); 2034 2035 std::map<DmCommonNotifyEvent, std::set<std::string>> callbackMap; 2036 DeviceManagerImpl::GetInstance().SyncCallbacksToService(callbackMap); 2037 std::set<std::string> strSet; 2038 callbackMap[DmCommonNotifyEvent::REG_DEVICE_STATE] = strSet; 2039 strSet.insert("pkgName02"); 2040 callbackMap[DmCommonNotifyEvent::REG_DEVICE_SCREEN_STATE] = strSet; 2041 DeviceManagerImpl::GetInstance().SyncCallbacksToService(callbackMap); 2042 } 2043 2044 HWTEST_F(DeviceManagerImplTest, PutDeviceProfileInfoList_201, testing::ext::TestSize.Level0) 2045 { 2046 std::string pkgName = "pkgName"; 2047 std::vector<OHOS::DistributedHardware::DmDeviceProfileInfo> deviceProfileInfoList; 2048 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2049 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 2050 int32_t ret = DeviceManager::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); 2051 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2052 } 2053 2054 HWTEST_F(DeviceManagerImplTest, PutDeviceProfileInfoList_202, testing::ext::TestSize.Level0) 2055 { 2056 std::string pkgName = "pkgName"; 2057 std::vector<OHOS::DistributedHardware::DmDeviceProfileInfo> deviceProfileInfoList; 2058 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2059 .Times(1).WillOnce(testing::Return(DM_OK)); 2060 int32_t ret = DeviceManager::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); 2061 ASSERT_EQ(ret, DM_OK); 2062 } 2063 2064 HWTEST_F(DeviceManagerImplTest, GetLocalDisplayDeviceName_201, testing::ext::TestSize.Level0) 2065 { 2066 std::string pkgName = "pkgName"; 2067 int32_t maxNameLength = 1; 2068 std::string displayName = "displayName"; 2069 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2070 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 2071 int32_t ret = DeviceManager::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); 2072 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2073 2074 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2075 .Times(1).WillOnce(testing::Return(DM_OK)); 2076 ret = DeviceManager::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); 2077 ASSERT_EQ(ret, DM_OK); 2078 } 2079 2080 HWTEST_F(DeviceManagerImplTest, GetLocalDeviceName_201, testing::ext::TestSize.Level0) 2081 { 2082 std::string deviceName = "deviceName"; 2083 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2084 .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); 2085 int32_t ret = DeviceManager::GetInstance().GetLocalDeviceName(deviceName); 2086 ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); 2087 2088 EXPECT_CALL(*ipcClientProxyMock_, SendRequest(testing::_, testing::_, testing::_)) 2089 .Times(1).WillOnce(testing::Return(DM_OK)); 2090 ret = DeviceManager::GetInstance().GetLocalDeviceName(deviceName); 2091 ASSERT_EQ(ret, DM_OK); 2092 } 2093 } // namespace 2094 } // namespace DistributedHardware 2095 } // namespace OHOS 2096