1 /*
2 * Copyright (c) 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 #include <gmock/gmock.h>
16 #include <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "disc_log.h"
20 #include "message_handler.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_ble_mock.h"
23 #include "softbus_broadcast_utils.h"
24 #include "softbus_error_code.h"
25
26 using namespace testing::ext;
27 using ::testing::Return;
28
29 #define BC_ADV_FLAG 0x2
30 #define BC_ADV_TX_POWER_DEFAULT (-6)
31 #define BC_CHANNLE_MAP 0x0
32 #define BC_INTERNAL 48
33 #define MANUFACTURE_COMPANY_ID 0x027D
34 #define SERVICE_UUID 0xFDEE
35 #define SRV_TYPE_INVALID (-1)
36
37 namespace OHOS {
38 class SoftbusBroadcastMgrTest : public testing::Test {
39 public:
SetUpTestCase()40 static void SetUpTestCase()
41 {
42 LooperInit();
43 }
44
TearDownTestCase()45 static void TearDownTestCase()
46 {
47 LooperDeinit();
48 }
49
SetUp()50 void SetUp() override {}
TearDown()51 void TearDown() override {}
52
53 static constexpr char BC_DATA_PAYLOAD[] = {0x04, 0x05, 0x90, 0x00, 0x00, 0x10, 0x00, 0x18, 0xB9, 0x13, 0x3D, 0x28,
54 0xFC, 0x0D, 0x7F, 0xAB, 0x21, 0x00, 0x30, 0x4F, 0x70, 0x65, 0x6E, 0x48};
55 static constexpr char RSP_DATA_PAYLOAD[] = {0x61, 0x72, 0x6D, 0x6F, 0x6E, 0x79, 0x20, 0x33, 0x2E, 0x32, 0x00};
56 };
57
BuildBroadcastParam(BroadcastParam * bcParam)58 static void BuildBroadcastParam(BroadcastParam *bcParam)
59 {
60 bcParam->minInterval = BC_INTERNAL;
61 bcParam->maxInterval = BC_INTERNAL;
62 bcParam->advType = SOFTBUS_BC_ADV_IND;
63 bcParam->ownAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
64 bcParam->peerAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
65 bcParam->channelMap = BC_CHANNLE_MAP;
66 bcParam->txPower = BC_ADV_TX_POWER_DEFAULT;
67 }
68
BuildBroadcastPacketExceptPayload(BroadcastPacket * packet)69 static void BuildBroadcastPacketExceptPayload(BroadcastPacket *packet)
70 {
71 packet->bcData.type = BC_DATA_TYPE_SERVICE;
72 packet->bcData.id = SERVICE_UUID;
73 packet->rspData.type = BC_DATA_TYPE_MANUFACTURER;
74 packet->rspData.id = MANUFACTURE_COMPANY_ID;
75 packet->isSupportFlag = true;
76 packet->flag = BC_ADV_FLAG;
77 }
78
BuildScanParam(BcScanParams * scanParam)79 static void BuildScanParam(BcScanParams *scanParam)
80 {
81 scanParam->scanInterval = SOFTBUS_BC_SCAN_INTERVAL_P2;
82 scanParam->scanWindow = SOFTBUS_BC_SCAN_WINDOW_P2;
83 scanParam->scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE;
84 scanParam->scanPhy = SOFTBUS_BC_SCAN_PHY_1M;
85 scanParam->scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL;
86 }
87
88 // filter is released in UnRegisterScanListener
GetBcScanFilter(void)89 static BcScanFilter *GetBcScanFilter(void)
90 {
91 unsigned char serviceData[] = {0x04, 0x05, 0x90};
92 unsigned char serviceDataMask[] = {0xFF, 0xFF, 0xFF};
93 int serviceDataLength = sizeof(serviceData);
94
95 BcScanFilter *filter = static_cast<BcScanFilter *>(SoftBusCalloc(sizeof(BcScanFilter)));
96 DISC_CHECK_AND_RETURN_RET_LOGW(filter != nullptr, nullptr, DISC_TEST, "malloc filter failed");
97
98 unsigned char *data = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
99 unsigned char *mask = static_cast<unsigned char *>(SoftBusCalloc(serviceDataLength));
100 if (data == nullptr || mask == nullptr) {
101 goto EXIT;
102 }
103 if (memcpy_s(data, serviceDataLength, serviceData, serviceDataLength) != EOK) {
104 goto EXIT;
105 }
106 if (memcpy_s(mask, serviceDataLength, serviceDataMask, serviceDataLength) != EOK) {
107 goto EXIT;
108 }
109
110 filter->serviceUuid = SERVICE_UUID;
111 filter->serviceData = data;
112 filter->serviceDataMask = mask;
113 filter->serviceDataLength = serviceDataLength;
114 return filter;
115 EXIT:
116 SoftBusFree(filter);
117 SoftBusFree(data);
118 SoftBusFree(mask);
119 return nullptr;
120 }
121
BleBcEnableCallback(int channel,int status)122 static void BleBcEnableCallback(int channel, int status)
123 {
124 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
125 }
126
BleBcDisableCallback(int channel,int status)127 static void BleBcDisableCallback(int channel, int status)
128 {
129 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
130 }
131
BleBcUpdateCallback(int channel,int status)132 static void BleBcUpdateCallback(int channel, int status)
133 {
134 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
135 }
136
BleBcDataCallback(int channel,int status)137 static void BleBcDataCallback(int channel, int status)
138 {
139 DISC_LOGI(DISC_TEST, "channel=%{public}d, status=%{public}d", channel, status);
140 }
141
BleOnScanStart(int listenerId,int status)142 static void BleOnScanStart(int listenerId, int status)
143 {
144 (void)listenerId;
145 (void)status;
146 DISC_LOGI(DISC_TEST, "BleOnScanStart");
147 }
148
BleOnScanStop(int listenerId,int status)149 static void BleOnScanStop(int listenerId, int status)
150 {
151 (void)listenerId;
152 (void)status;
153 DISC_LOGI(DISC_TEST, "BleOnScanStop");
154 }
155
BleScanResultCallback(int listenerId,const BroadcastReportInfo * reportInfo)156 static void BleScanResultCallback(int listenerId, const BroadcastReportInfo *reportInfo)
157 {
158 (void)listenerId;
159 }
160
GetBroadcastCallback()161 static BroadcastCallback *GetBroadcastCallback()
162 {
163 static BroadcastCallback g_bcCallback = {
164 .OnStartBroadcastingCallback = BleBcEnableCallback,
165 .OnStopBroadcastingCallback = BleBcDisableCallback,
166 .OnUpdateBroadcastingCallback = BleBcUpdateCallback,
167 .OnSetBroadcastingCallback = BleBcDataCallback,
168 };
169 return &g_bcCallback;
170 }
171
GetScanCallback()172 static ScanCallback *GetScanCallback()
173 {
174 static ScanCallback g_scanListener = {
175 .OnStartScanCallback = BleOnScanStart,
176 .OnStopScanCallback = BleOnScanStop,
177 .OnReportScanDataCallback = BleScanResultCallback,
178 };
179 return &g_scanListener;
180 }
181
182 /*
183 * @tc.name: SoftbusBroadcastMgrInit001
184 * @tc.desc: Init successful.
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit001, TestSize.Level1)
189 {
190 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 begin ----");
191 ManagerMock managerMock;
192
193 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
194 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
195
196 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit001 end ----");
197 }
198
199 /*
200 * @tc.name: SoftbusBroadcastMgrInit002
201 * @tc.desc: Repeated initializations successful.
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrInit002, TestSize.Level1)
206 {
207 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 begin ----");
208 ManagerMock managerMock;
209
210 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
211 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
212 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
213
214 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrInit002 end ----");
215 }
216
217 /*
218 * @tc.name: SoftbusBroadcastMgrDeInit001
219 * @tc.desc: Repeated deinitializations successful.
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit001, TestSize.Level1)
224 {
225 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 begin ----");
226 ManagerMock managerMock;
227
228 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
229 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
230 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
231
232 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit001 end ----");
233 }
234
235 /*
236 * @tc.name: SoftbusBroadcastMgrDeInit002
237 * @tc.desc: Deinit without initialization.
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastMgrDeInit002, TestSize.Level1)
242 {
243 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 begin ----");
244 ManagerMock managerMock;
245
246 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
247
248 DISC_LOGI(DISC_TEST, "SoftbusBroadcastMgrDeInit002 end ----");
249 }
250
251 /*
252 * @tc.name: SoftbusBroadcastInterface001
253 * @tc.desc: Calls the interfaces without initialization.
254 * @tc.type: FUNC
255 * @tc.require:
256 */
257 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastInterface001, TestSize.Level1)
258 {
259 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 begin ----");
260 ManagerMock managerMock;
261
262 int32_t bcId = -1;
263 int32_t listenerId = -1;
264 EXPECT_EQ(SOFTBUS_ERR, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
265 EXPECT_EQ(SOFTBUS_ERR, UnRegisterBroadcaster(bcId));
266 EXPECT_EQ(SOFTBUS_ERR, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
267 EXPECT_EQ(SOFTBUS_ERR, UnRegisterScanListener(listenerId));
268
269 BroadcastParam bcParam = {};
270 BroadcastPacket packet = {};
271 BuildBroadcastParam(&bcParam);
272 BuildBroadcastPacketExceptPayload(&packet);
273
274 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
275 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
276 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
277 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
278
279 EXPECT_EQ(SOFTBUS_ERR, StartBroadcasting(bcId, &bcParam, &packet));
280 EXPECT_EQ(SOFTBUS_ERR, SetBroadcastingData(bcId, &packet));
281 EXPECT_EQ(SOFTBUS_ERR, StopBroadcasting(bcId));
282
283 BcScanParams scanParam = {};
284 BuildScanParam(&scanParam);
285
286 EXPECT_EQ(SOFTBUS_ERR, StartScan(listenerId, &scanParam));
287 EXPECT_EQ(SOFTBUS_ERR, StopScan(listenerId));
288 EXPECT_FALSE(BroadcastIsLpDeviceAvailable());
289
290 DISC_LOGI(DISC_TEST, "SoftbusBroadcastInterface001 end ----");
291 }
292
293 /*
294 * @tc.name: SoftbusBroadcastRegisterBroadcaster001
295 * @tc.desc: Invalid parameter, register broadcaster fail.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster001, TestSize.Level1)
300 {
301 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 begin ----");
302 ManagerMock managerMock;
303
304 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
305 int32_t bcId = -1;
306 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(static_cast<BaseServiceType>(SRV_TYPE_INVALID), &bcId,
307 GetBroadcastCallback()));
308 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, nullptr, GetBroadcastCallback()));
309 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, nullptr));
310
311 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
312
313 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster001 end ----");
314 }
315
316 /*
317 * @tc.name: SoftbusBroadcastRegisterBroadcaster002
318 * @tc.desc: Register broadcaster and unregister broadcaster success.
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster002, TestSize.Level1)
323 {
324 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 begin ----");
325 ManagerMock managerMock;
326
327 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
328 int32_t bcId = -1;
329 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
330 EXPECT_TRUE(bcId >= 0);
331
332 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
333 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
334
335 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster002 end ----");
336 }
337
338 /*
339 * @tc.name: SoftbusBroadcastRegisterBroadcaster003
340 * @tc.desc: Duplicate registration.
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterBroadcaster003, TestSize.Level1)
345 {
346 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 begin ----");
347 ManagerMock managerMock;
348
349 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
350 int32_t bcId[BC_NUM_MAX + 1] = {-1};
351 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
352 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId[i], GetBroadcastCallback()));
353 EXPECT_TRUE(bcId[i] >= 0);
354 }
355
356 EXPECT_EQ(SOFTBUS_ERR, RegisterBroadcaster(SRV_TYPE_DIS, &bcId[BC_NUM_MAX], GetBroadcastCallback()));
357
358 for (int32_t i = 0; i < BC_NUM_MAX; i++) {
359 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId[i]));
360 }
361
362 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
363
364 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterBroadcaster003 end ----");
365 }
366
367 /*
368 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster001
369 * @tc.desc: Unregister without registration.
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster001, TestSize.Level1)
374 {
375 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 begin ----");
376 ManagerMock managerMock;
377
378 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
379
380 int32_t invalidId = -1;
381 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
382 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(BC_NUM_MAX));
383 invalidId = 1;
384 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterBroadcaster(invalidId));
385
386 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
387
388 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster001 end ----");
389 }
390
391 /*
392 * @tc.name: SoftbusBroadcastUnRegisterBroadcaster002
393 * @tc.desc: Unregister when broadcasting.
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterBroadcaster002, TestSize.Level1)
398 {
399 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 begin ----");
400 ManagerMock managerMock;
401
402 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
403
404 int32_t bcId = -1;
405 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
406 EXPECT_TRUE(bcId >= 0);
407
408 BroadcastParam bcParam = {};
409 BroadcastPacket packet = {};
410 BuildBroadcastParam(&bcParam);
411 BuildBroadcastPacketExceptPayload(&packet);
412
413 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
414 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
415 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
416 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
417 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
418 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
419
420 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
421
422 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterBroadcaster002 end ----");
423 }
424
425 /*
426 * @tc.name: SoftbusBroadcastRegisterScanListener001
427 * @tc.desc: Invalid parameter, register listener fail.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener001, TestSize.Level1)
432 {
433 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 begin ----");
434 ManagerMock managerMock;
435
436 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
437 int32_t listenerId = -1;
438 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(static_cast<BaseServiceType>(SRV_TYPE_INVALID), &listenerId,
439 GetScanCallback()));
440 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, nullptr, GetScanCallback()));
441 EXPECT_EQ(SOFTBUS_INVALID_PARAM, RegisterScanListener(SRV_TYPE_DIS, &listenerId, nullptr));
442
443 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
444
445 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener001 end ----");
446 }
447
448 /*
449 * @tc.name: SoftbusBroadcastRegisterScanListener002
450 * @tc.desc: Register listener and unregister listener success.
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener002, TestSize.Level1)
455 {
456 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 begin ----");
457 ManagerMock managerMock;
458
459 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
460 int32_t listenerId = -1;
461 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
462 EXPECT_TRUE(listenerId >= 0);
463
464 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
465 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
466
467 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener002 end ----");
468 }
469
470 /*
471 * @tc.name: SoftbusBroadcastRegisterScanListener003
472 * @tc.desc: Duplicate registration.
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastRegisterScanListener003, TestSize.Level1)
477 {
478 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 begin ----");
479 ManagerMock managerMock;
480
481 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
482 int32_t listenerId = -1;
483 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
484 EXPECT_TRUE(listenerId >= 0);
485 EXPECT_EQ(SOFTBUS_ERR, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
486 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
487
488 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_SH, &listenerId, GetScanCallback()));
489 EXPECT_TRUE(listenerId >= 0);
490 EXPECT_EQ(SOFTBUS_ERR, RegisterScanListener(SRV_TYPE_SH, &listenerId, GetScanCallback()));
491 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
492
493 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
494
495 DISC_LOGI(DISC_TEST, "SoftbusBroadcastRegisterScanListener003 end ----");
496 }
497
498 /*
499 * @tc.name: SoftbusBroadcastUnRegisterScanListener001
500 * @tc.desc: Unregister without registration.
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener001, TestSize.Level1)
505 {
506 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 begin ----");
507 ManagerMock managerMock;
508
509 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
510
511 int32_t invalidId = -1;
512 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
513 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(SCAN_NUM_MAX));
514 invalidId = 0;
515 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UnRegisterScanListener(invalidId));
516
517 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
518
519 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener001 end ----");
520 }
521
522 /*
523 * @tc.name: SoftbusBroadcastUnRegisterScanListener002
524 * @tc.desc: Unregister when scanning.
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUnRegisterScanListener002, TestSize.Level1)
529 {
530 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 begin ----");
531 ManagerMock managerMock;
532
533 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
534 int32_t listenerId = -1;
535 uint8_t filterNum = 1;
536 BcScanFilter *filter = GetBcScanFilter();
537 BcScanParams scanParam = {};
538 BuildScanParam(&scanParam);
539
540 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
541 EXPECT_TRUE(listenerId >= 0);
542
543 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
544 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
545
546 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
547 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
548
549 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUnRegisterScanListener002 end ----");
550 }
551
552 /*
553 * @tc.name: SoftbusBroadcastStartBroadcasting001
554 * @tc.desc: Invalid parameter, start broadcasting fail.
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting001, TestSize.Level1)
559 {
560 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 begin ----");
561 ManagerMock managerMock;
562
563 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
564
565 int32_t bcId = -1;
566 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
567 EXPECT_TRUE(bcId >= 0);
568
569 BroadcastParam bcParam = {};
570 BroadcastPacket packet = {};
571 BuildBroadcastParam(&bcParam);
572 BuildBroadcastPacketExceptPayload(&packet);
573
574 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, nullptr, &packet));
575 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, nullptr));
576 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBroadcasting(bcId, &bcParam, &packet));
577
578 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
579 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
580 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
581 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
582 int32_t invalidBcId = -1;
583 EXPECT_EQ(SOFTBUS_ERR, StartBroadcasting(invalidBcId, &bcParam, &packet));
584
585 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
586
587 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
588
589 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting001 end ----");
590 }
591
592 /*
593 * @tc.name: SoftbusBroadcastStartBroadcasting002
594 * @tc.desc: Start broadcasting and stop broadcasting success.
595 * @tc.type: FUNC
596 * @tc.require:
597 */
598 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting002, TestSize.Level1)
599 {
600 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 begin ----");
601 ManagerMock managerMock;
602
603 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
604
605 int32_t bcId = -1;
606 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
607 EXPECT_TRUE(bcId >= 0);
608
609 BroadcastParam bcParam = {};
610 BroadcastPacket packet = {};
611 BuildBroadcastParam(&bcParam);
612 BuildBroadcastPacketExceptPayload(&packet);
613
614 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
615 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
616 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
617 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
618
619 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
620 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
621
622 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
623 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
624
625 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting002 end ----");
626 }
627
628 /*
629 * @tc.name: SoftbusBroadcastStartBroadcasting003
630 * @tc.desc: Duplicate start broadcasting.
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartBroadcasting003, TestSize.Level1)
635 {
636 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 begin ----");
637 ManagerMock managerMock;
638
639 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
640
641 int32_t bcId = -1;
642 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
643 EXPECT_TRUE(bcId >= 0);
644
645 BroadcastParam bcParam = {};
646 BroadcastPacket packet = {};
647 BuildBroadcastParam(&bcParam);
648 BuildBroadcastPacketExceptPayload(&packet);
649
650 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
651 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
652 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
653 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
654
655 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
656 EXPECT_EQ(SOFTBUS_ERR, StartBroadcasting(bcId, &bcParam, &packet));
657 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
658
659 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
660 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
661
662 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartBroadcasting003 end ----");
663 }
664
665 /*
666 * @tc.name: SoftbusBroadcastUpdateBroadcasting001
667 * @tc.desc: Invalid parameter, update broadcasting fail.
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting001, TestSize.Level1)
672 {
673 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 begin ----");
674 ManagerMock managerMock;
675
676 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
677
678 int32_t bcId = -1;
679 BroadcastParam bcParam = {};
680 BroadcastPacket packet = {};
681 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, nullptr, &packet));
682 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateBroadcasting(bcId, &bcParam, nullptr));
683
684 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
685
686 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting001 end ----");
687 }
688
689 /*
690 * @tc.name: SoftbusBroadcastUpdateBroadcasting002
691 * @tc.desc: Update broadcasting success.
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastUpdateBroadcasting002, TestSize.Level1)
696 {
697 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 begin ----");
698 ManagerMock managerMock;
699
700 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
701
702 int32_t bcId = -1;
703 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
704 EXPECT_TRUE(bcId >= 0);
705
706 BroadcastParam bcParam = {};
707 BroadcastPacket packet = {};
708 BuildBroadcastParam(&bcParam);
709 BuildBroadcastPacketExceptPayload(&packet);
710
711 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
712 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
713 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
714 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
715
716 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
717 EXPECT_EQ(SOFTBUS_OK, UpdateBroadcasting(bcId, &bcParam, &packet));
718
719 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
720 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
721
722 DISC_LOGI(DISC_TEST, "SoftbusBroadcastUpdateBroadcasting002 end ----");
723 }
724
725 /*
726 * @tc.name: SoftbusBroadcastSetBroadcastingData001
727 * @tc.desc: Invalid parameter, set broadcasting data fail.
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData001, TestSize.Level1)
732 {
733 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 begin ----");
734 ManagerMock managerMock;
735
736 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
737
738 int32_t invalidId = -1;
739 BroadcastPacket packet = {};
740 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetBroadcastingData(invalidId, nullptr));
741 EXPECT_EQ(SOFTBUS_ERR, SetBroadcastingData(invalidId, &packet));
742 EXPECT_EQ(SOFTBUS_ERR, SetBroadcastingData(BC_NUM_MAX, &packet));
743 invalidId = 0;
744 EXPECT_EQ(SOFTBUS_ERR, SetBroadcastingData(invalidId, &packet));
745
746 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
747
748 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData001 end ----");
749 }
750
751 /*
752 * @tc.name: SoftbusBroadcastSetBroadcastingData002
753 * @tc.desc: Set broadcasting data without start.
754 * @tc.type: FUNC
755 * @tc.require:
756 */
757 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData002, TestSize.Level1)
758 {
759 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 begin ----");
760 ManagerMock managerMock;
761
762 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
763
764 int32_t bcId = -1;
765 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
766 EXPECT_TRUE(bcId >= 0);
767
768 BroadcastPacket packet = {};
769 EXPECT_EQ(SOFTBUS_ERR, SetBroadcastingData(bcId, &packet));
770
771 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
772 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
773
774 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData002 end ----");
775 }
776
777 /*
778 * @tc.name: SoftbusBroadcastSetBroadcastingData003
779 * @tc.desc: Set broadcasting data success.
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetBroadcastingData003, TestSize.Level1)
784 {
785 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 begin ----");
786 ManagerMock managerMock;
787
788 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
789
790 int32_t bcId = -1;
791 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
792 EXPECT_TRUE(bcId >= 0);
793
794 BroadcastParam bcParam = {};
795 BroadcastPacket packet = {};
796 BuildBroadcastParam(&bcParam);
797 BuildBroadcastPacketExceptPayload(&packet);
798
799 packet.bcData.payloadLen = sizeof(BC_DATA_PAYLOAD);
800 packet.bcData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(BC_DATA_PAYLOAD));
801 packet.rspData.payloadLen = sizeof(RSP_DATA_PAYLOAD);
802 packet.rspData.payload = reinterpret_cast<uint8_t *>(const_cast<char *>(RSP_DATA_PAYLOAD));
803
804 EXPECT_EQ(SOFTBUS_OK, StartBroadcasting(bcId, &bcParam, &packet));
805 EXPECT_EQ(SOFTBUS_OK, SetBroadcastingData(bcId, &packet));
806 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
807
808 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
809 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
810
811 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetBroadcastingData003 end ----");
812 }
813
814 /*
815 * @tc.name: SoftbusBroadcastStopBroadcasting001
816 * @tc.desc: Invalid parameter, stop broadcasting fail.
817 * @tc.type: FUNC
818 * @tc.require:
819 */
820 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting001, TestSize.Level1)
821 {
822 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 begin ----");
823 ManagerMock managerMock;
824
825 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
826
827 int32_t invalidId = -1;
828 EXPECT_EQ(SOFTBUS_ERR, StopBroadcasting(invalidId));
829 EXPECT_EQ(SOFTBUS_ERR, StopBroadcasting(BC_NUM_MAX));
830 invalidId = 0;
831 EXPECT_EQ(SOFTBUS_ERR, StopBroadcasting(invalidId));
832
833 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
834
835 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting001 end ----");
836 }
837
838 /*
839 * @tc.name: SoftbusBroadcastStopBroadcasting002
840 * @tc.desc: Stop broadcasting without start.
841 * @tc.type: FUNC
842 * @tc.require:
843 */
844 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopBroadcasting002, TestSize.Level1)
845 {
846 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 begin ----");
847 ManagerMock managerMock;
848
849 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
850 int32_t bcId = -1;
851 EXPECT_EQ(SOFTBUS_OK, RegisterBroadcaster(SRV_TYPE_DIS, &bcId, GetBroadcastCallback()));
852 EXPECT_TRUE(bcId >= 0);
853
854 EXPECT_EQ(SOFTBUS_OK, StopBroadcasting(bcId));
855
856 EXPECT_EQ(SOFTBUS_OK, UnRegisterBroadcaster(bcId));
857 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
858
859 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopBroadcasting002 end ----");
860 }
861
862 /*
863 * @tc.name: SoftbusBroadcastSetScanFilter001
864 * @tc.desc: Invalid parameter, set filter fail.
865 * @tc.type: FUNC
866 * @tc.require:
867 */
868 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter001, TestSize.Level1)
869 {
870 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 begin ----");
871 ManagerMock managerMock;
872
873 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
874 int32_t listenerId = -1;
875 uint8_t filterNum = 0;
876 BcScanFilter filter = {};
877 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, &filter, filterNum));
878
879 filterNum = 1;
880 EXPECT_EQ(SOFTBUS_INVALID_PARAM, SetScanFilter(listenerId, nullptr, filterNum));
881 EXPECT_EQ(SOFTBUS_ERR, SetScanFilter(listenerId, &filter, filterNum));
882 EXPECT_EQ(SOFTBUS_ERR, SetScanFilter(SCAN_NUM_MAX, &filter, filterNum));
883 listenerId = 0;
884 EXPECT_EQ(SOFTBUS_ERR, SetScanFilter(listenerId, &filter, filterNum));
885
886 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
887
888 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter001 end ----");
889 }
890
891 /*
892 * @tc.name: SoftbusBroadcastSetScanFilter002
893 * @tc.desc: Set filter success.
894 * @tc.type: FUNC
895 * @tc.require:
896 */
897 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastSetScanFilter002, TestSize.Level1)
898 {
899 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 begin ----");
900 ManagerMock managerMock;
901
902 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
903 int32_t listenerId = -1;
904 uint8_t filterNum = 1;
905 BcScanFilter *filter = GetBcScanFilter();
906
907 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
908 EXPECT_TRUE(listenerId >= 0);
909
910 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
911
912 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
913 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
914
915 DISC_LOGI(DISC_TEST, "SoftbusBroadcastSetScanFilter002 end ----");
916 }
917
918 /*
919 * @tc.name: SoftbusBroadcastStartScan001
920 * @tc.desc: Invalid parameter, start scan fail.
921 * @tc.type: FUNC
922 * @tc.require:
923 */
924 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan001, TestSize.Level1)
925 {
926 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 begin ----");
927 ManagerMock managerMock;
928
929 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
930 int32_t listenerId = -1;
931 BcScanParams scanParam = {};
932 BuildScanParam(&scanParam);
933 EXPECT_EQ(SOFTBUS_ERR, StartScan(listenerId, &scanParam));
934
935 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
936 EXPECT_TRUE(listenerId >= 0);
937 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartScan(listenerId, nullptr));
938
939 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
940 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
941
942 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan001 end ----");
943 }
944
945 /*
946 * @tc.name: SoftbusBroadcastStartScan002
947 * @tc.desc: Start scan without filter.
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan002, TestSize.Level1)
952 {
953 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 begin ----");
954 ManagerMock managerMock;
955
956 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
957 int32_t listenerId = -1;
958 BcScanParams scanParam = {};
959 BuildScanParam(&scanParam);
960
961 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
962 EXPECT_TRUE(listenerId >= 0);
963 EXPECT_EQ(SOFTBUS_ERR, StartScan(listenerId, &scanParam));
964
965 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
966 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
967
968 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan002 end ----");
969 }
970
971 /*
972 * @tc.name: SoftbusBroadcastStartScan003
973 * @tc.desc: Start scan and stop scan success.
974 * @tc.type: FUNC
975 * @tc.require:
976 */
977 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan003, TestSize.Level1)
978 {
979 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 begin ----");
980 ManagerMock managerMock;
981
982 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
983 int32_t listenerId = -1;
984 uint8_t filterNum = 1;
985 BcScanFilter *filter = GetBcScanFilter();
986 BcScanParams scanParam = {};
987 BuildScanParam(&scanParam);
988
989 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
990 EXPECT_TRUE(listenerId >= 0);
991
992 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
993 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
994 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
995
996 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
997 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
998
999 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan003 end ----");
1000 }
1001
1002 /*
1003 * @tc.name: SoftbusBroadcastStartScan004
1004 * @tc.desc: Duplicate start scan.
1005 * @tc.type: FUNC
1006 * @tc.require:
1007 */
1008 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStartScan004, TestSize.Level1)
1009 {
1010 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 begin ----");
1011 ManagerMock managerMock;
1012
1013 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1014 int32_t listenerId = -1;
1015 uint8_t filterNum = 1;
1016 BcScanFilter *filter = GetBcScanFilter();
1017 BcScanParams scanParam = {};
1018 BuildScanParam(&scanParam);
1019
1020 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1021 EXPECT_TRUE(listenerId >= 0);
1022
1023 EXPECT_EQ(SOFTBUS_OK, SetScanFilter(listenerId, filter, filterNum));
1024 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1025 EXPECT_EQ(SOFTBUS_OK, StartScan(listenerId, &scanParam));
1026 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1027
1028 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1029 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1030
1031 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStartScan004 end ----");
1032 }
1033
1034 /*
1035 * @tc.name: SoftbusBroadcastStopScan001
1036 * @tc.desc: Invalid parameter, stop scan fail.
1037 * @tc.type: FUNC
1038 * @tc.require:
1039 */
1040 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan001, TestSize.Level1)
1041 {
1042 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 begin ----");
1043 ManagerMock managerMock;
1044
1045 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1046 int32_t invalidId = -1;
1047 EXPECT_EQ(SOFTBUS_ERR, StopScan(invalidId));
1048 EXPECT_EQ(SOFTBUS_ERR, StopScan(SCAN_NUM_MAX));
1049 invalidId = 0;
1050 EXPECT_EQ(SOFTBUS_ERR, StopScan(invalidId));
1051
1052 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1053
1054 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan001 end ----");
1055 }
1056
1057 /*
1058 * @tc.name: SoftbusBroadcastStopScan002
1059 * @tc.desc: Stop scan without start.
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(SoftbusBroadcastMgrTest, SoftbusBroadcastStopScan002, TestSize.Level1)
1064 {
1065 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 begin ----");
1066 ManagerMock managerMock;
1067
1068 EXPECT_EQ(SOFTBUS_OK, InitBroadcastMgr());
1069 int32_t listenerId = -1;
1070 EXPECT_EQ(SOFTBUS_OK, RegisterScanListener(SRV_TYPE_DIS, &listenerId, GetScanCallback()));
1071 EXPECT_TRUE(listenerId >= 0);
1072 EXPECT_EQ(SOFTBUS_OK, StopScan(listenerId));
1073
1074 EXPECT_EQ(SOFTBUS_OK, UnRegisterScanListener(listenerId));
1075 EXPECT_EQ(SOFTBUS_OK, DeInitBroadcastMgr());
1076
1077 DISC_LOGI(DISC_TEST, "SoftbusBroadcastStopScan002 end ----");
1078 }
1079
1080 } // namespace OHOS