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