1 /* 2 * Copyright (c) 2022 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 <gtest/gtest.h> 17 #include <gmock/gmock.h> 18 19 #include "disc_interface.h" 20 #include "disc_manager.h" 21 #include "softbus_log.h" 22 #include "softbus_error_code.h" 23 #include "ble_mock.h" 24 #include "coap_mock.h" 25 #include "exception_branch_checker.h" 26 27 using namespace testing::ext; 28 using testing::Return; 29 30 namespace OHOS { 31 class DiscManagerMockTest : public testing::Test { 32 public: SetUpTestCase()33 static void SetUpTestCase() 34 {} 35 TearDownTestCase()36 static void TearDownTestCase() 37 {} 38 SetUp()39 void SetUp() override 40 {} 41 TearDown()42 void TearDown() override 43 {} 44 OnDeviceFoundInner(const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)45 static void OnDeviceFoundInner(const DeviceInfo *device, const InnerDeviceInfoAddtions *additions) 46 { 47 innerDeviceInfo_ = *device; 48 } 49 OnDeviceFound(const char * packageName,const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)50 static int32_t OnDeviceFound(const char *packageName, const DeviceInfo *device, 51 const InnerDeviceInfoAddtions *additions) 52 { 53 callbackPackageName_ = packageName; 54 deviceInfo_ = *device; 55 return SOFTBUS_OK; 56 } 57 58 static inline DiscInnerCallback innerCallback_ { OnDeviceFoundInner }; 59 static inline IServerDiscInnerCallback serverCallback_ { OnDeviceFound }; 60 static inline DeviceInfo innerDeviceInfo_; 61 static inline DeviceInfo deviceInfo_; 62 63 static constexpr int32_t PUBLISH_ID1 = 1; 64 static constexpr int32_t PUBLISH_ID2 = 2; 65 static constexpr int32_t PUBLISH_ID3 = 3; 66 static constexpr int32_t PUBLISH_ID4 = 4; 67 static constexpr int32_t PUBLISH_ID5 = 5; 68 static constexpr int32_t PUBLISH_ID6 = 6; 69 static constexpr int32_t PUBLISH_ID7 = 7; 70 static constexpr int32_t PUBLISH_ID8 = 8; 71 72 static constexpr int32_t SUBSCRIBE_ID1 = 1; 73 static constexpr int32_t SUBSCRIBE_ID2 = 2; 74 static constexpr int32_t SUBSCRIBE_ID3 = 3; 75 static constexpr int32_t SUBSCRIBE_ID4 = 4; 76 static constexpr int32_t SUBSCRIBE_ID5 = 5; 77 static constexpr int32_t SUBSCRIBE_ID6 = 6; 78 static constexpr int32_t SUBSCRIBE_ID7 = 7; 79 static constexpr int32_t SUBSCRIBE_ID8 = 8; 80 81 static inline std::string callbackPackageName_; 82 static inline const char *packageName_ = "TestPackage"; 83 static inline const char *packageName1_ = "TestPackage1"; 84 static inline const char *largePackageName_ = 85 "aaaaaaaaabbbbbbbbccccccccddddddddaaaaaaaaabbbbbbbbccccccccdddddddde"; 86 }; 87 88 /* 89 * @tc.name: DiscManagerInit001 90 * @tc.desc: discovery manager init failed 91 * @tc.type: FUNC 92 * @tc.require: 93 */ 94 HWTEST_F(DiscManagerMockTest, DiscManagerInit001, TestSize.Level1) 95 { 96 DLOGI("DiscManagerInit001 begin ----"); 97 BleMock bleMock; 98 bleMock.SetupStub(); 99 EXPECT_CALL(bleMock, DiscBleInit).WillRepeatedly(Return(nullptr)); 100 CoapMock coapMock; 101 coapMock.SetupStub(); 102 EXPECT_CALL(coapMock, DiscCoapInit).WillRepeatedly(Return(nullptr)); 103 104 EXPECT_EQ(DiscMgrInit(), SOFTBUS_ERR); 105 DLOGI("DiscManagerInit001 end ----"); 106 } 107 108 /* 109 * @tc.name: DiscManagerInit002 110 * @tc.desc: discovery manager init success 111 * @tc.type: FUNC 112 * @tc.require: 113 */ 114 HWTEST_F(DiscManagerMockTest, DiscManagerInit002, TestSize.Level1) 115 { 116 DLOGI("DiscManagerInit002 begin ----"); 117 BleMock bleMock; 118 bleMock.SetupStub(); 119 CoapMock coapMock; 120 coapMock.SetupStub(); 121 122 EXPECT_EQ(DiscMgrInit(), SOFTBUS_OK); 123 DLOGI("DiscManagerInit002 end ----"); 124 } 125 126 /* 127 * @tc.name: ClientDeathCallback001 128 * @tc.desc: client death callback 129 * @tc.type: FUNC 130 * @tc.require: 131 */ 132 HWTEST_F(DiscManagerMockTest, ClientDeathCallback001, TestSize.Level1) 133 { 134 DLOGI("ClientDeathCallback001 begin ----"); 135 { 136 ExceptionBranchChecker checker("pkgName is null"); 137 DiscMgrDeathCallback(nullptr); 138 EXPECT_EQ(checker.GetResult(), true); 139 } 140 { 141 ExceptionBranchChecker checker("Test is dead"); 142 DiscMgrDeathCallback("Test"); 143 EXPECT_EQ(checker.GetResult(), true); 144 } 145 DLOGI("ClientDeathCallback001 end ----"); 146 } 147 148 /* 149 * @tc.name: DiscSetDiscoverCallback001 150 * @tc.desc: set discovery callback 151 * @tc.type: FUNC 152 * @tc.require: 153 */ 154 HWTEST_F(DiscManagerMockTest, DiscSetDiscoverCallback001, TestSize.Level1) 155 { 156 DLOGI("DiscSetDiscoverCallback001 begin ----"); 157 EXPECT_EQ(DiscSetDiscoverCallback(static_cast<DiscModule>(0), &innerCallback_), SOFTBUS_INVALID_PARAM); 158 EXPECT_EQ(DiscSetDiscoverCallback(static_cast<DiscModule>(MODULE_MAX + 1), &innerCallback_), SOFTBUS_INVALID_PARAM); 159 EXPECT_EQ(DiscSetDiscoverCallback(MODULE_LNN, nullptr), SOFTBUS_INVALID_PARAM); 160 EXPECT_EQ(DiscSetDiscoverCallback(MODULE_LNN, &innerCallback_), SOFTBUS_OK); 161 DLOGI("DiscSetDiscoverCallback001 end ----"); 162 } 163 164 /* 165 * @tc.name: DiscPublish001 166 * @tc.desc: invalid parameters 167 * @tc.type: FUNC 168 * @tc.require: 169 */ 170 HWTEST_F(DiscManagerMockTest, DiscPublish001, TestSize.Level1) 171 { 172 DLOGI("DiscPublish001 begin ----"); 173 PublishInfo info; 174 info.publishId = 0; 175 EXPECT_EQ(DiscPublish(static_cast<DiscModule>(0), &info), SOFTBUS_INVALID_PARAM); 176 EXPECT_EQ(DiscPublish(static_cast<DiscModule>(MODULE_MAX + 1), &info), SOFTBUS_INVALID_PARAM); 177 EXPECT_EQ(DiscPublish(MODULE_LNN, nullptr), SOFTBUS_INVALID_PARAM); 178 179 info.mode = DISCOVER_MODE_PASSIVE; 180 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 181 182 info.mode = DISCOVER_MODE_ACTIVE; 183 info.medium = USB; 184 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 185 186 info.medium = BLE; 187 info.freq = FREQ_BUTT; 188 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 189 190 info.freq = LOW; 191 info.capabilityData = nullptr; 192 info.dataLen = 10; 193 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 194 195 info.capabilityData = nullptr; 196 info.dataLen = 0; 197 info.capability = "test"; 198 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 199 200 DLOGI("DiscPublish001 end ----"); 201 } 202 203 /* 204 * @tc.name: DiscPublish002 205 * @tc.desc: inner active publish 206 * @tc.type: FUNC 207 * @tc.require: 208 */ 209 HWTEST_F(DiscManagerMockTest, DiscPublish002, TestSize.Level1) 210 { 211 DLOGI("DiscPublish002 begin ----"); 212 PublishInfo info; 213 info.publishId = 0; 214 info.mode = DISCOVER_MODE_ACTIVE; 215 info.medium = BLE; 216 info.freq = LOW; 217 info.capabilityData = (uint8_t *)"test"; 218 info.dataLen = 4; 219 info.capability = "osdCapability"; 220 221 { 222 BleMock bleMock; 223 bleMock.SetupStub(); 224 EXPECT_CALL(bleMock, Publish).WillRepeatedly(Return(SOFTBUS_ERR)); 225 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_ERR); 226 } 227 228 info.publishId = PUBLISH_ID1; 229 { 230 BleMock bleMock; 231 bleMock.SetupStub(); 232 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_OK); 233 } 234 235 info.publishId = PUBLISH_ID2; 236 info.medium = COAP; 237 { 238 CoapMock coapMock; 239 coapMock.SetupStub(); 240 EXPECT_CALL(coapMock, Publish).WillRepeatedly(Return(SOFTBUS_ERR)); 241 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_ERR); 242 } 243 244 info.publishId = PUBLISH_ID3; 245 { 246 CoapMock coapMock; 247 coapMock.SetupStub(); 248 EXPECT_EQ(DiscPublish(MODULE_LNN, &info), SOFTBUS_OK); 249 } 250 DLOGI("DiscPublish002 end ----"); 251 } 252 253 /* 254 * @tc.name: DiscStartScan001 255 * @tc.desc: invalid parameters 256 * @tc.type: FUNC 257 * @tc.require: 258 */ 259 HWTEST_F(DiscManagerMockTest, DiscStartScan001, TestSize.Level1) 260 { 261 DLOGI("DiscStartScan001 begin ----"); 262 PublishInfo info; 263 info.publishId = 0; 264 EXPECT_EQ(DiscStartScan(static_cast<DiscModule>(0), &info), SOFTBUS_INVALID_PARAM); 265 EXPECT_EQ(DiscStartScan(static_cast<DiscModule>(MODULE_MAX + 1), &info), SOFTBUS_INVALID_PARAM); 266 EXPECT_EQ(DiscStartScan(MODULE_LNN, nullptr), SOFTBUS_INVALID_PARAM); 267 268 info.mode = DISCOVER_MODE_ACTIVE; 269 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 270 271 info.mode = DISCOVER_MODE_PASSIVE; 272 info.medium = USB; 273 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 274 275 info.medium = BLE; 276 info.freq = FREQ_BUTT; 277 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 278 279 info.freq = LOW; 280 info.capabilityData = nullptr; 281 info.dataLen = 10; 282 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 283 284 info.capabilityData = nullptr; 285 info.dataLen = 0; 286 info.capability = "test"; 287 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 288 289 DLOGI("DiscStartScan001 end ----"); 290 } 291 292 /* 293 * @tc.name: DiscStartScan002 294 * @tc.desc: inner passive publish 295 * @tc.type: FUNC 296 * @tc.require: 297 */ 298 HWTEST_F(DiscManagerMockTest, DiscStartScan002, TestSize.Level1) 299 { 300 DLOGI("DiscStartScan002 begin ----"); 301 PublishInfo info; 302 info.publishId = 0; 303 info.mode = DISCOVER_MODE_PASSIVE; 304 info.medium = BLE; 305 info.freq = LOW; 306 info.capabilityData = (uint8_t *)"test"; 307 info.dataLen = 4; 308 info.capability = "osdCapability"; 309 310 info.publishId = PUBLISH_ID4; 311 { 312 BleMock bleMock; 313 bleMock.SetupStub(); 314 EXPECT_CALL(bleMock, StartScan).WillRepeatedly(Return(SOFTBUS_ERR)); 315 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_ERR); 316 } 317 318 info.publishId = PUBLISH_ID5; 319 { 320 BleMock bleMock; 321 bleMock.SetupStub(); 322 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_OK); 323 } 324 325 info.publishId = PUBLISH_ID6; 326 info.medium = COAP; 327 { 328 CoapMock coapMock; 329 coapMock.SetupStub(); 330 EXPECT_CALL(coapMock, StartScan).WillRepeatedly(Return(SOFTBUS_ERR)); 331 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_ERR); 332 } 333 334 info.publishId = PUBLISH_ID7; 335 { 336 CoapMock coapMock; 337 coapMock.SetupStub(); 338 EXPECT_EQ(DiscStartScan(MODULE_LNN, &info), SOFTBUS_OK); 339 } 340 DLOGI("DiscStartScan002 end ----"); 341 } 342 343 /* 344 * @tc.name: DiscUnpublish001 345 * @tc.desc: cancel publish 346 * @tc.type: FUNC 347 * @tc.require: 348 */ 349 HWTEST_F(DiscManagerMockTest, DiscUnpublish001, TestSize.Level1) 350 { 351 DLOGI("DiscUnpublish001 begin ----"); 352 EXPECT_EQ(DiscUnpublish(static_cast<DiscModule>(0), 0), SOFTBUS_INVALID_PARAM); 353 EXPECT_EQ(DiscUnpublish(static_cast<DiscModule>(MODULE_MAX + 1), 0), SOFTBUS_INVALID_PARAM); 354 EXPECT_EQ(DiscUnpublish(MODULE_LNN, -1), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 355 356 { 357 BleMock bleMock; 358 bleMock.SetupStub(); 359 CoapMock coapMock; 360 coapMock.SetupStub(); 361 EXPECT_CALL(bleMock, Unpublish).WillRepeatedly(Return(SOFTBUS_ERR)); 362 EXPECT_CALL(bleMock, StopScan).WillRepeatedly(Return(SOFTBUS_ERR)); 363 364 EXPECT_EQ(DiscUnpublish(MODULE_LNN, PUBLISH_ID1), SOFTBUS_ERR); 365 EXPECT_EQ(DiscUnpublish(MODULE_LNN, PUBLISH_ID5), SOFTBUS_ERR); 366 } 367 { 368 BleMock bleMock; 369 bleMock.SetupStub(); 370 CoapMock coapMock; 371 coapMock.SetupStub(); 372 373 EXPECT_EQ(DiscUnpublish(MODULE_LNN, PUBLISH_ID3), SOFTBUS_OK); 374 EXPECT_EQ(DiscUnpublish(MODULE_LNN, PUBLISH_ID7), SOFTBUS_OK); 375 } 376 377 DLOGI("DiscUnpublish001 end ----"); 378 } 379 380 /* 381 * @tc.name: DiscStartAdvertise001 382 * @tc.desc: inner active subscribe 383 * @tc.type: FUNC 384 * @tc.require: 385 */ 386 HWTEST_F(DiscManagerMockTest, DiscStartAdvertise001, TestSize.Level1) 387 { 388 DLOGI("DiscStartAdvertise001 begin ----"); 389 SubscribeInfo info; 390 info.subscribeId = 0; 391 EXPECT_EQ(DiscStartAdvertise(static_cast<DiscModule>(0), &info), SOFTBUS_INVALID_PARAM); 392 EXPECT_EQ(DiscStartAdvertise(static_cast<DiscModule>(MODULE_MAX + 1), &info), SOFTBUS_INVALID_PARAM); 393 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, nullptr), SOFTBUS_INVALID_PARAM); 394 395 info.mode = DISCOVER_MODE_PASSIVE; 396 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 397 398 info.mode = DISCOVER_MODE_ACTIVE; 399 info.medium = USB; 400 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 401 402 info.medium = BLE; 403 info.freq = FREQ_BUTT; 404 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 405 406 info.freq = LOW; 407 info.capabilityData = nullptr; 408 info.dataLen = 10; 409 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 410 411 info.capabilityData = nullptr; 412 info.dataLen = 0; 413 info.capability = "test"; 414 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 415 416 DLOGI("DiscStartAdvertise001 end ----"); 417 } 418 419 /* 420 * @tc.name: DiscStartAdvertise002 421 * @tc.desc: inner active subscribe 422 * @tc.type: FUNC 423 * @tc.require: 424 */ 425 HWTEST_F(DiscManagerMockTest, DiscStartAdvertise002, TestSize.Level1) 426 { 427 DLOGI("DiscStartAdvertise002 begin ----"); 428 SubscribeInfo info; 429 info.subscribeId = 0; 430 info.mode = DISCOVER_MODE_ACTIVE; 431 info.medium = BLE; 432 info.freq = LOW; 433 info.capabilityData = (uint8_t *)"test"; 434 info.dataLen = 4; 435 info.capability = "osdCapability"; 436 437 { 438 BleMock bleMock; 439 bleMock.SetupStub(); 440 EXPECT_CALL(bleMock, StartAdvertise).WillRepeatedly(Return(SOFTBUS_ERR)); 441 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_ERR); 442 } 443 444 info.subscribeId = SUBSCRIBE_ID1; 445 { 446 BleMock bleMock; 447 bleMock.SetupStub(); 448 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_OK); 449 } 450 451 info.subscribeId = SUBSCRIBE_ID2; 452 info.medium = COAP; 453 { 454 CoapMock coapMock; 455 coapMock.SetupStub(); 456 EXPECT_CALL(coapMock, StartAdvertise).WillRepeatedly(Return(SOFTBUS_ERR)); 457 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_ERR); 458 } 459 460 info.subscribeId = SUBSCRIBE_ID3; 461 { 462 CoapMock coapMock; 463 coapMock.SetupStub(); 464 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_OK); 465 } 466 DLOGI("DiscStartAdvertise002 end ----"); 467 } 468 469 /* 470 * @tc.name: DiscSubscribe001 471 * @tc.desc: invalid parameters 472 * @tc.type: FUNC 473 * @tc.require: 474 */ 475 HWTEST_F(DiscManagerMockTest, DiscSubscribe001, TestSize.Level1) 476 { 477 DLOGI("DiscSubscribe001 begin ----"); 478 SubscribeInfo info; 479 info.subscribeId = 0; 480 EXPECT_EQ(DiscSubscribe(static_cast<DiscModule>(0), &info), SOFTBUS_INVALID_PARAM); 481 EXPECT_EQ(DiscSubscribe(static_cast<DiscModule>(MODULE_MAX + 1), &info), SOFTBUS_INVALID_PARAM); 482 EXPECT_EQ(DiscSubscribe(MODULE_LNN, nullptr), SOFTBUS_INVALID_PARAM); 483 484 info.mode = DISCOVER_MODE_ACTIVE; 485 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 486 487 info.mode = DISCOVER_MODE_PASSIVE; 488 info.medium = USB; 489 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 490 491 info.medium = BLE; 492 info.freq = FREQ_BUTT; 493 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 494 495 info.freq = LOW; 496 info.capabilityData = nullptr; 497 info.dataLen = 10; 498 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_INVALID_PARAM); 499 500 info.capabilityData = nullptr; 501 info.dataLen = 0; 502 info.capability = "test"; 503 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 504 505 DLOGI("DiscSubscribe001 end ----"); 506 } 507 508 /* 509 * @tc.name: DiscSubscribe002 510 * @tc.desc: inner passive subscribe 511 * @tc.type: FUNC 512 * @tc.require: 513 */ 514 HWTEST_F(DiscManagerMockTest, DiscSubscribe002, TestSize.Level1) 515 { 516 DLOGI("DiscSubscribe002 begin ----"); 517 SubscribeInfo info; 518 info.subscribeId = 0; 519 info.mode = DISCOVER_MODE_PASSIVE; 520 info.medium = BLE; 521 info.freq = LOW; 522 info.capabilityData = (uint8_t *)"test"; 523 info.dataLen = 4; 524 info.capability = "osdCapability"; 525 526 info.subscribeId = SUBSCRIBE_ID4; 527 { 528 BleMock bleMock; 529 bleMock.SetupStub(); 530 EXPECT_CALL(bleMock, Subscribe).WillRepeatedly(Return(SOFTBUS_ERR)); 531 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_ERR); 532 } 533 534 info.subscribeId = SUBSCRIBE_ID5; 535 { 536 BleMock bleMock; 537 bleMock.SetupStub(); 538 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_OK); 539 } 540 541 info.subscribeId = SUBSCRIBE_ID6; 542 info.medium = COAP; 543 { 544 CoapMock coapMock; 545 coapMock.SetupStub(); 546 EXPECT_CALL(coapMock, Subscribe).WillRepeatedly(Return(SOFTBUS_ERR)); 547 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_ERR); 548 } 549 550 info.subscribeId = SUBSCRIBE_ID7; 551 { 552 CoapMock coapMock; 553 coapMock.SetupStub(); 554 EXPECT_EQ(DiscSubscribe(MODULE_LNN, &info), SOFTBUS_OK); 555 } 556 DLOGI("DiscSubscribe002 end ----"); 557 } 558 559 /* 560 * @tc.name: DiscStopAdvertise001 561 * @tc.desc: stop advertise 562 * @tc.type: FUNC 563 * @tc.require: 564 */ 565 HWTEST_F(DiscManagerMockTest, DiscStopAdvertise001, TestSize.Level1) 566 { 567 DLOGI("DiscStopAdvertise001 begin ----"); 568 EXPECT_EQ(DiscStopAdvertise(static_cast<DiscModule>(0), 0), SOFTBUS_INVALID_PARAM); 569 EXPECT_EQ(DiscStopAdvertise(static_cast<DiscModule>(MODULE_MAX + 1), 0), SOFTBUS_INVALID_PARAM); 570 EXPECT_EQ(DiscStopAdvertise(MODULE_LNN, -1), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 571 572 { 573 BleMock bleMock; 574 bleMock.SetupStub(); 575 EXPECT_CALL(bleMock, StopAdvertise).WillRepeatedly(Return(SOFTBUS_ERR)); 576 EXPECT_CALL(bleMock, Unsubscribe).WillRepeatedly(Return(SOFTBUS_ERR)); 577 578 EXPECT_EQ(DiscStopAdvertise(MODULE_LNN, SUBSCRIBE_ID1), SOFTBUS_ERR); 579 EXPECT_EQ(DiscStopAdvertise(MODULE_LNN, SUBSCRIBE_ID5), SOFTBUS_ERR); 580 } 581 { 582 CoapMock coapMock; 583 coapMock.SetupStub(); 584 585 EXPECT_EQ(DiscStopAdvertise(MODULE_LNN, SUBSCRIBE_ID3), SOFTBUS_OK); 586 EXPECT_EQ(DiscStopAdvertise(MODULE_LNN, SUBSCRIBE_ID7), SOFTBUS_OK); 587 } 588 589 DLOGI("DiscStopAdvertise001 end ----"); 590 } 591 592 /* 593 * @tc.name: DiscPublishService001 594 * @tc.desc: active publish 595 * @tc.type: FUNC 596 * @tc.require: 597 */ 598 HWTEST_F(DiscManagerMockTest, DiscPublishService001, TestSize.Level1) 599 { 600 DLOGI("DiscPublishService001 begin ----"); 601 PublishInfo info; 602 info.medium = BLE; 603 info.mode = DISCOVER_MODE_ACTIVE; 604 info.freq = LOW; 605 info.capability = "test"; 606 info.capabilityData = (uint8_t *)"test"; 607 info.dataLen = 4; 608 609 EXPECT_EQ(DiscPublishService(nullptr, &info), SOFTBUS_INVALID_PARAM); 610 EXPECT_EQ(DiscPublishService(packageName_, nullptr), SOFTBUS_INVALID_PARAM); 611 EXPECT_EQ(DiscPublishService(largePackageName_, &info), SOFTBUS_INVALID_PARAM); 612 EXPECT_EQ(DiscPublishService(packageName_, &info), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 613 614 info.publishId = PUBLISH_ID8; 615 info.capability = "osdCapability"; 616 { 617 BleMock bleMock; 618 bleMock.SetupStub(); 619 EXPECT_CALL(bleMock, Publish).WillRepeatedly(Return(SOFTBUS_ERR)); 620 EXPECT_EQ(DiscPublishService(packageName_, &info), SOFTBUS_ERR); 621 } 622 { 623 BleMock bleMock; 624 bleMock.SetupStub(); 625 EXPECT_EQ(DiscPublishService(packageName_, &info), SOFTBUS_OK); 626 EXPECT_EQ(DiscPublishService(packageName_, &info), SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM); 627 } 628 629 DLOGI("DiscPublishService001 end ----"); 630 } 631 632 /* 633 * @tc.name: DiscUnPublishService001 634 * @tc.desc: cancel publish 635 * @tc.type: FUNC 636 * @tc.require: 637 */ 638 HWTEST_F(DiscManagerMockTest, DiscUnPublishService001, TestSize.Level1) 639 { 640 DLOGI("DiscUnPublishService001 begin ----"); 641 642 EXPECT_EQ(DiscUnPublishService(nullptr, 0), SOFTBUS_INVALID_PARAM); 643 EXPECT_EQ(DiscUnPublishService(largePackageName_, 0), SOFTBUS_INVALID_PARAM); 644 EXPECT_EQ(DiscUnPublishService(packageName_, -1), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 645 646 { 647 BleMock bleMock; 648 bleMock.SetupStub(); 649 EXPECT_CALL(bleMock, Unpublish).WillRepeatedly(Return(SOFTBUS_ERR)); 650 EXPECT_EQ(DiscUnPublishService(packageName_, PUBLISH_ID8), SOFTBUS_ERR); 651 } 652 653 { 654 PublishInfo info; 655 info.publishId = PUBLISH_ID8; 656 info.medium = BLE; 657 info.mode = DISCOVER_MODE_ACTIVE; 658 info.freq = LOW; 659 info.capability = "osdCapability"; 660 info.capabilityData = (uint8_t *)"test"; 661 info.dataLen = 4; 662 663 BleMock bleMock; 664 bleMock.SetupStub(); 665 EXPECT_EQ(DiscPublishService(packageName_, &info), SOFTBUS_OK); 666 EXPECT_EQ(DiscUnPublishService(packageName_, PUBLISH_ID8), SOFTBUS_OK); 667 } 668 669 DLOGI("DiscUnPublishService001 end ----"); 670 } 671 672 /* 673 * @tc.name: DiscStartDiscovery001 674 * @tc.desc: start active discovery 675 * @tc.type: FUNC 676 * @tc.require: 677 */ 678 HWTEST_F(DiscManagerMockTest, DiscStartDiscovery001, TestSize.Level1) 679 { 680 DLOGI("DiscPublishService001 begin ----"); 681 SubscribeInfo info; 682 info.medium = BLE; 683 info.mode = DISCOVER_MODE_ACTIVE; 684 info.freq = LOW; 685 info.capability = "test"; 686 info.capabilityData = (uint8_t *)"test"; 687 info.dataLen = 4; 688 689 EXPECT_EQ(DiscStartDiscovery(nullptr, &info, &serverCallback_), SOFTBUS_INVALID_PARAM); 690 EXPECT_EQ(DiscStartDiscovery(largePackageName_, &info, &serverCallback_), SOFTBUS_INVALID_PARAM); 691 EXPECT_EQ(DiscStartDiscovery(packageName_, nullptr, &serverCallback_), SOFTBUS_INVALID_PARAM); 692 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, nullptr), SOFTBUS_INVALID_PARAM); 693 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_CREATE); 694 695 info.subscribeId = SUBSCRIBE_ID8; 696 info.capability = "osdCapability"; 697 { 698 BleMock bleMock; 699 bleMock.SetupStub(); 700 EXPECT_CALL(bleMock, StartAdvertise).WillRepeatedly(Return(SOFTBUS_ERR)); 701 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_ERR); 702 } 703 704 { 705 BleMock bleMock; 706 bleMock.SetupStub(); 707 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_OK); 708 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_DISCOVER_MANAGER_DUPLICATE_PARAM); 709 } 710 711 DLOGI("DiscStartDiscovery001 end ----"); 712 } 713 714 /* 715 * @tc.name: DiscStopDiscovery001 716 * @tc.desc: stop discovery 717 * @tc.type: FUNC 718 * @tc.require: 719 */ 720 HWTEST_F(DiscManagerMockTest, DiscStopDiscovery001, TestSize.Level1) 721 { 722 DLOGI("DiscStopDiscovery001 begin ----"); 723 724 EXPECT_EQ(DiscStopDiscovery(nullptr, 0), SOFTBUS_INVALID_PARAM); 725 EXPECT_EQ(DiscStopDiscovery(largePackageName_, 0), SOFTBUS_INVALID_PARAM); 726 EXPECT_EQ(DiscStopDiscovery(packageName_, -1), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 727 728 { 729 BleMock bleMock; 730 bleMock.SetupStub(); 731 EXPECT_CALL(bleMock, StopAdvertise).WillRepeatedly(Return(SOFTBUS_ERR)); 732 EXPECT_EQ(DiscStopDiscovery(packageName_, SUBSCRIBE_ID8), SOFTBUS_ERR); 733 EXPECT_EQ(DiscStopDiscovery(packageName_, SUBSCRIBE_ID8), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 734 } 735 736 { 737 SubscribeInfo info; 738 info.subscribeId = SUBSCRIBE_ID8; 739 info.medium = BLE; 740 info.mode = DISCOVER_MODE_ACTIVE; 741 info.freq = LOW; 742 info.capability = "osdCapability"; 743 info.capabilityData = (uint8_t *)"test"; 744 info.dataLen = 4; 745 746 BleMock bleMock; 747 bleMock.SetupStub(); 748 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_OK); 749 EXPECT_EQ(DiscStopDiscovery(packageName_, PUBLISH_ID8), SOFTBUS_OK); 750 EXPECT_EQ(DiscStopDiscovery(packageName_, PUBLISH_ID8), SOFTBUS_DISCOVER_MANAGER_INFO_NOT_DELETE); 751 } 752 753 DLOGI("DiscStopDiscovery001 end ----"); 754 } 755 756 /* 757 * @tc.name: DiscMgrDeathCallback001 758 * @tc.desc: client death handler 759 * @tc.type: FUNC 760 * @tc.require: 761 */ 762 HWTEST_F(DiscManagerMockTest, DiscMgrDeathCallback001, TestSize.Level1) 763 { 764 DLOGI("DiscMgrDeathCallback001 begin ----"); 765 { 766 SubscribeInfo info; 767 info.subscribeId = SUBSCRIBE_ID8; 768 info.medium = BLE; 769 info.mode = DISCOVER_MODE_ACTIVE; 770 info.freq = LOW; 771 info.capability = "osdCapability"; 772 info.capabilityData = (uint8_t *)"test"; 773 info.dataLen = 4; 774 775 BleMock bleMock; 776 bleMock.SetupStub(); 777 EXPECT_EQ(DiscStartDiscovery(packageName_, &info, &serverCallback_), SOFTBUS_OK); 778 EXPECT_EQ(DiscStartDiscovery(packageName1_, &info, &serverCallback_), SOFTBUS_OK); 779 EXPECT_EQ(DiscStartAdvertise(MODULE_LNN, &info), SOFTBUS_OK); 780 EXPECT_EQ(DiscSetDiscoverCallback(MODULE_LNN, &innerCallback_), SOFTBUS_OK); 781 SetCallLnnStatus(true); 782 DiscMgrDeathCallback(packageName1_); 783 784 DeviceInfo deviceInfo; 785 deviceInfo.capabilityBitmapNum = 1; 786 deviceInfo.capabilityBitmap[0] = 1 << OSD_CAPABILITY_BITMAP; 787 BleMock::InjectDeviceFoundEvent(&deviceInfo); 788 EXPECT_EQ(callbackPackageName_, packageName_); 789 EXPECT_EQ(deviceInfo_.capabilityBitmapNum, deviceInfo.capabilityBitmapNum); 790 EXPECT_EQ(innerDeviceInfo_.capabilityBitmapNum, deviceInfo.capabilityBitmapNum); 791 } 792 DLOGI("DiscMgrDeathCallback001 end ----"); 793 } 794 795 /* 796 * @tc.name: DiscManagerDeinit001 797 * @tc.desc: discovery manager init success 798 * @tc.type: FUNC 799 * @tc.require: 800 */ 801 HWTEST_F(DiscManagerMockTest, DiscManagerDeinit001, TestSize.Level1) 802 { 803 DLOGI("DiscManagerDeinit001 begin ----"); 804 BleMock bleMock; 805 bleMock.SetupStub(); 806 CoapMock coapMock; 807 coapMock.SetupStub(); 808 809 ExceptionBranchChecker checker("disc manager deinit success"); 810 DiscMgrDeinit(); 811 EXPECT_EQ(checker.GetResult(), true); 812 DLOGI("DiscManagerDeinit001 end ----"); 813 } 814 }