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