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_notify.h" 17#include "device_manager_notify.h" 18#include "dm_device_info.h" 19#include "ipc_remote_broker.h" 20#include "iremote_object.h" 21#include "iservice_registry.h" 22#include "system_ability_definition.h" 23#include "ipc_client_manager.h" 24#include "ipc_set_useroperation_req.h" 25#include "ipc_rsp.h" 26#include "ipc_def.h" 27 28#include <unistd.h> 29 30namespace OHOS { 31namespace DistributedHardware { 32void DeviceManagerNotifyTest::SetUp() {} 33 34void DeviceManagerNotifyTest::TearDown() {} 35 36void DeviceManagerNotifyTest::SetUpTestCase() {} 37 38void DeviceManagerNotifyTest::TearDownTestCase() {} 39namespace { 40/** 41 * @tc.name: RegisterDeathRecipientCallback_001 42 * @tc.desc: 1. set pkgName not null 43 * set dmInitCallback not null 44 * 2. set checkMap null 45 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 46 * 4. Get checkMap from DeviceManagerNotify 47 * 5. check checkMap not null 48 * deviceTypeId 49 * @tc.type: FUNC 50 * @tc.require: AR000GHSJK 51 */ 52HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_001, testing::ext::TestSize.Level0) 53{ 54 // 1. set pkgName not null 55 std::string pkgName = "com.ohos.test"; 56 // set dmInitCallback not null 57 int count = 0; 58 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 59 // 2. set checkMap null 60 std::shared_ptr<DmInitCallback> checkMap = nullptr; 61 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 62 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 63 // 4. Get checkMap from DeviceManagerNotify 64 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 65 // 5. check checkMap not null 66 ASSERT_NE(checkMap, nullptr); 67} 68 69/** 70 * @tc.name: RegisterDeathRecipientCallback_002 71 * @tc.desc: 1. set pkgName not null 72 * set dmInitCallback null 73 * 2. set checkMap null 74 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 75 * 4. Get checkMap from DeviceManagerNotify 76 * 5. check checkMap not null 77 * deviceTypeId 78 * @tc.type: FUNC 79 * @tc.require: AR000GHSJK 80 */ 81HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_002, testing::ext::TestSize.Level0) 82{ 83 // 1. set pkgName not null 84 std::string pkgName = "com.ohos.test"; 85 // set dmInitCallback not null 86 int count = 0; 87 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 88 // 2. set checkMap not null 89 std::shared_ptr<DmInitCallback> checkMap = nullptr; 90 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 91 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 92 // 4. Get checkMap from DeviceManagerNotify 93 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 94 // 5. check checkMap null 95 ASSERT_NE(checkMap, nullptr); 96} 97 98/** 99 * @tc.name: RegisterDeathRecipientCallback_003 100 * @tc.desc: 1. set pkgName com.ohos.test 101 * set dmInitCallback not null 102 * 2. set checkMap null 103 * 3. set testpkcName com.ohos.test1 104 * 4. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 105 * 5. Get checkMap from DeviceManagerNotify with testpkcName 106 * 6. check checkMap null 107 * deviceTypeId 108 * @tc.type: FUNC 109 * @tc.require: AR000GHSJK 110 */ 111HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_003, testing::ext::TestSize.Level0) 112{ 113 // 1. set pkgName com.ohos.test 114 std::string pkgName = "com.ohos.test"; 115 // set dmInitCallback not null 116 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr; 117 // 2. set checkMap null 118 std::shared_ptr<DmInitCallback> checkMap = nullptr; 119 // 3. set testpkcName com.ohos.test1 120 std::string testPkgName = "com.ohos.test1"; 121 // 4. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 122 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 123 // 5. Get checkMap from DeviceManagerNotify with testpkcName 124 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[testPkgName]; 125 // 6. check checkMap not null 126 ASSERT_EQ(checkMap, nullptr); 127} 128 129/** 130 * @tc.name: RegisterDeathRecipientCallback_004 131 * @tc.desc: 1. set pkgName not null 132 * set dmInitCallback not null 133 * 2. set checkMap null 134 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 135 * 4. Get checkMap from DeviceManagerNotify 136 * 5. check checkMap not null 137 * 6. call checkMap OnRemoteDied 138 * 7. check count is 1 139 * deviceTypeId 140 * @tc.type: FUNC 141 * @tc.require: AR000GHSJK 142 */ 143HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_004, testing::ext::TestSize.Level0) 144{ 145 // 1. set pkgName not null 146 std::string pkgName = "com.ohos.test"; 147 // set dmInitCallback not null 148 int count = 0; 149 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 150 // 2. set checkMap null 151 std::shared_ptr<DmInitCallback> checkMap = nullptr; 152 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 153 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 154 // 4. Get checkMap from DeviceManagerNotify 155 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 156 // 5. check checkMap not null 157 ASSERT_NE(checkMap, nullptr); 158 // 6. call checkMap OnRemoteDied 159 if (checkMap != nullptr) { 160 checkMap->OnRemoteDied(); 161 } 162 // 7. check count is 1 163 ASSERT_EQ(count, 1); 164} 165 166/** 167 * @tc.name: RegisterDeathRecipientCallback_005 168 * @tc.desc: 1. set pkgName not null 169 * set dmInitCallback not null 170 * 2. set checkMap null 171 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 172 * 4. Get checkMap from DeviceManagerNotify 173 * 5. check checkMap not null 174 * 6. call checkMap OnRemoteDied 175 * 7. check count is 1 176 * deviceTypeId 177 * @tc.type: FUNC 178 * @tc.require: AR000GHSJK 179 */ 180HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_005, testing::ext::TestSize.Level0) 181{ 182 // 1. set pkgName not null 183 std::string pkgName = "com.ohos.test"; 184 // set dmInitCallback not null 185 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr; 186 // 2. set checkMap null 187 std::shared_ptr<DmInitCallback> checkMap = nullptr; 188 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 189 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 190 // 4. Get checkMap from DeviceManagerNotify 191 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 192 // 5. check checkMap not null 193 ASSERT_NE(checkMap, nullptr); 194} 195 196/** 197 * @tc.name: RegisterDeathRecipientCallback_005 198 * @tc.type: FUNC 199 */ 200HWTEST_F(DeviceManagerNotifyTest, RegisterDeathRecipientCallback_006, testing::ext::TestSize.Level0) 201{ 202 std::string pkgName; 203 std::shared_ptr<DmInitCallback> dmInitCallback = nullptr; 204 std::shared_ptr<DmInitCallback> checkMap = nullptr; 205 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 206 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 207 ASSERT_EQ(checkMap, nullptr); 208} 209 210/** 211 * @tc.name: UnRegisterDeathRecipientCallback_001 212 * @tc.desc: 1. set pkgName not null 213 * set dmInitCallback not null 214 * 2. set checkMap null 215 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 216 * 4. Get checkMap from DeviceManagerNotify 217 * 5. check checkMap not null 218 * 6. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with parameter 219 * 7. Get checkMap from DeviceManagerNotify 220 * 8. check checkMap null 221 * deviceTypeId 222 * @tc.type: FUNC 223 * @tc.require: AR000GHSJK 224 */ 225HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_001, testing::ext::TestSize.Level0) 226{ 227 // 1. set pkgName not null 228 std::string pkgName = "com.ohos.test"; 229 // set dmInitCallback not null 230 int count = 0; 231 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 232 // 2. set checkMap null 233 std::shared_ptr<DmInitCallback> checkMap = nullptr; 234 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 235 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 236 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 237 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 238 // 5. check checkMap not null 239 ASSERT_NE(checkMap, nullptr); 240 // 6. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with parameter 241 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(pkgName); 242 // 7. Get checkMap from DeviceManagerNotify 243 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 244 // 8 check checkMap null 245 ASSERT_EQ(checkMap, nullptr); 246} 247 248/** 249 * @tc.name: UnRegisterDeathRecipientCallback_002 250 * @tc.desc: 1. set pkgName com.ohos.test 251 * set dmInitCallback not null 252 * 2. set checkMap null 253 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 254 * 4. Get checkMap from DeviceManagerNotify 255 * 5. check checkMap not null 256 * 6. set testpkcName com.ohos.test1 257 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 258 * 8. Get checkMap from DeviceManagerNotify 259 * 9. check checkMap not null 260 * deviceTypeId 261 * @tc.type: FUNC 262 * @tc.require: AR000GHSJK 263 */ 264HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_002, testing::ext::TestSize.Level0) 265{ 266 // 1. set pkgName not null 267 std::string pkgName = "com.ohos.test"; 268 // set dmInitCallback not null 269 int count = 0; 270 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 271 // 2. set checkMap null 272 std::shared_ptr<DmInitCallback> checkMap = nullptr; 273 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 274 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 275 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 276 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 277 // 5. check checkMap not null 278 ASSERT_NE(checkMap, nullptr); 279 // 6. set testpkcName com.ohos.test1 280 std::string testPkgName = "com.ohos.test1"; 281 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 282 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName); 283 // 8. Get checkMap from DeviceManagerNotify 284 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 285 // 8 check checkMap not null 286 ASSERT_NE(checkMap, nullptr); 287} 288 289/** 290 * @tc.name: UnRegisterDeathRecipientCallback_003 291 * @tc.desc: 1. set pkgName com.ohos.test 292 * set dmInitCallback not null 293 * 2. set checkMap null 294 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 295 * 4. Get checkMap from DeviceManagerNotify 296 * 5. check checkMap not null 297 * 6. set testpkcName com.ohos.test1 298 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 299 * 8. Get checkMap from DeviceManagerNotify 300 * 9. call checkMap OnRemoteDied 301 * 10. check count is 1 302 * deviceTypeId 303 * @tc.type: FUNC 304 * @tc.require: AR000GHSJK 305 */ 306HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_003, testing::ext::TestSize.Level0) 307{ 308 // 1. set pkgName not null 309 std::string pkgName = "com.ohos.test"; 310 // set dmInitCallback not null 311 int count = 0; 312 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 313 // 2. set checkMap null 314 std::shared_ptr<DmInitCallback> checkMap = nullptr; 315 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 316 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 317 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 318 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 319 // 5. check checkMap not null 320 ASSERT_NE(checkMap, nullptr); 321 // 6. set testpkcName com.ohos.test1 322 std::string testPkgName = "com.ohos.test1"; 323 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 324 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName); 325 // 8. Get checkMap from DeviceManagerNotify 326 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 327 // 9. call checkMap OnRemoteDied 328 if (checkMap != nullptr) { 329 checkMap->OnRemoteDied(); 330 } 331 // 10. check count is 1 332 ASSERT_EQ(count, 1); 333} 334 335/** 336 * @tc.name: UnRegisterDeathRecipientCallback_004 337 * @tc.desc: 1. set pkgName com.ohos.test 338 * set dmInitCallback not null 339 * 2. set checkMap null 340 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 341 * 4. Get checkMap from DeviceManagerNotify 342 * 5. check checkMap not null 343 * 6. set testpkcName com.ohos.test1 344 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 345 * 8. Get checkMap from DeviceManagerNotify 346 * 9. check checkMap not null 347 * deviceTypeId 348 * @tc.type: FUNC 349 * @tc.require: AR000GHSJK 350 */ 351HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_004, testing::ext::TestSize.Level0) 352{ 353 // 1. set pkgName not null 354 std::string pkgName = "com.ohos.test"; 355 // set dmInitCallback not null 356 int count = 0; 357 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 358 // 2. set checkMap null 359 std::shared_ptr<DmInitCallback> checkMap = nullptr; 360 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 361 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 362 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 363 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 364 // 5. check checkMap not null 365 ASSERT_NE(checkMap, nullptr); 366 // 6. set testpkcName com.ohos.test1 367 std::string testPkgName = "com.ohos.test1"; 368 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 369 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName); 370 // 8. Get checkMap from DeviceManagerNotify 371 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 372 // 9. check checkMap not null 373 ASSERT_NE(checkMap, nullptr); 374} 375 376/** 377 * @tc.name: UnRegisterDeathRecipientCallback_005 378 * @tc.desc: 1. set pkgName com.ohos.test 379 * set dmInitCallback not null 380 * 2. set checkMap null 381 * 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 382 * 4. Get checkMap from DeviceManagerNotify 383 * 5. check checkMap not null 384 * 6. set testpkcName com.ohos.test1 385 * 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 386 * 8. Get checkMap from DeviceManagerNotify 387 * 9. check checkMap not null 388 * deviceTypeId 389 * @tc.type: FUNC 390 * @tc.require: AR000GHSJK 391 */ 392HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeathRecipientCallback_005, testing::ext::TestSize.Level0) 393{ 394 // 1. set pkgName not null 395 std::string pkgName = "com.ohos.test"; 396 // set dmInitCallback not null 397 int count = 0; 398 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 399 // 2. set checkMap null 400 std::shared_ptr<DmInitCallback> checkMap = nullptr; 401 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 402 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 403 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 404 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 405 // 5. check checkMap not null 406 ASSERT_NE(checkMap, nullptr); 407 // 6. set testpkcName nullptr 408 std::string testPkgName = ""; 409 // 7. call DeviceManagerNotifyTest UnRegisterDeathRecipientCallback with testpkcName 410 DeviceManagerNotify::GetInstance().UnRegisterDeathRecipientCallback(testPkgName); 411 // 8. Get checkMap from DeviceManagerNotify 412 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 413 // 8 check checkMap not null 414 ASSERT_NE(checkMap, nullptr); 415} 416 417/** 418 * @tc.name: RegisterDeviceStateCallback_001 419 * @tc.desc: 1. set pkgName not null 420 * set Callback not null 421 * 2. set checkMap null 422 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 423 * 4. Get checkMap from DeviceManagerNotify 424 * 5. check checkMap not null 425 * deviceTypeId 426 * @tc.type: FUNC 427 * @tc.require: AR000GHSJK 428 */ 429HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_001, testing::ext::TestSize.Level0) 430{ 431 // 1. set pkgName not null 432 std::string pkgName = "com.ohos.test"; 433 // set Callback not null 434 int count = 0; 435 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 436 // 2. set checkMap null 437 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 438 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 439 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 440 // 4. Get checkMap from DeviceManagerNotify 441 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 442 // 5. check checkMap not null 443 ASSERT_NE(checkMap, nullptr); 444} 445 446/** 447 * @tc.name: RegisterDeviceStateCallback_002 448 * @tc.desc: 1. set pkgName not null 449 * set Callback not null 450 * 2. set checkMap null 451 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 452 * 4. Get checkMap from DeviceManagerNotify 453 * 5. check checkMap not null 454 * @tc.type: FUNC 455 * @tc.require: AR000GHSJK 456 */ 457HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_002, testing::ext::TestSize.Level0) 458{ 459 // 1. set pkgName not null 460 std::string pkgName = "com.ohos.test"; 461 // set dmInitCallback not null 462 int count = 0; 463 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 464 // 2. set checkMap null 465 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 466 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 467 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 468 // 4. Get checkMap from DeviceManagerNotify 469 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 470 // 5. check checkMap null 471 ASSERT_NE(checkMap, nullptr); 472} 473 474/** 475 * @tc.name: RegisterDeviceStateCallback_003 476 * @tc.desc: 1. set pkgName com.ohos.test 477 * set Callback not null 478 * 2. set checkMap null 479 * 3. set testpkcName com.ohos.test1 480 * 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 481 * 5. Get checkMap from DeviceManagerNotify with testpkcName 482 * 6. check checkMap null 483 * @tc.type: FUNC 484 * @tc.require: AR000GHSJK 485 */ 486HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_003, testing::ext::TestSize.Level0) 487{ 488 // 1. set pkgName com.ohos.test 489 std::string pkgName = "com.ohos.test"; 490 // set dmInitCallback not null 491 std::shared_ptr<DeviceStateCallback> callback = nullptr; 492 // 2. set checkMap null 493 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 494 // 3. set testpkcName com.ohos.test1 495 std::string testPkgName = "com.ohos.test1"; 496 // 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 497 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 498 // 5. Get checkMap from DeviceManagerNotify with testpkcName 499 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[testPkgName]; 500 // 6. check checkMap not null 501 ASSERT_EQ(checkMap, nullptr); 502} 503 504/** 505 * @tc.name: RegisterDeviceStateCallback_004 506 * @tc.desc: 1. set pkgName not null 507 * set Callback not null 508 * 2. set checkMap null 509 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 510 * 4. Get checkMap from DeviceManagerNotify 511 * 5. check checkMap not null 512 * 6. call checkMap OnDeviceOnline 513 * 7. check count is 1 514 * @tc.type: FUNC 515 * @tc.require: AR000GHSJK 516 */ 517HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_004, testing::ext::TestSize.Level0) 518{ 519 // 1. set pkgName not null 520 std::string pkgName = "com.ohos.test"; 521 // set Callback not null 522 int count = 0; 523 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 524 // 2. set checkMap null 525 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 526 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 527 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 528 // 4. Get checkMap from DeviceManagerNotify 529 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 530 // 5. check checkMap not null 531 ASSERT_NE(checkMap, nullptr); 532 // 6. call checkMap OnDeviceOnline 533 DmDeviceInfo deviceInfo; 534 if (checkMap != nullptr) { 535 checkMap->OnDeviceOnline(deviceInfo); 536 } 537 // 7. check count is 1 538 ASSERT_EQ(count, 1); 539} 540 541/** 542 * @tc.name: RegisterDeviceStateCallback_005 543 * @tc.desc: 1. set pkgName com.ohos.test 544 * set Callback not null 545 * 2. set checkMap null 546 * 3. set testpkcName com.ohos.test1 547 * 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 548 * 5. Get checkMap from DeviceManagerNotify with testpkcName 549 * 6. check checkMap null 550 * @tc.type: FUNC 551 * @tc.require: AR000GHSJK 552 */ 553HWTEST_F(DeviceManagerNotifyTest, RegisterDeviceStateCallback_005, testing::ext::TestSize.Level0) 554{ 555 // 1. set pkgName com.ohos.test 556 std::string pkgName = "com.ohos.test"; 557 int count = 0; 558 // set dmInitCallback not null 559 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 560 // 2. set checkMap null 561 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 562 // 3. set testpkcName com.ohos.test1 563 std::string testPkgName = "com.ohos.test1"; 564 // 4. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 565 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 566 // 5. Get checkMap from DeviceManagerNotify with testpkcName 567 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[testPkgName]; 568 // 6. check checkMap not null 569 ASSERT_EQ(checkMap, nullptr); 570} 571 572/** 573 * @tc.name: UnRegisterDeviceStateCallback_001 574 * @tc.desc: 1. set pkgName not null 575 * set Callback not null 576 * 2. set checkMap null 577 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 578 * 4. Get checkMap from DeviceManagerNotify 579 * 5. check checkMap not null 580 * 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter 581 * 7. Get checkMap from DeviceManagerNotify 582 * 8. check checkMap null 583 * @tc.type: FUNC 584 * @tc.require: AR000GHSJK 585 */ 586HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_001, testing::ext::TestSize.Level0) 587{ 588 // 1. set pkgName not null 589 std::string pkgName = "com.ohos.test"; 590 // set dmInitCallback not null 591 int count = 0; 592 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 593 // 2. set checkMap null 594 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 595 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 596 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 597 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 598 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 599 // 5. check checkMap not null 600 ASSERT_NE(checkMap, nullptr); 601 // 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter 602 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName); 603 // 7. Get checkMap from DeviceManagerNotify 604 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 605 // 8 check checkMap null 606 ASSERT_EQ(checkMap, nullptr); 607} 608 609/** 610 * @tc.name: UnRegisterDeviceStateCallback_002 611 * @tc.desc: 1. set pkgName com.ohos.test 612 * set Callback not null 613 * 2. set checkMap null 614 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 615 * 4. Get checkMap from DeviceManagerNotify 616 * 5. check checkMap not null 617 * 6. set testpkcName com.ohos.test1 618 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 619 * 8. Get checkMap from DeviceManagerNotify 620 * 9. check checkMap not null 621 * @tc.type: FUNC 622 * @tc.require: AR000GHSJK 623 */ 624HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_002, testing::ext::TestSize.Level0) 625{ 626 // 1. set pkgName not null 627 std::string pkgName = "com.ohos.test"; 628 // set dmInitCallback not null 629 int count = 0; 630 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 631 // 2. set checkMap null 632 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 633 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 634 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 635 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 636 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 637 // 5. check checkMap not null 638 ASSERT_NE(checkMap, nullptr); 639 // 6. set testpkcName com.ohos.test1 640 std::string testPkgName = "com.ohos.test1"; 641 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 642 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName); 643 // 8. Get checkMap from DeviceManagerNotify 644 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 645 // 8 check checkMap not null 646 ASSERT_NE(checkMap, nullptr); 647} 648 649/** 650 * @tc.name: UnRegisterDeviceStateCallback_003 651 * @tc.desc: 1. set pkgName com.ohos.test 652 * set Callback not null 653 * 2. set checkMap null 654 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 655 * 4. Get checkMap from DeviceManagerNotify 656 * 5. check checkMap not null 657 * 6. set testpkcName com.ohos.test1 658 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 659 * 8. Get checkMap from DeviceManagerNotify 660 * 9. check checkMap not null 661 * @tc.type: FUNC 662 * @tc.require: AR000GHSJK 663 */ 664HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_003, testing::ext::TestSize.Level0) 665{ 666 // 1. set pkgName not null 667 std::string pkgName = "com.ohos.test"; 668 // set dmInitCallback not null 669 int count = 0; 670 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 671 // 2. set checkMap null 672 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 673 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 674 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 675 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 676 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 677 // 5. check checkMap not null 678 ASSERT_NE(checkMap, nullptr); 679 // 6. set testpkcName com.ohos.test1 680 std::string testPkgName = "com.ohos.test1"; 681 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 682 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName); 683 // 8. Get checkMap from DeviceManagerNotify 684 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 685 // 8 check checkMap not null 686 ASSERT_NE(checkMap, nullptr); 687 // 9. call checkMap OnDeviceOnline 688 DmDeviceInfo deviceInfo; 689 if (checkMap != nullptr) { 690 checkMap->OnDeviceOnline(deviceInfo); 691 } 692 // 10. check count is 1 693 ASSERT_EQ(count, 1); 694} 695 696/** 697 * @tc.name: UnRegisterDeviceStateCallback_004 698 * @tc.desc: 1. set pkgName not null 699 * set Callback not null 700 * 2. set checkMap null 701 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 702 * 4. Get checkMap from DeviceManagerNotify 703 * 5. check checkMap not null 704 * 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter 705 * 7. Get checkMap from DeviceManagerNotify 706 * 8. check checkMap null 707 * @tc.type: FUNC 708 * @tc.require: AR000GHSJK 709 */ 710HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_004, testing::ext::TestSize.Level0) 711{ 712 // 1. set pkgName not null 713 std::string pkgName = "com.ohos.test"; 714 // set dmInitCallback not null 715 int count = 0; 716 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 717 // 2. set checkMap null 718 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 719 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 720 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 721 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 722 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 723 // 5. check checkMap not null 724 ASSERT_NE(checkMap, nullptr); 725 // 6. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with parameter 726 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName); 727 // 7. Get checkMap from DeviceManagerNotify 728 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 729 // 8 check checkMap null 730 ASSERT_EQ(checkMap, nullptr); 731} 732 733/** 734 * @tc.name: UnRegisterDeviceStateCallback_005 735 * @tc.desc: 1. set pkgName com.ohos.test 736 * set Callback not null 737 * 2. set checkMap null 738 * 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 739 * 4. Get checkMap from DeviceManagerNotify 740 * 5. check checkMap not null 741 * 6. set testpkcName com.ohos.test1 742 * 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 743 * 8. Get checkMap from DeviceManagerNotify 744 * 9. check checkMap not null 745 * @tc.type: FUNC 746 * @tc.require: AR000GHSJK 747 */ 748HWTEST_F(DeviceManagerNotifyTest, UnRegisterDeviceStateCallback_005, testing::ext::TestSize.Level0) 749{ 750 // 1. set pkgName not null 751 std::string pkgName = "com.ohos.test"; 752 // set dmInitCallback not null 753 int count = 0; 754 std::shared_ptr<DeviceStateCallback> callback = std::make_shared<DeviceStateCallbackTest>(count); 755 // 2. set checkMap null 756 std::shared_ptr<DeviceStateCallback> checkMap = nullptr; 757 // 3. call DeviceManagerNotifyTest RegisterDeviceStateCallback with parameter 758 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); 759 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 760 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 761 // 5. check checkMap not null 762 ASSERT_NE(checkMap, nullptr); 763 // 6. set testpkcName com.ohos.test1 764 std::string testPkgName = ""; 765 // 7. call DeviceManagerNotifyTest UnRegisterDeviceStateCallback with testpkcName 766 DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(testPkgName); 767 // 8. Get checkMap from DeviceManagerNotify 768 checkMap = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 769 // 8 check checkMap not null 770 ASSERT_NE(checkMap, nullptr); 771 // 9. call checkMap OnDeviceOnline 772 DmDeviceInfo deviceInfo; 773 if (checkMap != nullptr) { 774 checkMap->OnDeviceOnline(deviceInfo); 775 } 776 // 10. check count is 1 777 ASSERT_EQ(count, 1); 778} 779 780/** 781 * @tc.name: RegisterDiscoverCallback_001 782 * @tc.desc: 1. set pkgName not null 783 * set Callback not null 784 * set subscribeId not null 785 * 2. set checkMap null 786 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 787 * 4. Get checkMap from DeviceManagerNotify 788 * 5. check checkMap not null 789 * @tc.type: FUNC 790 * @tc.require: AR000GHSJK 791 */ 792HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_001, testing::ext::TestSize.Level0) 793{ 794 // 1. set pkgName not null 795 std::string pkgName = "com.ohos.test"; 796 // set dmInitCallback not null 797 int count = 0; 798 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 799 // set subscribeId not null 800 uint16_t subscribeId = 0; 801 // 2. set checkMap null 802 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 803 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 804 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 805 // 4. Get checkMap from DeviceManagerNotify 806 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 807 // 5. check checkMap not null 808 ASSERT_NE(checkMap, nullptr); 809} 810 811/** 812 * @tc.name: RegisterDiscoverCallback_002 813 * @tc.desc: 1. set pkgName not null 814 * set Callback null 815 * set subscribeId not null 816 * 2. set checkMap null 817 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 818 * 4. Get checkMap from DeviceManagerNotify 819 * 5. check checkMap mot null 820 * @tc.type: FUNC 821 * @tc.require: AR000GHSJK 822 */ 823HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_002, testing::ext::TestSize.Level0) 824{ 825 // 1. set pkgName not null 826 std::string pkgName = "com.ohos.test"; 827 // set dmInitCallback not null 828 int count = 0; 829 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 830 // set subscribeId not null 831 uint16_t subscribeId = 0; 832 // 2. set checkMap not null 833 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 834 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 835 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 836 // 4. Get checkMap from DeviceManagerNotify 837 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 838 // 5. check checkMap null 839 ASSERT_NE(checkMap, nullptr); 840} 841 842/** 843 * @tc.name: RegisterDiscoverCallback_003 844 * @tc.desc: 1. set pkgName com.ohos.test 845 * set Callback not null 846 * set subscribeId not null 847 * 2. set checkMap null 848 * 3. set testpkcName com.ohos.test1 849 * 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 850 * 5. Get checkMap from DeviceManagerNotify with testpkcName 851 * 6. check checkMap null 852 * @tc.type: FUNC 853 * @tc.require: AR000GHSJK 854 */ 855HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_003, testing::ext::TestSize.Level0) 856{ 857 // 1. set pkgName com.ohos.test 858 std::string pkgName = "com.ohos.test"; 859 // set dmInitCallback not null 860 int count = 0; 861 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 862 // set subscribeId not null 863 uint16_t subscribeId = 0; 864 // 2. set checkMap null 865 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 866 // 3. set testpkcName com.ohos.test1 867 std::string testPkgName = "com.ohos.test1"; 868 // 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 869 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 870 // 5. Get checkMap from DeviceManagerNotify with testpkcName 871 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 872 // 6. check checkMap not null 873 ASSERT_NE(checkMap, nullptr); 874} 875 876/** 877 * @tc.name: RegisterDiscoverCallback_004 878 * @tc.desc: 1. set pkgName not null 879 * set Callback not null 880 * set subscribeId not null 881 * 2. set checkMap null 882 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 883 * 4. Get checkMap from DeviceManagerNotify 884 * 5. check checkMap not null 885 * 6. call checkMap OnDiscoverySuccess 886 * 7. check count is 1 887 * @tc.type: FUNC 888 * @tc.require: AR000GHSJK 889 */ 890HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_004, testing::ext::TestSize.Level0) 891{ 892 // 1. set pkgName not null 893 std::string pkgName = "com.ohos.test"; 894 // set dmInitCallback not null 895 int count = 0; 896 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 897 // set subscribeId not null 898 uint16_t subscribeId = 0; 899 // 2. set checkMap null 900 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 901 // 3. call DeviceManagerNotifyTest RegisterDeathRecipientCallback with parameter 902 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 903 // 4. Get checkMap from DeviceManagerNotify 904 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 905 // 5. check checkMap not null 906 ASSERT_NE(checkMap, nullptr); 907 // 6. call checkMap OnDiscoverySuccess 908 if (checkMap != nullptr) { 909 checkMap->OnDiscoverySuccess(subscribeId); 910 } 911 // 7. check count is 1 912 ASSERT_EQ(count, 1); 913} 914 915/** 916 * @tc.name: RegisterDiscoverCallback_005 917 * @tc.desc: 1. set pkgName com.ohos.test 918 * set Callback not null 919 * set subscribeId not null 920 * 2. set checkMap null 921 * 3. set testpkcName com.ohos.test1 922 * 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 923 * 5. Get checkMap from DeviceManagerNotify with testpkcName 924 * 6. check checkMap null 925 * @tc.type: FUNC 926 * @tc.require: AR000GHSJK 927 */ 928HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_005, testing::ext::TestSize.Level0) 929{ 930 // 1. set pkgName com.ohos.test 931 std::string pkgName = "com.ohos.test"; 932 int count = 0; 933 // set dmInitCallback not null 934 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 935 uint16_t subscribeId = 0; 936 // 2. set checkMap null 937 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 938 // 4. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 939 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 940 // 5. Get checkMap from DeviceManagerNotify with testpkcName 941 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 942 // 6. check checkMap not null 943 ASSERT_NE(checkMap, nullptr); 944} 945 946/** 947 * @tc.name: RegisterDiscoverCallback_006 948 * @tc.type: FUNC 949 */ 950HWTEST_F(DeviceManagerNotifyTest, RegisterDiscoveryCallback_006, testing::ext::TestSize.Level0) 951{ 952 std::string pkgName; 953 int count = 0; 954 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 955 uint16_t subscribeId = 0; 956 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 957 EXPECT_EQ(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_.count(pkgName), 0); 958} 959 960/** 961 * @tc.name: UnRegisterDiscoverCallback_001 962 * @tc.desc: 1. set pkgName not null 963 * set callback not null 964 * set subscribeId not null 965 * 2. set checkMap null 966 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 967 * 4. Get checkMap from DeviceManagerNotify 968 * 5. check checkMap not null 969 * 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter 970 * 7. Get checkMap from DeviceManagerNotify 971 * 8. check checkMap null 972 * @tc.type: FUNC 973 * @tc.require: AR000GHSJK 974 */ 975HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_001, testing::ext::TestSize.Level0) 976{ 977 // 1. set pkgName not null 978 std::string pkgName = "com.ohos.test"; 979 // set dmInitCallback not null 980 int count = 0; 981 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 982 // set subscribeId not null 983 uint16_t subscribeId = 0; 984 // 2. set checkMap null 985 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 986 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 987 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 988 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 989 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 990 // 5. check checkMap not null 991 ASSERT_NE(checkMap, nullptr); 992 // 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter 993 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId); 994 // 7. Get checkMap from DeviceManagerNotify 995 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 996 // 8 check checkMap null 997 ASSERT_EQ(checkMap, nullptr); 998} 999 1000/** 1001 * @tc.name: UnRegisterDiscoverCallback_002 1002 * @tc.desc: 1. set pkgName com.ohos.test 1003 * set dmInitCallback not null 1004 * set subscribeId not null 1005 * 2. set checkMap null 1006 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1007 * 4. Get checkMap from DeviceManagerNotify 1008 * 5. check checkMap not null 1009 * 6. set testpkcName com.ohos.test1 1010 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1011 * 8. Get checkMap from DeviceManagerNotify 1012 * 9. check checkMap not null 1013 * @tc.type: FUNC 1014 * @tc.require: AR000GHSJK 1015 */ 1016HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_002, testing::ext::TestSize.Level0) 1017{ 1018 // 1. set pkgName not null 1019 std::string pkgName = "com.ohos.test"; 1020 // set dmInitCallback not null 1021 int count = 0; 1022 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 1023 // set subscribeId not null 1024 uint16_t subscribeId = 0; 1025 // 2. set checkMap null 1026 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 1027 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1028 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 1029 // 4. Get checkMap from DeviceManagerNotify 1030 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1031 // 5. check checkMap not null 1032 ASSERT_NE(checkMap, nullptr); 1033 // 6. set testpkcName com.ohos.test1 1034 std::string testPkgName = "com.ohos.test1"; 1035 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1036 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId); 1037 // 8. Get checkMap from DeviceManagerNotify 1038 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1039 // 8 check checkMap not null 1040 ASSERT_NE(checkMap, nullptr); 1041} 1042 1043/** 1044 * @tc.name: UnRegisterDiscoverCallback_003 1045 * @tc.desc: 1. set pkgName com.ohos.test 1046 * set dmInitCallback not null 1047 * set subscribeId not null 1048 * 2. set checkMap null 1049 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1050 * 4. Get checkMap from DeviceManagerNotify 1051 * 5. check checkMap not null 1052 * 6. set testpkcName com.ohos.test1 1053 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1054 * 8. Get checkMap from DeviceManagerNotify 1055 * 9. check checkMap not null 1056 * 10. call checkMap OnDiscoverySuccess 1057 * 11. check count is 1 1058 * @tc.type: FUNC 1059 * @tc.require: AR000GHSJK 1060 */ 1061HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_003, testing::ext::TestSize.Level0) 1062{ 1063 // 1. set pkgName not null 1064 std::string pkgName = "com.ohos.test"; 1065 // set dmInitCallback not null 1066 int count = 0; 1067 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 1068 // set subscribeId not null 1069 uint16_t subscribeId = 0; 1070 // 2. set checkMap null 1071 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 1072 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1073 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 1074 // 4. Get checkMap from DeviceManagerNotify 1075 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1076 // 5. check checkMap not null 1077 ASSERT_NE(checkMap, nullptr); 1078 // 6. set testpkcName com.ohos.test1 1079 std::string testPkgName = "com.ohos.test1"; 1080 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1081 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId); 1082 // 8. Get checkMap from DeviceManagerNotify 1083 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1084 // 9 check checkMap not null 1085 ASSERT_NE(checkMap, nullptr); 1086 // 10. call checkMap OnDiscoverySuccess 1087 if (checkMap != nullptr) { 1088 checkMap->OnDiscoverySuccess(subscribeId); 1089 } 1090 // 11. check count is 1 1091 ASSERT_EQ(count, 1); 1092} 1093 1094/** 1095 * @tc.name: UnRegisterDiscoverCallback_004 1096 * @tc.desc: 1. set pkgName not null 1097 * set callback not null 1098 * set subscribeId not null 1099 * 2. set checkMap null 1100 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1101 * 4. Get checkMap from DeviceManagerNotify 1102 * 5. check checkMap not null 1103 * 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter 1104 * 7. Get checkMap from DeviceManagerNotify 1105 * 8. check checkMap null 1106 * @tc.type: FUNC 1107 * @tc.require: AR000GHSJK 1108 */ 1109HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_004, testing::ext::TestSize.Level0) 1110{ 1111 // 1. set pkgName not null 1112 std::string pkgName = "com.ohos.test"; 1113 // set dmInitCallback not null 1114 int count = 0; 1115 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 1116 // set subscribeId not null 1117 uint16_t subscribeId = 0; 1118 // 2. set checkMap null 1119 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 1120 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1121 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 1122 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 1123 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1124 // 5. check checkMap not null 1125 ASSERT_NE(checkMap, nullptr); 1126 // 6. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with parameter 1127 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId); 1128 // 7. Get checkMap from DeviceManagerNotify 1129 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1130 // 8 check checkMap null 1131 ASSERT_EQ(checkMap, nullptr); 1132} 1133 1134/** 1135 * @tc.name: UnRegisterDiscoverCallback_005 1136 * @tc.desc: 1. set pkgName com.ohos.test 1137 * set dmInitCallback not null 1138 * set subscribeId not null 1139 * 2. set checkMap null 1140 * 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1141 * 4. Get checkMap from DeviceManagerNotify 1142 * 5. check checkMap not null 1143 * 6. set testpkcName com.ohos.test1 1144 * 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1145 * 8. Get checkMap from DeviceManagerNotify 1146 * 9. check checkMap not null 1147 * 10. call checkMap OnDiscoverySuccess 1148 * 11. check count is 1 1149 * @tc.type: FUNC 1150 * @tc.require: AR000GHSJK 1151 */ 1152HWTEST_F(DeviceManagerNotifyTest, UnRegisterDiscoveryCallback_005, testing::ext::TestSize.Level0) 1153{ 1154 // 1. set pkgName not null 1155 std::string pkgName = "com.ohos.test"; 1156 // set dmInitCallback not null 1157 int count = 0; 1158 std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DiscoveryCallbackTest>(count); 1159 // set subscribeId not null 1160 uint16_t subscribeId = 0; 1161 // 2. set checkMap null 1162 std::shared_ptr<DiscoveryCallback> checkMap = nullptr; 1163 // 3. call DeviceManagerNotifyTest RegisterDiscoverCallback with parameter 1164 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback); 1165 // 4. Get checkMap from DeviceManagerNotify 1166 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1167 // 5. check checkMap not null 1168 ASSERT_NE(checkMap, nullptr); 1169 // 6. set testpkcName com.ohos.test1 1170 std::string testPkgName = ""; 1171 // 7. call DeviceManagerNotifyTest UnRegisterDiscoverCallback with testpkcName 1172 DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(testPkgName, subscribeId); 1173 // 8. Get checkMap from DeviceManagerNotify 1174 checkMap = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1175 // 9 check checkMap not null 1176 ASSERT_NE(checkMap, nullptr); 1177 // 10. call checkMap OnDiscoverySuccess 1178 if (checkMap != nullptr) { 1179 checkMap->OnDiscoverySuccess(subscribeId); 1180 } 1181 // 11. check count is 1 1182 ASSERT_EQ(count, 1); 1183} 1184 1185/** 1186 * @tc.name: RegisterAuthenticateCallback_001 1187 * @tc.desc: 1. set pkgName not null 1188 * set Callback not null 1189 * set deviceId not null 1190 * 2. set checkMap null 1191 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1192 * 4. Get checkMap from DeviceManagerNotify 1193 * 5. check checkMap not null 1194 * @tc.type: FUNC 1195 * @tc.require: AR000GHSJK 1196 */ 1197HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_001, testing::ext::TestSize.Level0) 1198{ 1199 // 1. set pkgName not null 1200 std::string pkgName = "com.ohos.test"; 1201 // set dmInitCallback not null 1202 int count = 0; 1203 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1204 // set subscribeId not null 1205 std::string deviceId = "1"; 1206 // 2. set checkMap null 1207 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1208 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1209 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1210 // 4. Get checkMap from DeviceManagerNotify 1211 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1212 // 5. check checkMap not null 1213 ASSERT_NE(checkMap, nullptr); 1214} 1215 1216/** 1217 * @tc.name: RegisterAuthenticateCallback_002 1218 * @tc.desc: 1. set pkgName not null 1219 * set Callback null 1220 * set deviceId not null 1221 * 2. set checkMap null 1222 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1223 * 4. Get checkMap from DeviceManagerNotify 1224 * 5. check checkMap null 1225 * @tc.type: FUNC 1226 * @tc.require: AR000GHSJK 1227 */ 1228HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_002, testing::ext::TestSize.Level0) 1229{ 1230 // 1. set pkgName not null 1231 std::string pkgName = "com.ohos.test"; 1232 // set dmInitCallback not null 1233 int count = 0; 1234 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1235 // set subscribeId not null 1236 std::string deviceId = "1"; 1237 // 2. set checkMap not null 1238 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1239 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1240 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1241 // 4. Get checkMap from DeviceManagerNotify 1242 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1243 // 5. check checkMap null 1244 ASSERT_NE(checkMap, nullptr); 1245} 1246 1247/** 1248 * @tc.name: RegisterAuthenticateCallback_003 1249 * @tc.desc: 1. set pkgName com.ohos.test 1250 * set Callback not null 1251 * set deviceId not null 1252 * 2. set checkMap null 1253 * 3. set testpkcName com.ohos.test1 1254 * 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1255 * 5. Get checkMap from DeviceManagerNotify with testpkcName 1256 * 6. check checkMap null 1257 * @tc.type: FUNC 1258 * @tc.require: AR000GHSJK 1259 */ 1260HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_003, testing::ext::TestSize.Level0) 1261{ 1262 // 1. set pkgName com.ohos.test 1263 std::string pkgName = "com.ohos.test"; 1264 // set dmInitCallback not null 1265 int count = 0; 1266 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1267 // set subscribeId not null 1268 std::string deviceId = "1"; 1269 // 2. set checkMap null 1270 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1271 // 3. set testpkcName com.ohos.test1 1272 std::string testPkgName = "com.ohos.test1"; 1273 // 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1274 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1275 // 5. Get checkMap from DeviceManagerNotify with testpkcName 1276 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1277 // 6. check checkMap not null 1278 ASSERT_NE(checkMap, nullptr); 1279} 1280 1281/** 1282 * @tc.name: RegisterAuthenticateCallback_004 1283 * @tc.desc: 1. set pkgName not null 1284 * set Callback not null 1285 * set deviceId not null 1286 * 2. set checkMap null 1287 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1288 * 4. Get checkMap from DeviceManagerNotify 1289 * 5. check checkMap not null 1290 * @tc.type: FUNC 1291 * @tc.require: AR000GHSJK 1292 */ 1293HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_004, testing::ext::TestSize.Level0) 1294{ 1295 // 1. set pkgName not null 1296 std::string pkgName = "com.ohos.test"; 1297 // set dmInitCallback not null 1298 int count = 0; 1299 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1300 // set subscribeId not null 1301 std::string deviceId = "1"; 1302 // 2. set checkMap null 1303 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1304 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1305 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1306 // 4. Get checkMap from DeviceManagerNotify 1307 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1308 // 5. check checkMap not null 1309 ASSERT_NE(checkMap, nullptr); 1310 // 6. call checkMap OnAuthResult 1311 std::string token = "1"; 1312 int32_t status = 1; 1313 int32_t reason = 1; 1314 if (checkMap != nullptr) { 1315 checkMap->OnAuthResult(deviceId, token, status, reason); 1316 } 1317 // 7. check count is 1 1318 ASSERT_EQ(count, 1); 1319} 1320 1321/** 1322 * @tc.name: RegisterAuthenticateCallback_005 1323 * @tc.desc: 1. set pkgName com.ohos.test 1324 * set Callback not null 1325 * set deviceId not null 1326 * 2. set checkMap null 1327 * 3. set testpkcName com.ohos.test1 1328 * 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1329 * 5. Get checkMap from DeviceManagerNotify with testpkcName 1330 * 6. check checkMap null 1331 * @tc.type: FUNC 1332 * @tc.require: AR000GHSJK 1333 */ 1334HWTEST_F(DeviceManagerNotifyTest, RegisterAuthenticateCallback_005, testing::ext::TestSize.Level0) 1335{ 1336 // 1. set pkgName com.ohos.test 1337 std::string pkgName = "com.ohos.test"; 1338 int count = 0; 1339 // set dmInitCallback not null 1340 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1341 // set subscribeId not null 1342 std::string deviceId = "1"; 1343 // 2. set checkMap null 1344 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1345 // 3. set testpkcName com.ohos.test1 1346 std::string testPkgName = "com.ohos.test1"; 1347 // 4. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1348 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1349 // 5. Get checkMap from DeviceManagerNotify with testpkcName 1350 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1351 // 6. check checkMap not null 1352 ASSERT_NE(checkMap, nullptr); 1353} 1354 1355/** 1356 * @tc.name: UnRegisterAuthenticateCallback_001 1357 * @tc.desc: 1. set pkgName not null 1358 * set callback not null 1359 * set deviceId not null 1360 * 2. set checkMap null 1361 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1362 * 4. Get checkMap from DeviceManagerNotify 1363 * 5. check checkMap not null 1364 * 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter 1365 * 7. Get checkMap from DeviceManagerNotify 1366 * 8. check checkMap null 1367 * @tc.type: FUNC 1368 * @tc.require: AR000GHSJK 1369 */ 1370HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_001, testing::ext::TestSize.Level0) 1371{ 1372 // 1. set pkgName not null 1373 std::string pkgName = "com.ohos.test"; 1374 // set dmInitCallback not null 1375 int count = 0; 1376 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1377 // set subscribeId not null 1378 std::string deviceId = "1"; 1379 // 2. set checkMap null 1380 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1381 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1382 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1383 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 1384 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1385 // 5. check checkMap not null 1386 ASSERT_NE(checkMap, nullptr); 1387 // 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter 1388 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(pkgName, deviceId); 1389 // 7. Get checkMap from DeviceManagerNotify 1390 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1391 // 8 check checkMap null 1392 ASSERT_EQ(checkMap, nullptr); 1393} 1394 1395/** 1396 * @tc.name: UnRegisterAuthenticateCallback_002 1397 * @tc.desc: 1. set pkgName com.ohos.test 1398 * set dmInitCallback not null 1399 * set subscribeId not null 1400 * 2. set checkMap null 1401 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1402 * 4. Get checkMap from DeviceManagerNotify 1403 * 5. check checkMap not null 1404 * 6. set testpkcName com.ohos.test1 1405 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1406 * 8. Get checkMap from DeviceManagerNotify 1407 * 9. check checkMap not null 1408 * @tc.type: FUNC 1409 * @tc.require: AR000GHSJK 1410 */ 1411HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_002, testing::ext::TestSize.Level0) 1412{ 1413 // 1. set pkgName not null 1414 std::string pkgName = "com.ohos.test"; 1415 // set dmInitCallback not null 1416 int count = 0; 1417 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1418 // set subscribeId not null 1419 std::string deviceId = "1"; 1420 // 2. set checkMap null 1421 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1422 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1423 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1424 // 4. Get checkMap from DeviceManagerNotify 1425 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1426 // 5. check checkMap not null 1427 ASSERT_NE(checkMap, nullptr); 1428 // 6. set testpkcName com.ohos.test1 1429 std::string testPkgName = "com.ohos.test1"; 1430 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1431 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId); 1432 // 8. Get checkMap from DeviceManagerNotify 1433 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1434 // 8 check checkMap not null 1435 ASSERT_NE(checkMap, nullptr); 1436} 1437 1438/** 1439 * @tc.name: UnRegisterAuthenticateCallback_003 1440 * @tc.desc: 1. set pkgName com.ohos.test 1441 * set dmInitCallback not null 1442 * set subscribeId not null 1443 * 2. set checkMap null 1444 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1445 * 4. Get checkMap from DeviceManagerNotify 1446 * 5. check checkMap not null 1447 * 6. set testpkcName com.ohos.test1 1448 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1449 * 8. Get checkMap from DeviceManagerNotify 1450 * 9. check checkMap not null 1451 * 10. call checkMap OnAuthResult 1452 * 11. check count is 1 1453 * @tc.type: FUNC 1454 * @tc.require: AR000GHSJK 1455 */ 1456HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_003, testing::ext::TestSize.Level0) 1457{ 1458 // 1. set pkgName not null 1459 std::string pkgName = "com.ohos.test"; 1460 // set dmInitCallback not null 1461 int count = 0; 1462 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1463 // set subscribeId not null 1464 std::string deviceId = "1"; 1465 // 2. set checkMap null 1466 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1467 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1468 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1469 // 4. Get checkMap from DeviceManagerNotify 1470 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1471 // 5. check checkMap not null 1472 ASSERT_NE(checkMap, nullptr); 1473 // 6. set testpkcName com.ohos.test1 1474 std::string testPkgName = "com.ohos.test1"; 1475 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1476 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId); 1477 // 8. Get checkMap from DeviceManagerNotify 1478 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1479 // 9 check checkMap not null 1480 ASSERT_NE(checkMap, nullptr); 1481 // 10. call checkMap OnAuthResult 1482 std::string token = "1"; 1483 int32_t status = 1; 1484 int32_t reason = 1; 1485 if (checkMap != nullptr) { 1486 checkMap->OnAuthResult(deviceId, token, status, reason); 1487 } 1488 // 11. check count is 1 1489 ASSERT_EQ(count, 1); 1490} 1491 1492/** 1493 * @tc.name: UnRegisterAuthenticateCallback_004 1494 * @tc.desc: 1. set pkgName not null 1495 * set callback not null 1496 * set deviceId not null 1497 * 2. set checkMap null 1498 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1499 * 4. Get checkMap from DeviceManagerNotify 1500 * 5. check checkMap not null 1501 * 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter 1502 * 7. Get checkMap from DeviceManagerNotify 1503 * 8. check checkMap null 1504 * @tc.type: FUNC 1505 * @tc.require: AR000GHSJK 1506 */ 1507HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_004, testing::ext::TestSize.Level0) 1508{ 1509 // 1. set pkgName not null 1510 std::string pkgName = "com.ohos.test"; 1511 // set dmInitCallback not null 1512 int count = 0; 1513 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1514 // set subscribeId not null 1515 std::string deviceId = "1"; 1516 // 2. set checkMap null 1517 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1518 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1519 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1520 // 4. Get checkMap from DeviceManagerNotify RegisterDeathRecipientCallback 1521 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1522 // 5. check checkMap not null 1523 ASSERT_NE(checkMap, nullptr); 1524 // 6. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with parameter 1525 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(pkgName, deviceId); 1526 // 7. Get checkMap from DeviceManagerNotify 1527 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1528 // 8. check checkMap not null 1529 ASSERT_EQ(checkMap, nullptr); 1530} 1531 1532/** 1533 * @tc.name: UnRegisterAuthenticateCallback_005 1534 * @tc.desc: 1. set pkgName com.ohos.test 1535 * set dmInitCallback not null 1536 * set subscribeId not null 1537 * 2. set checkMap null 1538 * 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1539 * 4. Get checkMap from DeviceManagerNotify 1540 * 5. check checkMap not null 1541 * 6. set testpkcName com.ohos.test1 1542 * 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1543 * 8. Get checkMap from DeviceManagerNotify 1544 * 9. check checkMap not null 1545 * @tc.type: FUNC 1546 * @tc.require: AR000GHSJK 1547 */ 1548HWTEST_F(DeviceManagerNotifyTest, UnRegisterAuthenticateCallback_005, testing::ext::TestSize.Level0) 1549{ 1550 // 1. set pkgName not null 1551 std::string pkgName = "com.ohos.test"; 1552 // set dmInitCallback not null 1553 int count = 0; 1554 std::shared_ptr<AuthenticateCallback> callback = std::make_shared<AuthenticateCallbackTest>(count); 1555 // set subscribeId not null 1556 std::string deviceId = "1"; 1557 // 2. set checkMap null 1558 std::shared_ptr<AuthenticateCallback> checkMap = nullptr; 1559 // 3. call DeviceManagerNotifyTest RegisterAuthenticateCallback with parameter 1560 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); 1561 // 4. Get checkMap from DeviceManagerNotify 1562 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1563 // 5. check checkMap not null 1564 ASSERT_NE(checkMap, nullptr); 1565 // 6. set testpkcName com.ohos.test1 1566 std::string testPkgName = ""; 1567 // 7. call DeviceManagerNotifyTest UnRegisterAuthenticateCallback with testpkcName 1568 DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(testPkgName, deviceId); 1569 // 8. Get checkMap from DeviceManagerNotify 1570 checkMap = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1571 // 8 check checkMap not null 1572 ASSERT_NE(checkMap, nullptr); 1573} 1574 1575/** 1576 * @tc.name: UnRegisterPackageCallback_001 1577 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1578 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1579 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1580 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1581 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1582 * 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName 1583 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is null 1584 * @tc.type: FUNC 1585 * @tc.require: AR000GHSJK 1586 */ 1587HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_001, testing::ext::TestSize.Level0) 1588{ 1589 // 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1590 std::string pkgName = "com.ohos.test"; 1591 int count = 0; 1592 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 1593 std::shared_ptr<DmInitCallback> checkMap = nullptr; 1594 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1595 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1596 ASSERT_NE(checkMap, nullptr); 1597 // 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1598 int count1 = 0; 1599 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1); 1600 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr; 1601 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1602 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1603 ASSERT_NE(checkMap1, nullptr); 1604 // 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1605 int count2 = 0; 1606 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2); 1607 uint16_t subscribeId = 0; 1608 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr; 1609 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1610 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1611 ASSERT_NE(checkMap2, nullptr); 1612 // 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1613 int count3 = 0; 1614 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3); 1615 std::string deviceId = "1"; 1616 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr; 1617 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1618 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1619 ASSERT_NE(checkMap3, nullptr); 1620 // 5. RegisterPublishCallback with pkgName and deviceStateCallback and subscribeId 1621 int count4 = 0; 1622 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4); 1623 int32_t publishId = 0; 1624 std::shared_ptr<PublishCallback> checkMap4 = nullptr; 1625 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1626 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1627 ASSERT_NE(checkMap4, nullptr); 1628 // 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName 1629 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName); 1630 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1631 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1632 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1633 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1634 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1635 // 7. check if checkMap checkMap1 checkMap2 checkMap3 is null 1636 ASSERT_EQ(checkMap, nullptr); 1637 ASSERT_EQ(checkMap1, nullptr); 1638 ASSERT_EQ(checkMap2, nullptr); 1639 ASSERT_EQ(checkMap3, nullptr); 1640 ASSERT_EQ(checkMap4, nullptr); 1641} 1642 1643/** 1644 * @tc.name: UnRegisterPackageCallback_002 1645 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1646 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1647 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1648 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1649 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1650 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName 1651 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null 1652 * @tc.type: FUNC 1653 * @tc.require: AR000GHSJK 1654 */ 1655HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_002, testing::ext::TestSize.Level0) 1656{ 1657 // 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1658 std::string pkgName = "com.ohos.test"; 1659 int count = 0; 1660 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 1661 std::shared_ptr<DmInitCallback> checkMap = nullptr; 1662 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1663 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1664 ASSERT_NE(checkMap, nullptr); 1665 // 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1666 int count1 = 0; 1667 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1); 1668 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr; 1669 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1670 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1671 ASSERT_NE(checkMap1, nullptr); 1672 // 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1673 int count2 = 0; 1674 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2); 1675 uint16_t subscribeId = 0; 1676 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr; 1677 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1678 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1679 ASSERT_NE(checkMap2, nullptr); 1680 // 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1681 int count3 = 0; 1682 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3); 1683 std::string deviceId = "1"; 1684 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr; 1685 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1686 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1687 ASSERT_NE(checkMap3, nullptr); 1688 // 5. RegisterPublishCallback with pkgName and deviceStateCallback and publishId 1689 int count4 = 0; 1690 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4); 1691 int32_t publishId = 0; 1692 std::shared_ptr<PublishCallback> checkMap4 = nullptr; 1693 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1694 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1695 ASSERT_NE(checkMap4, nullptr); 1696 // 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName 1697 std::string testPkgName = "com.ohos.test1"; 1698 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName); 1699 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1700 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1701 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1702 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1703 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1704 // 7. check if checkMap checkMap1 checkMap2 checkMap3 is null 1705 ASSERT_NE(checkMap, nullptr); 1706 ASSERT_NE(checkMap1, nullptr); 1707 ASSERT_NE(checkMap2, nullptr); 1708 ASSERT_NE(checkMap3, nullptr); 1709 ASSERT_NE(checkMap4, nullptr); 1710} 1711 1712/** 1713 * @tc.name: UnRegisterPackageCallback_003 1714 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1715 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1716 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1717 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1718 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1719 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName 1720 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null 1721 * @tc.type: FUNC 1722 * @tc.require: AR000GHSJK 1723 */ 1724HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_003, testing::ext::TestSize.Level0) 1725{ 1726 std::string pkgName = "com.ohos.test"; 1727 int count[5] = {0, 0, 0, 0, 0}; 1728 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count[0]); 1729 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1730 ASSERT_NE(DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName], nullptr); 1731 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count[1]); 1732 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1733 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName], nullptr); 1734 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count[2]); 1735 uint16_t subscribeId = 0; 1736 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1737 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId], nullptr); 1738 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count[3]); 1739 std::string deviceId = "1"; 1740 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1741 ASSERT_NE(DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId], nullptr); 1742 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count[4]); 1743 int32_t publishId = 0; 1744 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1745 ASSERT_NE(DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId], nullptr); 1746 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback("com.ohos.test1"); 1747 std::shared_ptr<DmInitCallback> checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1748 std::shared_ptr<DeviceStateCallback> checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1749 std::shared_ptr<DiscoveryCallback> checkMap2 = 1750 DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1751 std::shared_ptr<AuthenticateCallback> checkMap3 = 1752 DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1753 std::shared_ptr<PublishCallback> checkMap4 = 1754 DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1755 ASSERT_NE(checkMap, nullptr); 1756 ASSERT_NE(checkMap1, nullptr); 1757 ASSERT_NE(checkMap2, nullptr); 1758 ASSERT_NE(checkMap3, nullptr); 1759 ASSERT_NE(checkMap4, nullptr); 1760} 1761 1762/** 1763 * @tc.name: UnRegisterPackageCallback_004 1764 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1765 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1766 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1767 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1768 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1769 * 6. call DeviceManagerNotify UnRegisterPackageCallback with PkgName 1770 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is null 1771 * @tc.type: FUNC 1772 * @tc.require: AR000GHSJK 1773 */ 1774HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_004, testing::ext::TestSize.Level0) 1775{ 1776 std::string pkgName = "com.ohos.test"; 1777 int count[5] = {0, 0, 0, 0, 0}; 1778 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count[0]); 1779 std::shared_ptr<DmInitCallback> checkMap = nullptr; 1780 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1781 ASSERT_NE(DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName], nullptr); 1782 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count[1]); 1783 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr; 1784 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1785 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName], nullptr); 1786 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count[2]); 1787 uint16_t subscribeId = 0; 1788 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr; 1789 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1790 ASSERT_NE(DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId], nullptr); 1791 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count[3]); 1792 std::string deviceId = "1"; 1793 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr; 1794 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1795 ASSERT_NE(DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId], nullptr); 1796 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count[4]); 1797 int32_t publishId = 0; 1798 std::shared_ptr<PublishCallback> checkMap4 = nullptr; 1799 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1800 ASSERT_NE(DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId], nullptr); 1801 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName); 1802 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1803 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1804 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1805 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1806 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1807 ASSERT_EQ(checkMap, nullptr); 1808 ASSERT_EQ(checkMap1, nullptr); 1809 ASSERT_EQ(checkMap2, nullptr); 1810 ASSERT_EQ(checkMap3, nullptr); 1811 ASSERT_EQ(checkMap4, nullptr); 1812} 1813 1814/** 1815 * @tc.name: UnRegisterPackageCallback_005 1816 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1817 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1818 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1819 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1820 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1821 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName 1822 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null 1823 * @tc.type: FUNC 1824 * @tc.require: AR000GHSJK 1825 */ 1826HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_005, testing::ext::TestSize.Level0) 1827{ 1828 std::string pkgName = "com.ohos.test"; 1829 int count = 0; 1830 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 1831 std::shared_ptr<DmInitCallback> checkMap = nullptr; 1832 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1833 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1834 ASSERT_NE(checkMap, nullptr); 1835 int count1 = 0; 1836 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1); 1837 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr; 1838 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1839 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1840 ASSERT_NE(checkMap1, nullptr); 1841 int count2 = 0; 1842 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2); 1843 uint16_t subscribeId = 0; 1844 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr; 1845 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1846 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1847 ASSERT_NE(checkMap2, nullptr); 1848 int count3 = 0; 1849 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3); 1850 std::string deviceId = "1"; 1851 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr; 1852 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1853 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1854 ASSERT_NE(checkMap3, nullptr); 1855 int count4 = 0; 1856 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4); 1857 int32_t publishId = 0; 1858 std::shared_ptr<PublishCallback> checkMap4 = nullptr; 1859 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1860 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][subscribeId]; 1861 ASSERT_NE(checkMap4, nullptr); 1862 std::string testPkgName = ""; 1863 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName); 1864 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1865 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1866 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1867 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1868 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1869 ASSERT_NE(checkMap, nullptr); 1870 ASSERT_NE(checkMap1, nullptr); 1871 ASSERT_NE(checkMap2, nullptr); 1872 ASSERT_NE(checkMap3, nullptr); 1873 ASSERT_NE(checkMap4, nullptr); 1874} 1875 1876/** 1877 * @tc.name: UnRegisterPackageCallback_005 1878 * @tc.desc: 1. RegisterDeathRecipientCallback with pkgName and dmInitCallback 1879 * 2. RegisterDeviceStateCallback with pkgName and deviceStateCallback 1880 * 3. RegisterDiscoverCallback with pkgName and deviceStateCallback and subscribeId 1881 * 4. RegisterAuthenticateCallback with pkgName and deviceId and authenticateCallback 1882 * 5. RegisterPublishCallback with pkgName and devicePublishCallback and publishId 1883 * 6. call DeviceManagerNotify UnRegisterPackageCallback with testPkgName 1884 * 7. check if checkMap checkMap1 checkMap2 checkMap3 is not null 1885 * @tc.type: FUNC 1886 * @tc.require: AR000GHSJK 1887 */ 1888HWTEST_F(DeviceManagerNotifyTest, UnRegisterPackageCallback_006, testing::ext::TestSize.Level0) 1889{ 1890 std::string pkgName; 1891 int count = 0; 1892 std::shared_ptr<DmInitCallback> dmInitCallback = std::make_shared<DmInitCallbackTest>(count); 1893 std::shared_ptr<DmInitCallback> checkMap = nullptr; 1894 DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); 1895 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1896 ASSERT_EQ(checkMap, nullptr); 1897 int count1 = 0; 1898 std::shared_ptr<DeviceStateCallback> deviceStateCallback = std::make_shared<DeviceStateCallbackTest>(count1); 1899 std::shared_ptr<DeviceStateCallback> checkMap1 = nullptr; 1900 DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, deviceStateCallback); 1901 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1902 ASSERT_EQ(checkMap1, nullptr); 1903 int count2 = 0; 1904 std::shared_ptr<DiscoveryCallback> deviceDiscoveryCallback = std::make_shared<DiscoveryCallbackTest>(count2); 1905 uint16_t subscribeId = 0; 1906 std::shared_ptr<DiscoveryCallback> checkMap2 = nullptr; 1907 DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, deviceDiscoveryCallback); 1908 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1909 ASSERT_EQ(checkMap2, nullptr); 1910 int count3 = 0; 1911 std::shared_ptr<AuthenticateCallback> authenticateCallback = std::make_shared<AuthenticateCallbackTest>(count3); 1912 std::string deviceId = "1"; 1913 std::shared_ptr<AuthenticateCallback> checkMap3 = nullptr; 1914 DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, authenticateCallback); 1915 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1916 ASSERT_EQ(checkMap3, nullptr); 1917 int count4 = 0; 1918 std::shared_ptr<PublishCallback> devicePublishCallback = std::make_shared<PublishCallbackTest>(count4); 1919 int32_t publishId = 0; 1920 std::shared_ptr<PublishCallback> checkMap4 = nullptr; 1921 DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, devicePublishCallback); 1922 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][subscribeId]; 1923 ASSERT_EQ(checkMap4, nullptr); 1924 std::string testPkgName = ""; 1925 DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(testPkgName); 1926 checkMap = DeviceManagerNotify::GetInstance().dmInitCallback_[pkgName]; 1927 checkMap1 = DeviceManagerNotify::GetInstance().deviceStateCallback_[pkgName]; 1928 checkMap2 = DeviceManagerNotify::GetInstance().deviceDiscoveryCallbacks_[pkgName][subscribeId]; 1929 checkMap3 = DeviceManagerNotify::GetInstance().authenticateCallback_[pkgName][deviceId]; 1930 checkMap4 = DeviceManagerNotify::GetInstance().devicePublishCallbacks_[pkgName][publishId]; 1931 ASSERT_EQ(checkMap, nullptr); 1932 ASSERT_EQ(checkMap1, nullptr); 1933 ASSERT_EQ(checkMap2, nullptr); 1934 ASSERT_EQ(checkMap3, nullptr); 1935 ASSERT_EQ(checkMap4, nullptr); 1936} 1937} 1938} // namespace DistributedHardware 1939} // namespace OHOS 1940