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 <unistd.h>
18
19 #include "disc_ble_dispatcher.h"
20 #include "disc_interface.h"
21 #include "softbus_errcode.h"
22 #include "softbus_log.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 typedef struct {
28 int32_t publishCntA;
29 int32_t startScanCntA;
30 int32_t unpublishCntA;
31 int32_t stopScanCntA;
32 int32_t startAdvertiseCntA;
33 int32_t subscribeCntA;
34 int32_t unsubscribeCntA;
35 int32_t stopAdvertiseCntA;
36 int32_t linkStatusChangedCntA;
37 int32_t updateLocalDeviceInfoCntA;
38 } InterfaceFunCntA;
39
40 typedef struct {
41 int32_t publishCntB;
42 int32_t startScanCntB;
43 int32_t unpublishCntB;
44 int32_t stopScanCntB;
45 int32_t startAdvertiseCntB;
46 int32_t subscribeCntB;
47 int32_t stopAdvertiseCntB;
48 int32_t unsubscribeCntB;
49 } InterfaceFunCntB;
50
51 #define IS_CONCERNA 1
52 #define IS_CONCERNB 2
53 InterfaceFunCntA g_interfaceFunCntA = {
54 .publishCntA = 0,
55 .startScanCntA = 0,
56 .unpublishCntA = 0,
57 .stopScanCntA = 0,
58 .startAdvertiseCntA = 0,
59 .subscribeCntA = 0,
60 .unsubscribeCntA = 0,
61 .stopAdvertiseCntA = 0,
62 .linkStatusChangedCntA = 0,
63 .updateLocalDeviceInfoCntA = 0
64 };
65
66 InterfaceFunCntB g_interfaceFunCntB = {
67 .publishCntB = 0,
68 .startScanCntB = 0,
69 .unpublishCntB = 0,
70 .stopScanCntB = 0,
71 .startAdvertiseCntB = 0,
72 .subscribeCntB = 0,
73 .stopAdvertiseCntB = 0,
74 .unsubscribeCntB = 0,
75 };
IsConcernA(uint32_t capability)76 static bool IsConcernA(uint32_t capability)
77 {
78 if (capability == IS_CONCERNA) {
79 return true;
80 }
81 return false;
82 }
83
IsConcernB(uint32_t capability)84 static bool IsConcernB(uint32_t capability)
85 {
86 if (capability == IS_CONCERNB) {
87 return true;
88 }
89 return false;
90 }
91
PublishA(const PublishOption * option)92 static int32_t PublishA(const PublishOption *option)
93 {
94 if (IsConcernA(option->capabilityBitmap[0])) {
95 g_interfaceFunCntA.publishCntA = 1;
96 return SOFTBUS_OK;
97 }
98 return SOFTBUS_ERR;
99 }
100
StartScanA(const PublishOption * option)101 static int32_t StartScanA(const PublishOption *option)
102 {
103 if (IsConcernA(option->capabilityBitmap[0])) {
104 g_interfaceFunCntA.startScanCntA = 1;
105 return SOFTBUS_OK;
106 }
107 return SOFTBUS_ERR;
108 }
109
UnpublishA(const PublishOption * option)110 static int32_t UnpublishA(const PublishOption *option)
111 {
112 if (IsConcernA(option->capabilityBitmap[0])) {
113 g_interfaceFunCntA.unpublishCntA = 1;
114 return SOFTBUS_OK;
115 }
116 return SOFTBUS_ERR;
117 }
118
StopScanA(const PublishOption * option)119 static int32_t StopScanA(const PublishOption *option)
120 {
121 if (IsConcernA(option->capabilityBitmap[0])) {
122 g_interfaceFunCntA.stopScanCntA = 1;
123 return SOFTBUS_OK;
124 }
125 return SOFTBUS_ERR;
126 }
127
StartAdvertiseA(const SubscribeOption * option)128 static int32_t StartAdvertiseA(const SubscribeOption *option)
129 {
130 if (IsConcernA(option->capabilityBitmap[0])) {
131 g_interfaceFunCntA.startAdvertiseCntA = 1;
132 return SOFTBUS_OK;
133 }
134 return SOFTBUS_ERR;
135 }
136
SubscribeA(const SubscribeOption * option)137 static int32_t SubscribeA(const SubscribeOption *option)
138 {
139 if (IsConcernA(option->capabilityBitmap[0])) {
140 g_interfaceFunCntA.subscribeCntA = 1;
141 return SOFTBUS_OK;
142 }
143 return SOFTBUS_ERR;
144 }
145
UnsubscribeA(const SubscribeOption * option)146 static int32_t UnsubscribeA(const SubscribeOption *option)
147 {
148 if (IsConcernA(option->capabilityBitmap[0])) {
149 g_interfaceFunCntA.unsubscribeCntA = 1;
150 return SOFTBUS_OK;
151 }
152 return SOFTBUS_ERR;
153 }
154
StopAdvertiseA(const SubscribeOption * option)155 static int32_t StopAdvertiseA(const SubscribeOption *option)
156 {
157 if (IsConcernA(option->capabilityBitmap[0])) {
158 g_interfaceFunCntA.stopAdvertiseCntA = 1;
159 return SOFTBUS_OK;
160 }
161 return SOFTBUS_ERR;
162 }
163
LinkStatusChangedA(LinkStatus status)164 static void LinkStatusChangedA(LinkStatus status)
165 {
166 g_interfaceFunCntA.linkStatusChangedCntA = 1;
167 }
168
UpdateLocalDeviceInfoA(InfoTypeChanged type)169 static void UpdateLocalDeviceInfoA(InfoTypeChanged type)
170 {
171 (void)type;
172 g_interfaceFunCntA.updateLocalDeviceInfoCntA = 1;
173 }
174
PublishB(const PublishOption * option)175 static int32_t PublishB(const PublishOption *option)
176 {
177 if (IsConcernB(option->capabilityBitmap[0])) {
178 g_interfaceFunCntB.publishCntB = 1;
179 return SOFTBUS_OK;
180 }
181 return SOFTBUS_ERR;
182 }
183
StartScanB(const PublishOption * option)184 static int32_t StartScanB(const PublishOption *option)
185 {
186 if (IsConcernB(option->capabilityBitmap[0])) {
187 g_interfaceFunCntB.startScanCntB = 1;
188 return SOFTBUS_OK;
189 }
190 return SOFTBUS_ERR;
191 }
192
UnpublishB(const PublishOption * option)193 static int32_t UnpublishB(const PublishOption *option)
194 {
195 if (IsConcernB(option->capabilityBitmap[0])) {
196 g_interfaceFunCntB.unpublishCntB = 1;
197 return SOFTBUS_OK;
198 }
199 return SOFTBUS_ERR;
200 }
201
StopScanB(const PublishOption * option)202 static int32_t StopScanB(const PublishOption *option)
203 {
204 if (IsConcernB(option->capabilityBitmap[0])) {
205 g_interfaceFunCntB.stopScanCntB = 1;
206 return SOFTBUS_OK;
207 }
208 return SOFTBUS_ERR;
209 }
210
StartAdvertiseB(const SubscribeOption * option)211 static int32_t StartAdvertiseB(const SubscribeOption *option)
212 {
213 if (IsConcernB(option->capabilityBitmap[0])) {
214 g_interfaceFunCntB.startAdvertiseCntB = 1;
215 return SOFTBUS_OK;
216 }
217 return SOFTBUS_ERR;
218 }
219
SubscribeB(const SubscribeOption * option)220 static int32_t SubscribeB(const SubscribeOption *option)
221 {
222 if (IsConcernB(option->capabilityBitmap[0])) {
223 g_interfaceFunCntB.subscribeCntB = 1;
224 return SOFTBUS_OK;
225 }
226 return SOFTBUS_ERR;
227 }
228
UnsubscribeB(const SubscribeOption * option)229 static int32_t UnsubscribeB(const SubscribeOption *option)
230 {
231 if (IsConcernB(option->capabilityBitmap[0])) {
232 g_interfaceFunCntB.unsubscribeCntB = 1;
233 return SOFTBUS_OK;
234 }
235 return SOFTBUS_ERR;
236 }
237
StopAdvertiseB(const SubscribeOption * option)238 static int32_t StopAdvertiseB(const SubscribeOption *option)
239 {
240 if (IsConcernB(option->capabilityBitmap[0])) {
241 g_interfaceFunCntB.stopAdvertiseCntB = 1;
242 return SOFTBUS_OK;
243 }
244 return SOFTBUS_ERR;
245 }
246
247 static PublishOption g_pOption0 = {
248 .freq = 1,
249 .capabilityBitmap = {0},
250 .capabilityData = nullptr,
251 .dataLen = 0,
252 .ranging = true
253 };
254
255 static SubscribeOption g_sOption0 = {
256 .freq = 1,
257 .isSameAccount = true,
258 .isWakeRemote = false,
259 .capabilityBitmap = {0},
260 .capabilityData = nullptr,
261 .dataLen = 0
262 };
263
264 static PublishOption g_pOption1 = {
265 .freq = 1,
266 .capabilityBitmap = {1},
267 .capabilityData = NULL,
268 .dataLen = 0,
269 .ranging = true
270 };
271
272 static SubscribeOption g_sOption1 = {
273 .freq = 1,
274 .isSameAccount = true,
275 .isWakeRemote = false,
276 .capabilityBitmap = {1},
277 .capabilityData = NULL,
278 .dataLen = 0
279 };
280
281 static PublishOption g_pOption2 = {
282 .freq = 1,
283 .capabilityBitmap = {2},
284 .capabilityData = NULL,
285 .dataLen = 0,
286 .ranging = true
287 };
288
289 static SubscribeOption g_sOption2 = {
290 .freq = 1,
291 .isSameAccount = true,
292 .isWakeRemote = false,
293 .capabilityBitmap = {2},
294 .capabilityData = NULL,
295 .dataLen = 0
296 };
297
298 static PublishOption g_pOption3 = {
299 .freq = 1,
300 .capabilityBitmap = {3},
301 .capabilityData = NULL,
302 .dataLen = 0,
303 .ranging = true
304 };
305
306 static SubscribeOption g_sOption3 = {
307 .freq = 1,
308 .isSameAccount = true,
309 .isWakeRemote = false,
310 .capabilityBitmap = {3},
311 .capabilityData = NULL,
312 .dataLen = 0
313 };
314
315 class DiscoveryBleDispatcherTest : public testing::Test {
316 public:
DiscoveryBleDispatcherTest()317 DiscoveryBleDispatcherTest()
318 {}
~DiscoveryBleDispatcherTest()319 ~DiscoveryBleDispatcherTest()
320 {}
321 static void SetUpTestCase(void);
322 static void TearDownTestCase(void);
323 void SetUp();
324 void TearDown();
325 };
326
327 static DiscoveryFuncInterface g_discoveryFuncA = {
328 .Publish = PublishA,
329 .StartScan = StartScanA,
330 .Unpublish = UnpublishA,
331 .StopScan = StopScanA,
332 .StartAdvertise = StartAdvertiseA,
333 .Subscribe = SubscribeA,
334 .Unsubscribe = UnsubscribeA,
335 .StopAdvertise = StopAdvertiseA,
336 .LinkStatusChanged = LinkStatusChangedA,
337 .UpdateLocalDeviceInfo = UpdateLocalDeviceInfoA,
338 };
339
340 static DiscoveryBleDispatcherInterface g_interfaceA = {
341 .IsConcern = IsConcernA,
342 .mediumInterface = &g_discoveryFuncA,
343 };
344
345 static DiscoveryFuncInterface g_discoveryFuncB = {
346 .Publish = PublishB,
347 .StartScan = StartScanB,
348 .Unpublish = UnpublishB,
349 .StopScan = StopScanB,
350 .StartAdvertise = StartAdvertiseB,
351 .Subscribe = SubscribeB,
352 .Unsubscribe = UnsubscribeB,
353 .StopAdvertise = StopAdvertiseB,
354 .LinkStatusChanged = LinkStatusChangedA,
355 .UpdateLocalDeviceInfo = UpdateLocalDeviceInfoA,
356 };
357
358 static DiscoveryBleDispatcherInterface g_interfaceB = {
359 .IsConcern = IsConcernB,
360 .mediumInterface = &g_discoveryFuncB,
361 };
362
SetUpTestCase(void)363 void DiscoveryBleDispatcherTest::SetUpTestCase(void)
364 {}
365
TearDownTestCase(void)366 void DiscoveryBleDispatcherTest::TearDownTestCase(void)
367 {}
368
SetUp(void)369 void DiscoveryBleDispatcherTest::SetUp(void)
370 {}
371
TearDown(void)372 void DiscoveryBleDispatcherTest::TearDown(void)
373 {}
374
375 /*
376 * @tc.name: testDiscPublish001
377 * @tc.desc: test dispatcher
378 * @tc.type: FUNC
379 * @tc.require:
380 */
381 HWTEST_F(DiscoveryBleDispatcherTest, testDiscPublish001, TestSize.Level1)
382 {
383 printf("testDiscPublish001\r\n");
384 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
385 int ret;
386 int32_t beforeFunCntA;
387 int32_t beforeFunCntB;
388 int32_t afterFunCntA;
389 int32_t afterFunCntB;
390
391 beforeFunCntA = g_interfaceFunCntA.publishCntA;
392 beforeFunCntB = g_interfaceFunCntB.publishCntB;
393 ret = interface->Publish(&g_pOption1);
394 afterFunCntA = g_interfaceFunCntA.publishCntA;
395 afterFunCntB = g_interfaceFunCntB.publishCntB;
396 EXPECT_EQ(SOFTBUS_OK, ret);
397 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
398 EXPECT_EQ(beforeFunCntB, afterFunCntB);
399
400 beforeFunCntA = g_interfaceFunCntA.startScanCntA;
401 beforeFunCntB = g_interfaceFunCntB.startScanCntB;
402 ret = interface->StartScan(&g_pOption1);
403 afterFunCntA = g_interfaceFunCntA.startScanCntA;
404 afterFunCntB = g_interfaceFunCntB.startScanCntB;
405 EXPECT_EQ(SOFTBUS_OK, ret);
406 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
407 EXPECT_EQ(beforeFunCntB, afterFunCntB);
408
409 beforeFunCntA = g_interfaceFunCntA.unpublishCntA;
410 beforeFunCntB = g_interfaceFunCntB.unpublishCntB;
411 ret = interface->Unpublish(&g_pOption1);
412 afterFunCntA = g_interfaceFunCntA.unpublishCntA;
413 afterFunCntB = g_interfaceFunCntB.unpublishCntB;
414 EXPECT_EQ(SOFTBUS_OK, ret);
415 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
416 EXPECT_EQ(beforeFunCntB, afterFunCntB);
417
418 beforeFunCntA = g_interfaceFunCntA.stopScanCntA;
419 beforeFunCntB = g_interfaceFunCntB.stopScanCntB;
420 ret = interface->StopScan(&g_pOption1);
421 afterFunCntA = g_interfaceFunCntA.stopScanCntA;
422 afterFunCntB = g_interfaceFunCntB.stopScanCntB;
423 EXPECT_EQ(SOFTBUS_OK, ret);
424 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
425 EXPECT_EQ(beforeFunCntB, afterFunCntB);
426 };
427
428 /*
429 * @tc.name: testDiscovery001
430 * @tc.desc: test dispatcher
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(DiscoveryBleDispatcherTest, testDiscovery001, TestSize.Level1)
435 {
436 printf("testDiscovery001\r\n");
437 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
438 int ret;
439 int32_t beforeFunCntA;
440 int32_t beforeFunCntB;
441 int32_t afterFunCntA;
442 int32_t afterFunCntB;
443
444 beforeFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
445 beforeFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
446 ret = interface->StartAdvertise(&g_sOption1);
447 afterFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
448 afterFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
451 EXPECT_EQ(beforeFunCntB, afterFunCntB);
452
453 beforeFunCntA = g_interfaceFunCntA.subscribeCntA;
454 beforeFunCntB = g_interfaceFunCntB.subscribeCntB;
455 ret = interface->Subscribe(&g_sOption1);
456 afterFunCntA = g_interfaceFunCntA.subscribeCntA;
457 afterFunCntB = g_interfaceFunCntB.subscribeCntB;
458 EXPECT_EQ(SOFTBUS_OK, ret);
459 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
460 EXPECT_EQ(beforeFunCntB, afterFunCntB);
461
462 beforeFunCntA = g_interfaceFunCntA.unsubscribeCntA;
463 beforeFunCntB = g_interfaceFunCntB.unsubscribeCntB;
464 ret = interface->Unsubscribe(&g_sOption1);
465 afterFunCntA = g_interfaceFunCntA.unsubscribeCntA;
466 afterFunCntB = g_interfaceFunCntB.unsubscribeCntB;
467 EXPECT_EQ(SOFTBUS_OK, ret);
468 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
469 EXPECT_EQ(beforeFunCntB, afterFunCntB);
470
471 beforeFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
472 beforeFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
473 ret = interface->StopAdvertise(&g_sOption1);
474 afterFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
475 afterFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
476 EXPECT_EQ(SOFTBUS_OK, ret);
477 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
478 EXPECT_EQ(beforeFunCntB, afterFunCntB);
479 };
480
481 /*
482 * @tc.name: testDiscPublish002
483 * @tc.desc: test dispatcher
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(DiscoveryBleDispatcherTest, testDiscPublish002, TestSize.Level1)
488 {
489 printf("testDiscPublish002\r\n");
490 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
491 int ret;
492 int32_t beforeFunCntA;
493 int32_t beforeFunCntB;
494 int32_t afterFunCntA;
495 int32_t afterFunCntB;
496
497 beforeFunCntA = g_interfaceFunCntA.publishCntA;
498 beforeFunCntB = g_interfaceFunCntB.publishCntB;
499 ret = interface->Publish(&g_pOption2);
500 afterFunCntA = g_interfaceFunCntA.publishCntA;
501 afterFunCntB = g_interfaceFunCntB.publishCntB;
502 EXPECT_EQ(SOFTBUS_OK, ret);
503 EXPECT_EQ(beforeFunCntA, afterFunCntA);
504 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
505
506 beforeFunCntA = g_interfaceFunCntA.startScanCntA;
507 beforeFunCntB = g_interfaceFunCntB.startScanCntB;
508 ret = interface->StartScan(&g_pOption2);
509 afterFunCntA = g_interfaceFunCntA.startScanCntA;
510 afterFunCntB = g_interfaceFunCntB.startScanCntB;
511 EXPECT_EQ(SOFTBUS_OK, ret);
512 EXPECT_EQ(beforeFunCntA, afterFunCntA);
513 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
514
515 beforeFunCntA = g_interfaceFunCntA.unpublishCntA;
516 beforeFunCntB = g_interfaceFunCntB.unpublishCntB;
517 ret = interface->Unpublish(&g_pOption2);
518 afterFunCntA = g_interfaceFunCntA.unpublishCntA;
519 afterFunCntB = g_interfaceFunCntB.unpublishCntB;
520 EXPECT_EQ(SOFTBUS_OK, ret);
521 EXPECT_EQ(beforeFunCntA, afterFunCntA);
522 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
523
524 beforeFunCntA = g_interfaceFunCntA.stopScanCntA;
525 beforeFunCntB = g_interfaceFunCntB.stopScanCntB;
526 ret = interface->StopScan(&g_pOption2);
527 afterFunCntA = g_interfaceFunCntA.stopScanCntA;
528 afterFunCntB = g_interfaceFunCntB.stopScanCntB;
529 EXPECT_EQ(SOFTBUS_OK, ret);
530 EXPECT_EQ(beforeFunCntA, afterFunCntA);
531 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
532 };
533
534 /*
535 * @tc.name: testDiscovery002
536 * @tc.desc: test dispatcher
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(DiscoveryBleDispatcherTest, testDiscovery002, TestSize.Level1)
541 {
542 printf("testDiscovery002\r\n");
543 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
544 int ret;
545 int32_t beforeFunCntA;
546 int32_t beforeFunCntB;
547 int32_t afterFunCntA;
548 int32_t afterFunCntB;
549
550 beforeFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
551 beforeFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
552 ret = interface->StartAdvertise(&g_sOption2);
553 afterFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
554 afterFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
555 EXPECT_EQ(SOFTBUS_OK, ret);
556 EXPECT_EQ(beforeFunCntA, afterFunCntA);
557 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
558
559 beforeFunCntA = g_interfaceFunCntA.subscribeCntA;
560 beforeFunCntB = g_interfaceFunCntB.subscribeCntB;
561 ret = interface->Subscribe(&g_sOption2);
562 afterFunCntA = g_interfaceFunCntA.subscribeCntA;
563 afterFunCntB = g_interfaceFunCntB.subscribeCntB;
564 EXPECT_EQ(SOFTBUS_OK, ret);
565 EXPECT_EQ(beforeFunCntA, afterFunCntA);
566 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
567
568 beforeFunCntA = g_interfaceFunCntA.unsubscribeCntA;
569 beforeFunCntB = g_interfaceFunCntB.unsubscribeCntB;
570 ret = interface->Unsubscribe(&g_sOption2);
571 afterFunCntA = g_interfaceFunCntA.unsubscribeCntA;
572 afterFunCntB = g_interfaceFunCntB.unsubscribeCntB;
573 EXPECT_EQ(SOFTBUS_OK, ret);
574 EXPECT_EQ(beforeFunCntA, afterFunCntA);
575 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
576
577 beforeFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
578 beforeFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
579 ret = interface->StopAdvertise(&g_sOption2);
580 afterFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
581 afterFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
582 EXPECT_EQ(SOFTBUS_OK, ret);
583 EXPECT_EQ(beforeFunCntA, afterFunCntA);
584 EXPECT_EQ(beforeFunCntB + 1, afterFunCntB);
585 };
586
587 /*
588 * @tc.name: testDiscPublish003
589 * @tc.desc: test dispatcher
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(DiscoveryBleDispatcherTest, testDiscPublish003, TestSize.Level1)
594 {
595 printf("testDiscDispatcher003\r\n");
596 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
597 int ret;
598 int32_t beforeFunCntA;
599 int32_t beforeFunCntB;
600 int32_t afterFunCntA;
601 int32_t afterFunCntB;
602
603 beforeFunCntA = g_interfaceFunCntA.publishCntA;
604 beforeFunCntB = g_interfaceFunCntB.publishCntB;
605 ret = interface->Publish(&g_pOption3);
606 afterFunCntA = g_interfaceFunCntA.publishCntA;
607 afterFunCntB = g_interfaceFunCntB.publishCntB;
608 EXPECT_NE(SOFTBUS_OK, ret);
609 EXPECT_EQ(beforeFunCntA, afterFunCntA);
610 EXPECT_EQ(beforeFunCntB, afterFunCntB);
611
612 beforeFunCntA = g_interfaceFunCntA.startScanCntA;
613 beforeFunCntB = g_interfaceFunCntB.startScanCntB;
614 ret = interface->StartScan(&g_pOption3);
615 afterFunCntA = g_interfaceFunCntA.startScanCntA;
616 afterFunCntB = g_interfaceFunCntB.startScanCntB;
617 EXPECT_NE(SOFTBUS_OK, ret);
618 EXPECT_EQ(beforeFunCntA, afterFunCntA);
619 EXPECT_EQ(beforeFunCntB, afterFunCntB);
620
621 beforeFunCntA = g_interfaceFunCntA.unpublishCntA;
622 beforeFunCntB = g_interfaceFunCntB.unpublishCntB;
623 ret = interface->Unpublish(&g_pOption3);
624 afterFunCntA = g_interfaceFunCntA.unpublishCntA;
625 afterFunCntB = g_interfaceFunCntB.unpublishCntB;
626 EXPECT_NE(SOFTBUS_OK, ret);
627 EXPECT_EQ(beforeFunCntA, afterFunCntA);
628 EXPECT_EQ(beforeFunCntB, afterFunCntB);
629
630 beforeFunCntA = g_interfaceFunCntA.stopScanCntA;
631 beforeFunCntB = g_interfaceFunCntB.stopScanCntB;
632 ret = interface->StopScan(&g_pOption3);
633 afterFunCntA = g_interfaceFunCntA.stopScanCntA;
634 afterFunCntB = g_interfaceFunCntB.stopScanCntB;
635 EXPECT_NE(SOFTBUS_OK, ret);
636 EXPECT_EQ(beforeFunCntA, afterFunCntA);
637 EXPECT_EQ(beforeFunCntB, afterFunCntB);
638 };
639
640 /*
641 * @tc.name: testDiscovery003
642 * @tc.desc: test dispatcher
643 * @tc.type: FUNC
644 * @tc.require:
645 */
646 HWTEST_F(DiscoveryBleDispatcherTest, testDiscovery003, TestSize.Level1)
647 {
648 printf("testDiscovery003\r\n");
649 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
650 int ret;
651 int32_t beforeFunCntA;
652 int32_t beforeFunCntB;
653 int32_t afterFunCntA;
654 int32_t afterFunCntB;
655
656 beforeFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
657 beforeFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
658 ret = interface->StartAdvertise(&g_sOption3);
659 afterFunCntA = g_interfaceFunCntA.startAdvertiseCntA;
660 afterFunCntB = g_interfaceFunCntB.startAdvertiseCntB;
661 EXPECT_NE(SOFTBUS_OK, ret);
662 EXPECT_EQ(beforeFunCntA, afterFunCntA);
663 EXPECT_EQ(beforeFunCntB, afterFunCntB);
664
665 beforeFunCntA = g_interfaceFunCntA.subscribeCntA;
666 beforeFunCntB = g_interfaceFunCntB.subscribeCntB;
667 ret = interface->Subscribe(&g_sOption3);
668 afterFunCntA = g_interfaceFunCntA.subscribeCntA;
669 afterFunCntB = g_interfaceFunCntB.subscribeCntB;
670 EXPECT_NE(SOFTBUS_OK, ret);
671 EXPECT_EQ(beforeFunCntA, afterFunCntA);
672 EXPECT_EQ(beforeFunCntB, afterFunCntB);
673
674 beforeFunCntA = g_interfaceFunCntA.unsubscribeCntA;
675 beforeFunCntB = g_interfaceFunCntB.unsubscribeCntB;
676 ret = interface->Unsubscribe(&g_sOption3);
677 afterFunCntA = g_interfaceFunCntA.unsubscribeCntA;
678 afterFunCntB = g_interfaceFunCntB.unsubscribeCntB;
679 EXPECT_NE(SOFTBUS_OK, ret);
680 EXPECT_EQ(beforeFunCntA, afterFunCntA);
681 EXPECT_EQ(beforeFunCntB, afterFunCntB);
682
683 beforeFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
684 beforeFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
685 ret = interface->StopAdvertise(&g_sOption3);
686 afterFunCntA = g_interfaceFunCntA.stopAdvertiseCntA;
687 afterFunCntB = g_interfaceFunCntB.stopAdvertiseCntB;
688 EXPECT_NE(SOFTBUS_OK, ret);
689 EXPECT_EQ(beforeFunCntA, afterFunCntA);
690 EXPECT_EQ(beforeFunCntB, afterFunCntB);
691 };
692
693 /*
694 * @tc.name: testLinkStatusChanged001
695 * @tc.desc: test dispatcher
696 * @tc.type: FUNC
697 * @tc.require:
698 */
699 HWTEST_F(DiscoveryBleDispatcherTest, testLinkStatusChanged001, TestSize.Level1)
700 {
701 printf("testLinkStatusChanged001\r\n");
702 static LinkStatus status = LINK_STATUS_UP;
703 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
704 int32_t beforeFunCntA;
705 int32_t afterFunCntA;
706 beforeFunCntA = g_interfaceFunCntA.linkStatusChangedCntA;
707 interface->LinkStatusChanged(status);
708 afterFunCntA = g_interfaceFunCntA.linkStatusChangedCntA;
709 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
710 };
711
712 /*
713 * @tc.name: testUpdateLocalDeviceInfo001
714 * @tc.desc: test dispatcher
715 * @tc.type: FUNC
716 * @tc.require:
717 */
718 HWTEST_F(DiscoveryBleDispatcherTest, testUpdateLocalDeviceInfo001, TestSize.Level1)
719 {
720 printf("testUpdateLocalDeviceInfo001\r\n");
721 static InfoTypeChanged type = TYPE_LOCAL_DEVICE_NAME;
722 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
723 int32_t beforeFunCntA;
724 int32_t afterFunCntA;
725 beforeFunCntA = g_interfaceFunCntA.updateLocalDeviceInfoCntA;
726 interface->UpdateLocalDeviceInfo(type);
727 afterFunCntA = g_interfaceFunCntA.updateLocalDeviceInfoCntA;
728 EXPECT_EQ(beforeFunCntA + 1, afterFunCntA);
729 }
730
731 /*
732 * @tc.name: BleDispatchPublishOption001
733 * @tc.desc: test dispatcher
734 * @tc.type: FUNC
735 * @tc.require:
736 */
737 HWTEST_F(DiscoveryBleDispatcherTest, BleDispatchPublishOption001, TestSize.Level1)
738 {
739 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "BleDispatchPublishOption001");
740 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
741 int32_t ret = interface->Publish(&g_pOption0);
742 EXPECT_EQ(SOFTBUS_ERR, ret);
743 }
744
745 /*
746 * @tc.name: BleDispatchSubscribeOption001
747 * @tc.desc: test dispatcher
748 * @tc.type: FUNC
749 * @tc.require:
750 */
751 HWTEST_F(DiscoveryBleDispatcherTest, BleDispatchSubscribeOption001, TestSize.Level1)
752 {
753 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "BleDispatchSubscribeOption001");
754 DiscoveryFuncInterface *interface = DiscBleInitForTest(&g_interfaceA, &g_interfaceB);
755 int32_t ret = interface->StartAdvertise(&g_sOption0);
756 EXPECT_EQ(SOFTBUS_ERR, ret);
757 }
758
759 /*
760 * @tc.name: DiscBleInit001
761 * @tc.desc: test dispatcher
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 HWTEST_F(DiscoveryBleDispatcherTest, DiscBleInit001, TestSize.Level1)
766 {
767 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "DiscBleInit001");
768 DiscoveryFuncInterface *interface = DiscBleInit(nullptr);
769 EXPECT_EQ(interface, nullptr);
770 }
771
772 /*
773 * @tc.name: DiscBleInit002
774 * @tc.desc: test dispatcher
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(DiscoveryBleDispatcherTest, DiscBleInit002, TestSize.Level1)
779 {
780 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "DiscBleInit002");
781 DiscInnerCallback g_discMgrMediumCb;
782 g_discMgrMediumCb.OnDeviceFound = nullptr;
783 DiscoveryFuncInterface *interface = DiscBleInit(&g_discMgrMediumCb);
784 EXPECT_EQ(interface, nullptr);
785 }
786 }
787