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