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
16 #include "assert_helper.h"
17 #include "bluetooth_mock.h"
18 #include "c_header/ohos_bt_gatt.h"
19 #include "disc_log.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_ble_gatt.h"
22 #include "softbus_broadcast_type.h"
23 #include "softbus_error_code.h"
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26
27 #define GATT_ADV_MAX_NUM 20
28
29 using namespace testing::ext;
30 using ::testing::AtMost;
31 using ::testing::Return;
32
33 namespace OHOS {
34
35 class ScanResultCtx : public RecordCtx {
36 public:
37 explicit ScanResultCtx(const char *identifier);
38 ~ScanResultCtx();
39 bool Update(int32_t scannerId, const SoftBusBcScanResult *reportData);
40 testing::AssertionResult Expect(int32_t scannerId, const SoftBusBcScanResult *reportData);
41
42 private:
43 SoftBusBcScanResult scanResult;
44 void Reset();
45 };
46
47 class SoftbusBleGattTest : public testing::Test {
48 public:
49 static ScanResultCtx scanResultCtx;
50
51 static StRecordCtx advEnableCtx;
52 static StRecordCtx advDisableCtx;
53 static StRecordCtx advDataCtx;
54 static StRecordCtx advUpdateCtx;
55 static int32_t btInnerAdvId;
56
57 static void SetUpTestCase(void);
58 };
59
60 ScanResultCtx SoftbusBleGattTest::scanResultCtx("OnReportScanDataCallback");
61
62 StRecordCtx SoftbusBleGattTest::advEnableCtx("AdvEnableCallback");
63 StRecordCtx SoftbusBleGattTest::advDisableCtx("AdvDisableCallback");
64 StRecordCtx SoftbusBleGattTest::advDataCtx("AdvDataCallback");
65 StRecordCtx SoftbusBleGattTest::advUpdateCtx("AdvUpdateCallback");
66 int32_t SoftbusBleGattTest::btInnerAdvId = -1;
67
SetUpTestCase()68 void SoftbusBleGattTest::SetUpTestCase()
69 {
70 MockBluetooth mocker;
71 SoftbusBleAdapterInit();
72 MockBluetooth::interface->Init();
73 }
74
StubOnScanResult(int32_t scannerId,const SoftBusBcScanResult * reportData)75 static void StubOnScanResult(int32_t scannerId, const SoftBusBcScanResult *reportData)
76 {
77 SoftbusBleGattTest::scanResultCtx.Update(scannerId, reportData);
78 }
79
GetStubScanListener()80 static SoftbusScanCallback *GetStubScanListener()
81 {
82 static SoftbusScanCallback listener = { .OnStartScanCallback = nullptr,
83 .OnStopScanCallback = nullptr,
84 .OnReportScanDataCallback = StubOnScanResult,
85 .OnScanStateChanged = nullptr };
86 return &listener;
87 }
88
StubAdvEnableCallback(int32_t advId,int32_t status)89 static void StubAdvEnableCallback(int32_t advId, int32_t status)
90 {
91 SoftbusBleGattTest::advEnableCtx.Update(advId, status);
92 }
93
StubAdvDisableCallback(int32_t advId,int32_t status)94 static void StubAdvDisableCallback(int32_t advId, int32_t status)
95 {
96 SoftbusBleGattTest::advDisableCtx.Update(advId, status);
97 }
98
StubAdvUpdateCallback(int32_t advId,int32_t status)99 static void StubAdvUpdateCallback(int32_t advId, int32_t status)
100 {
101 SoftbusBleGattTest::advUpdateCtx.Update(advId, status);
102 }
103
StubAdvDataCallback(int32_t advId,int32_t status)104 static void StubAdvDataCallback(int32_t advId, int32_t status)
105 {
106 SoftbusBleGattTest::advDataCtx.Update(advId, status);
107 }
108
GetStubAdvCallback()109 SoftbusBroadcastCallback *GetStubAdvCallback()
110 {
111 static SoftbusBroadcastCallback callback = {
112 .OnStartBroadcastingCallback = StubAdvEnableCallback,
113 .OnStopBroadcastingCallback = StubAdvDisableCallback,
114 .OnUpdateBroadcastingCallback = StubAdvUpdateCallback,
115 .OnSetBroadcastingCallback = StubAdvDataCallback,
116 };
117 return &callback;
118 }
119
PrepareScanListener(int32_t * scannerId)120 static testing::AssertionResult PrepareScanListener(int32_t *scannerId)
121 {
122 int32_t ret = MockBluetooth::interface->RegisterScanListener(scannerId, GetStubScanListener());
123 if (ret != SOFTBUS_OK) {
124 return testing::AssertionFailure() << "RegisterScanListener failed";
125 }
126 if (MockBluetooth::bleScanCallback == nullptr) {
127 return testing::AssertionFailure() << "RegisterScanListener is not invoke";
128 }
129 return testing::AssertionSuccess();
130 }
131
CreateScanFilter()132 static SoftBusBcScanFilter *CreateScanFilter()
133 {
134 unsigned char serviceData[] = { 0xE, 0xE, 0xF, 0xF, 0x04, 0x05 };
135 int32_t len = sizeof(serviceData);
136
137 SoftBusBcScanFilter *filter = static_cast<SoftBusBcScanFilter *>(SoftBusCalloc(sizeof(SoftBusBcScanFilter)));
138 unsigned char *serviceDataPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
139 unsigned char *serviceDataMaskPtr = static_cast<unsigned char *>(SoftBusCalloc(len));
140 if (filter == nullptr || serviceDataPtr == nullptr || serviceDataMaskPtr == nullptr) {
141 goto EXIT;
142 }
143 if (memcpy_s(serviceDataPtr, len, serviceData, len) != EOK) {
144 goto EXIT;
145 }
146 if (memset_s(serviceDataMaskPtr, len, 0xFF, len) != EOK) {
147 goto EXIT;
148 }
149 filter->serviceData = serviceDataPtr;
150 filter->serviceDataMask = serviceDataMaskPtr;
151 filter->serviceDataLength = len;
152 return filter;
153 EXIT:
154 SoftBusFree(filter);
155 SoftBusFree(serviceDataPtr);
156 SoftBusFree(serviceDataMaskPtr);
157 return nullptr;
158 }
159
160 /**
161 * @tc.name: TestSoftbusGattInit
162 * @tc.desc: Test lnit will return SOFTBUS_OK when called more than once
163 * @tc.type: FUNC
164 * @tc.require: NONE
165 */
166 HWTEST_F(SoftbusBleGattTest, TestSoftbusGattInit001, TestSize.Level1)
167 {
168 int32_t ret = MockBluetooth::interface->Init();
169 EXPECT_EQ(ret, SOFTBUS_OK);
170
171 ret = MockBluetooth::interface->Init();
172 EXPECT_EQ(ret, SOFTBUS_OK);
173 }
174
175 /**
176 * @tc.name: TestSoftbusGattDeInit
177 * @tc.desc: Test DeInit will return SOFTBUS_OK when called more than once
178 * @tc.type: FUNC
179 * @tc.require: NONE
180 */
181 HWTEST_F(SoftbusBleGattTest, TestSoftbusGattDeInit001, TestSize.Level1)
182 {
183 int32_t ret = MockBluetooth::interface->DeInit();
184 EXPECT_EQ(ret, SOFTBUS_OK);
185
186 ret = MockBluetooth::interface->DeInit();
187 EXPECT_EQ(ret, SOFTBUS_OK);
188 }
189
190 /**
191 * @tc.name: TestSoftbusRegisterAdvCb
192 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_INVALID_PARAM when called more than once
193 * @tc.type: FUNC
194 * @tc.require: NONE
195 */
196 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterAdvCb001, TestSize.Level1)
197 {
198 int32_t ret = MockBluetooth::interface->RegisterBroadcaster(nullptr, nullptr);
199 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
200 }
201
202 // 充当参数
FakeBcBleCallback(int32_t adapterBcld,int32_t status)203 static void FakeBcBleCallback(int32_t adapterBcld, int32_t status)
204 {
205 (void)adapterBcld;
206 (void)status;
207 }
208
209 static SoftbusBroadcastCallback g_softbusBcBleCbTest = {
210 .OnStartBroadcastingCallback = FakeBcBleCallback,
211 .OnStopBroadcastingCallback = FakeBcBleCallback,
212 .OnUpdateBroadcastingCallback = FakeBcBleCallback,
213 .OnSetBroadcastingCallback = FakeBcBleCallback,
214 };
215
216 /**
217 * @tc.name: TestSoftbusRegisterAdvCb002
218 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_LOCK_ERR when called more than once
219 * @tc.type: FUNC
220 * @tc.require: NONE
221 */
222 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterAdvCb002, TestSize.Level1)
223 {
224 int32_t advld = 0;
225 int32_t ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
226 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
227 }
228
229 /**
230 * @tc.name: TestSoftbusRegisterAdvCb003
231 * @tc.desc: Test SoftbusRegisterAdvCb will return OHOS_BT_STATUS_FAIL
232 * @tc.type: FUNC
233 * @tc.require: NONE
234 */
235 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterAdvCb003, TestSize.Level1)
236 {
237 MockBluetooth mocker;
238 int32_t ret = MockBluetooth::interface->Init();
239 EXPECT_EQ(ret, SOFTBUS_OK);
240
241 int32_t advld = 0;
242 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
243 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
244 EXPECT_EQ(ret, OHOS_BT_STATUS_FAIL);
245
246 ret = MockBluetooth::interface->DeInit();
247 EXPECT_EQ(ret, SOFTBUS_OK);
248 }
249
250 /**
251 * @tc.name: TestSoftbusRegisterAdvCb004
252 * @tc.desc: Test SoftbusRegisterAdvCb will return SOFTBUS_OK when BleGattRegisterCallbacks
253 * @tc.type: FUNC
254 * @tc.require: NONE
255 */
256 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterAdvCb004, TestSize.Level1)
257 {
258 MockBluetooth mocker;
259 int32_t ret = MockBluetooth::interface->Init();
260 EXPECT_EQ(ret, SOFTBUS_OK);
261
262 int32_t advld = 0;
263 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
264 EXPECT_EQ(ret, SOFTBUS_OK);
265
266 ret = MockBluetooth::interface->DeInit();
267 EXPECT_EQ(ret, SOFTBUS_OK);
268 }
269
270 /**
271 * @tc.name: TestSoftbusUnRegisterAdvCb001
272 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_INVALID_PARAM when given invalid param
273 * @tc.type: FUNC
274 * @tc.require: NONE
275 */
276 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterAdvCb001, TestSize.Level1)
277 {
278 int32_t ret = MockBluetooth::interface->UnRegisterBroadcaster(GATT_ADV_MAX_NUM);
279 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
280
281 int32_t advld = -1;
282 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
283 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
284 }
285
286 /**
287 * @tc.name: TestSoftbusUnRegisterAdvCb002
288 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_LOCK_ERR when never called init
289 * @tc.type: FUNC
290 * @tc.require: NONE
291 */
292 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterAdvCb002, TestSize.Level1)
293 {
294 int32_t advld = 0;
295 int32_t ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
296 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
297 }
298
299 /**
300 * @tc.name: TestSoftbusUnRegisterAdvCb003
301 * @tc.desc: Test SoftbusUnRegisterAdvCb will return SOFTBUS_OK when given vaild param
302 * @tc.type: FUNC
303 * @tc.require: NONE
304 */
305 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterAdvCb003, TestSize.Level1)
306 {
307 int32_t ret = MockBluetooth::interface->Init();
308 EXPECT_EQ(ret, SOFTBUS_OK);
309
310 int32_t advld = 0;
311 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
312 EXPECT_EQ(ret, SOFTBUS_OK);
313
314 ret = MockBluetooth::interface->UnRegisterBroadcaster(advld);
315 EXPECT_EQ(ret, SOFTBUS_OK);
316
317 ret = MockBluetooth::interface->DeInit();
318 EXPECT_EQ(ret, SOFTBUS_OK);
319 }
320
321 /**
322 * @tc.name: TestSoftbusRegisterScanCb001
323 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_INVALID_PARAM when given invalid param
324 * @tc.type: FUNC
325 * @tc.require: NONE
326 */
327 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterScanCb001, TestSize.Level1)
328 {
329 int32_t ret = MockBluetooth::interface->RegisterScanListener(nullptr, nullptr);
330 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
331 }
332
333 // 充当参数
FakeScanCallback(int32_t adapterScanld,int32_t status)334 static void FakeScanCallback(int32_t adapterScanld, int32_t status)
335 {
336 (void)adapterScanld;
337 (void)status;
338 }
339
FakeReportScanDataCallback(int32_t adapterScanld,const SoftBusBcScanResult * reportData)340 static void FakeReportScanDataCallback(int32_t adapterScanld, const SoftBusBcScanResult *reportData)
341 {
342 (void)adapterScanld;
343 (void)reportData;
344 }
345
FakeScanStateChanged(int32_t resultCode,bool isStartScan)346 static void FakeScanStateChanged(int32_t resultCode, bool isStartScan)
347 {
348 (void)resultCode;
349 (void)isStartScan;
350 }
351
FakeLpDeviceInfoCallback(const SoftbusBroadcastUuid * uuid,int32_t type,uint8_t * data,uint32_t dataSize)352 static void FakeLpDeviceInfoCallback(const SoftbusBroadcastUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
353 {
354 (void)uuid;
355 (void)type;
356 (void)data;
357 (void)dataSize;
358 }
359
360 static SoftbusScanCallback g_softbusBcBleScanCbTest = {
361 .OnStartScanCallback = FakeScanCallback,
362 .OnStopScanCallback = FakeScanCallback,
363 .OnReportScanDataCallback = FakeReportScanDataCallback,
364 .OnScanStateChanged = FakeScanStateChanged,
365 .OnLpDeviceInfoCallback = FakeLpDeviceInfoCallback,
366 };
367
368 /**
369 * @tc.name: TestSoftbusRegisterScanCb002
370 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_LOCK_ERR when never called init
371 * @tc.type: FUNC
372 * @tc.require: NONE
373 */
374 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterScanCb002, TestSize.Level1)
375 {
376 int32_t scannerld = 0;
377 int32_t ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
378 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
379 }
380
381 /**
382 * @tc.name: TestSoftbusRegisterScanCb003
383 * @tc.desc: Test SoftbusRegisterScanCb will return OHOS_BT_STATUS_FAIL
384 * @tc.type: FUNC
385 * @tc.require: NONE
386 */
387 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterScanCb003, TestSize.Level1)
388 {
389 MockBluetooth mocker;
390 int32_t ret = MockBluetooth::interface->Init();
391 EXPECT_EQ(ret, SOFTBUS_OK);
392
393 int32_t scannerld = 0;
394 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
395 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
396 EXPECT_EQ(ret, OHOS_BT_STATUS_FAIL);
397
398 ret = MockBluetooth::interface->DeInit();
399 EXPECT_EQ(ret, SOFTBUS_OK);
400 }
401
402 /**
403 * @tc.name: TestSoftbusRegisterScanCb004
404 * @tc.desc: Test SoftbusRegisterScanCb will return SOFTBUS_BC_ADAPTER_REGISTER_FAIL when scan channel are all uesd
405 * @tc.type: FUNC
406 * @tc.require: NONE
407 */
408 HWTEST_F(SoftbusBleGattTest, TestSoftbusRegisterScanCb004, TestSize.Level1)
409 {
410 MockBluetooth mocker;
411 int32_t ret = MockBluetooth::interface->Init();
412 EXPECT_EQ(ret, SOFTBUS_OK);
413
414 int32_t scannerld = 0;
415 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
416
417 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
418 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
419 EXPECT_EQ(ret, OHOS_BT_STATUS_SUCCESS);
420 }
421
422 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
423 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_REGISTER_FAIL);
424
425 ret = MockBluetooth::interface->DeInit();
426 EXPECT_EQ(ret, SOFTBUS_OK);
427 }
428
429 /**
430 * @tc.name: TestSoftbusUnRegisterScanCb001
431 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_INVALID_PARAM when given invalid param
432 * @tc.type: FUNC
433 * @tc.require: NONE
434 */
435 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterScanCb001, TestSize.Level1)
436 {
437 int32_t scannerld = -1;
438 int32_t ret = MockBluetooth::interface->UnRegisterScanListener(GATT_SCAN_MAX_NUM);
439 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
440
441 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
442 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
443 }
444
445 /**
446 * @tc.name: TestSoftbusUnRegisterScanCb002
447 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_LOCK_ERR when never called init
448 * @tc.type: FUNC
449 * @tc.require: NONE
450 */
451 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterScanCb002, TestSize.Level1)
452 {
453 int32_t scannerld = 0;
454 int32_t ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
455 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
456 }
457
458 /**
459 * @tc.name: TestSoftbusUnRegisterScanCb003
460 * @tc.desc: Test SoftbusUnRegisterScanCb will return SOFTBUS_OK when successfully unregistered
461 * @tc.type: FUNC
462 * @tc.require: NONE
463 */
464 HWTEST_F(SoftbusBleGattTest, TestSoftbusUnRegisterScanCb003, TestSize.Level1)
465 {
466 MockBluetooth mocker;
467 int32_t ret = MockBluetooth::interface->Init();
468 EXPECT_EQ(ret, SOFTBUS_OK);
469
470 int32_t scannerld = 0;
471 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
472 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
473 EXPECT_EQ(ret, SOFTBUS_OK);
474
475 ret = MockBluetooth::interface->UnRegisterScanListener(scannerld);
476 EXPECT_EQ(ret, SOFTBUS_OK);
477
478 ret = MockBluetooth::interface->DeInit();
479 EXPECT_EQ(ret, SOFTBUS_OK);
480 }
481
482 /**
483 * @tc.name: TestSoftbusStartAdv001
484 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_INVALID_PARAM when given invalid param
485 * @tc.type: FUNC
486 * @tc.require: NONE
487 */
488 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartAdv001, TestSize.Level1)
489 {
490 int32_t advld = 0;
491 int32_t ret = MockBluetooth::interface->StartBroadcasting(advld, nullptr, nullptr);
492 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
493 }
494
495 const char ADV_DATA_EXAMPLE[] = {
496 0x02,
497 0x01,
498 0x02,
499 0x15,
500 0x16,
501 0xEE,
502 0xFD,
503 0x04,
504 0x05,
505 0x90,
506 0x00,
507 0x00,
508 0x04,
509 0x00,
510 0x18,
511 0x33,
512 0x39,
513 0x36,
514 0x62,
515 0x33,
516 0x61,
517 0x33,
518 0x31,
519 0x21,
520 0x00,
521 0x02,
522 0x0A,
523 0xEF,
524 };
525 const unsigned char SCAN_RSP_DATA_EXAMPLE[] = { 0x03, 0xFF, 0x7D, 0x02 };
526
527 /**
528 * @tc.name: TestSoftbusStartAdv002
529 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_LOCK_ERR when never called init
530 * @tc.type: FUNC
531 * @tc.require: NONE
532 */
533 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartAdv002, TestSize.Level1)
534 {
535 int32_t advld = 0;
536 SoftbusBroadcastParam params = {};
537 SoftbusBroadcastData data = {};
538 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
539 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
540 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
541 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
542
543 int32_t ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
544 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
545 }
546
547 /**
548 * @tc.name: TestSoftbusStartAdv003
549 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld is not used
550 * @tc.type: FUNC
551 * @tc.require: NONE
552 */
553 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartAdv003, TestSize.Level1)
554 {
555 int32_t ret = MockBluetooth::interface->Init();
556 EXPECT_EQ(ret, SOFTBUS_OK);
557
558 int32_t advld = 0;
559 SoftbusBroadcastParam params = {};
560 SoftbusBroadcastData data = {};
561 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
562 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
563 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
564 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
565
566 ret = MockBluetooth::interface->StartBroadcasting(GATT_ADV_MAX_NUM, ¶ms, &data);
567 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
568
569 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
570 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
571
572 ret = MockBluetooth::interface->DeInit();
573 EXPECT_EQ(ret, SOFTBUS_OK);
574 }
575
576 /**
577 * @tc.name: TestSoftbusStartAdv004
578 * @tc.desc: Test SoftbusStartAdv will return SOFTBUS_ALREADY_TRIGGERED
579 * @tc.type: FUNC
580 * @tc.require: NONE
581 */
582 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartAdv004, TestSize.Level1)
583 {
584 MockBluetooth mocker;
585 int32_t ret = MockBluetooth::interface->Init();
586 EXPECT_EQ(ret, SOFTBUS_OK);
587
588 int32_t advld = 0;
589 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
590 EXPECT_EQ(ret, SOFTBUS_OK);
591
592 EXPECT_CALL(mocker, BleStartAdvEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
593 SoftbusBroadcastParam params = {};
594 SoftbusBroadcastData data = {};
595 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
596 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
597 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
598 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
599
600 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
601 ret = MockBluetooth::interface->StartBroadcasting(advld, ¶ms, &data);
602 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
603 ret = MockBluetooth::interface->DeInit();
604 EXPECT_EQ(ret, SOFTBUS_OK);
605 }
606
607 /**
608 * @tc.name: TestSoftbusStopAdv001
609 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_LOCK_ERR when never called lnit
610 * @tc.type: FUNC
611 * @tc.require: NONE
612 */
613 HWTEST_F(SoftbusBleGattTest, TestSoftbusStopAdv001, TestSize.Level1)
614 {
615 int32_t advld = 0;
616 int32_t ret = MockBluetooth::interface->StopBroadcasting(advld);
617 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
618 }
619
620 /**
621 * @tc.name: TestSoftbusStopAdv002
622 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld never registed
623 * @tc.type: FUNC
624 * @tc.require: NONE
625 */
626 HWTEST_F(SoftbusBleGattTest, TestSoftbusStopAdv002, TestSize.Level1)
627 {
628 int32_t ret = MockBluetooth::interface->Init();
629 EXPECT_EQ(ret, SOFTBUS_OK);
630
631 ret = MockBluetooth::interface->StopBroadcasting(GATT_ADV_MAX_NUM);
632 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
633
634 ret = MockBluetooth::interface->DeInit();
635 EXPECT_EQ(ret, SOFTBUS_OK);
636 }
637
638 /**
639 * @tc.name: TestSoftbusStopAdv004
640 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_OK when advld has been registed
641 * @tc.type: FUNC
642 * @tc.require: NONE
643 */
644 HWTEST_F(SoftbusBleGattTest, TestSoftbusStopAdv004, TestSize.Level1)
645 {
646 MockBluetooth mocker;
647 int32_t ret = MockBluetooth::interface->Init();
648 EXPECT_EQ(ret, SOFTBUS_OK);
649
650 int32_t advld = 0;
651 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
652 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
653 EXPECT_EQ(ret, SOFTBUS_OK);
654
655 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
656 ret = MockBluetooth::interface->StopBroadcasting(advld);
657 EXPECT_EQ(ret, SOFTBUS_OK);
658
659 ret = MockBluetooth::interface->DeInit();
660 EXPECT_EQ(ret, SOFTBUS_OK);
661 }
662
663 /**
664 * @tc.name: TestSoftbusStopAdv005
665 * @tc.desc: Test SoftbusStopAdv will return SOFTBUS_OK when advld has been stopped
666 * @tc.type: FUNC
667 * @tc.require: NONE
668 */
669 HWTEST_F(SoftbusBleGattTest, TestSoftbusStopAdv005, TestSize.Level1)
670 {
671 MockBluetooth mocker;
672 int32_t ret = MockBluetooth::interface->Init();
673 EXPECT_EQ(ret, SOFTBUS_OK);
674
675 int32_t advld = 0;
676 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
677 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
678 EXPECT_EQ(ret, SOFTBUS_OK);
679
680 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
681 ret = MockBluetooth::interface->StopBroadcasting(advld);
682 EXPECT_EQ(ret, SOFTBUS_OK);
683
684 ret = MockBluetooth::interface->StopBroadcasting(advld);
685 EXPECT_EQ(ret, SOFTBUS_OK);
686
687 ret = MockBluetooth::interface->DeInit();
688 EXPECT_EQ(ret, SOFTBUS_OK);
689 }
690
691 /**
692 * @tc.name: TestSoftbusSetAdvData001
693 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_INVALID_PARAM when given invalid param
694 * @tc.type: FUNC
695 * @tc.require: NONE
696 */
697 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetAdvData001, TestSize.Level1)
698 {
699 int32_t advld = 0;
700 int32_t ret = MockBluetooth::interface->SetBroadcastingData(advld, nullptr);
701 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
702 }
703
704 /**
705 * @tc.name: TestSoftbusSetAdvData002
706 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_LOCK_ERR when never lnit
707 * @tc.type: FUNC
708 * @tc.require: NONE
709 */
710 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetAdvData002, TestSize.Level1)
711 {
712 int32_t advld = 0;
713 SoftbusBroadcastData data = {};
714 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
715 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
716 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
717 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
718
719 int32_t ret = MockBluetooth::interface->SetBroadcastingData(advld, &data);
720 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
721 }
722
723 /**
724 * @tc.name: TestSoftbusSetAdvData003
725 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when advld is not used
726 * @tc.type: FUNC
727 * @tc.require: NONE
728 */
729 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetAdvData003, TestSize.Level1)
730 {
731 int32_t ret = MockBluetooth::interface->Init();
732 EXPECT_EQ(ret, SOFTBUS_OK);
733
734 SoftbusBroadcastData data = {};
735 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
736 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
737 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
738 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
739
740 ret = MockBluetooth::interface->SetBroadcastingData(GATT_ADV_MAX_NUM, &data);
741 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
742
743 ret = MockBluetooth::interface->DeInit();
744 EXPECT_EQ(ret, SOFTBUS_OK);
745 }
746
747 /**
748 * @tc.name: TestSoftbusSetAdvData005
749 * @tc.desc: Test SoftbusSetAdvData will return SOFTBUS_ALREADY_TRIGGERED when broadcast has already registed
750 * @tc.type: FUNC
751 * @tc.require: NONE
752 */
753 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetAdvData005, TestSize.Level1)
754 {
755 MockBluetooth mocker;
756 int32_t ret = MockBluetooth::interface->Init();
757 EXPECT_EQ(ret, SOFTBUS_OK);
758
759 int32_t advld = 0;
760 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
761 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
762 EXPECT_EQ(ret, SOFTBUS_OK);
763
764 SoftbusBroadcastData data = {};
765 data.bcData.payloadLen = sizeof(ADV_DATA_EXAMPLE);
766 data.bcData.payload = (uint8_t *)ADV_DATA_EXAMPLE;
767 data.rspData.payloadLen = sizeof(SCAN_RSP_DATA_EXAMPLE);
768 data.rspData.payload = (uint8_t *)SCAN_RSP_DATA_EXAMPLE;
769
770 ret = MockBluetooth::interface->SetBroadcastingData(advld, &data);
771 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
772
773 ret = MockBluetooth::interface->DeInit();
774 EXPECT_EQ(ret, SOFTBUS_OK);
775 }
776
777 /**
778 * @tc.name: TestSoftbusUpdateAdvData001
779 * @tc.desc: Test SoftbusUpdateAdvData will return SOFTBUS_LOCK_ERR when never called init
780 * @tc.type: FUNC
781 * @tc.require: NONE
782 */
783 HWTEST_F(SoftbusBleGattTest, TestSoftbusUpdateAdvData001, TestSize.Level1)
784 {
785 int32_t advld = 0;
786 int32_t ret = MockBluetooth::interface->UpdateBroadcasting(advld, nullptr, nullptr);
787 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
788 }
789
790 /**
791 * @tc.name: TestSoftbusUpdateAdvData002
792 * @tc.desc: Test SoftbusUpdateAdvData will return SOFTBUS_INVALID_PARAM when given invalid params
793 * @tc.type: FUNC
794 * @tc.require: NONE
795 */
796 HWTEST_F(SoftbusBleGattTest, TestSoftbusUpdateAdvData002, TestSize.Level1)
797 {
798 MockBluetooth mocker;
799 int32_t ret = MockBluetooth::interface->Init();
800 EXPECT_EQ(ret, SOFTBUS_OK);
801
802 int32_t advld = 0;
803 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
804 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
805 EXPECT_EQ(ret, SOFTBUS_OK);
806
807 EXPECT_CALL(mocker, BleStopAdv).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
808 ret = MockBluetooth::interface->UpdateBroadcasting(advld, nullptr, nullptr);
809 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
810
811 ret = MockBluetooth::interface->DeInit();
812 EXPECT_EQ(ret, SOFTBUS_OK);
813 }
814
815 /**
816 * @tc.name: TestSoftbusStartScan001
817 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_INVALID_PARAM when given invalid params
818 * @tc.type: FUNC
819 * @tc.require: NONE
820 */
821 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartScan001, TestSize.Level1)
822 {
823 int32_t scannerld = 0;
824 int32_t ret = MockBluetooth::interface->StartScan(scannerld, nullptr, nullptr, 0);
825 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
826 }
827
828 /**
829 * @tc.name: TestSoftbusStartScan002
830 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_LOCK_ERR when never called init
831 * @tc.type: FUNC
832 * @tc.require: NONE
833 */
834 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartScan002, TestSize.Level1)
835 {
836 SoftBusBcScanParams scanParam = {
837 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
838 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
839 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
840 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
841 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
842 };
843
844 SoftBusBcScanFilter softBusBcScanFilter = {};
845 softBusBcScanFilter.address = (int8_t *)"address";
846 softBusBcScanFilter.deviceName = (int8_t *)"deviceName";
847 softBusBcScanFilter.serviceUuid = 1;
848 softBusBcScanFilter.serviceDataLength = 1;
849 softBusBcScanFilter.manufactureId = 1;
850 softBusBcScanFilter.manufactureDataLength = 1;
851
852 int32_t scannerld = 0;
853 int32_t filterSize = 1;
854 int32_t ret = MockBluetooth::interface->StartScan(scannerld, &scanParam, &softBusBcScanFilter, filterSize);
855 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
856 }
857
858 /**
859 * @tc.name: TestSoftbusStartScan003
860 * @tc.desc: Test SoftbusStartScan will return SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL when given invalid params scannerld
861 * @tc.type: FUNC
862 * @tc.require: NONE
863 */
864 HWTEST_F(SoftbusBleGattTest, TestSoftbusStartScan003, TestSize.Level1)
865 {
866 int32_t ret = MockBluetooth::interface->Init();
867 EXPECT_EQ(ret, SOFTBUS_OK);
868
869 SoftBusBcScanParams scanParam = {
870 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
871 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
872 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
873 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
874 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
875 };
876
877 SoftBusBcScanFilter softBusBcScanFilter = {};
878 softBusBcScanFilter.address = (int8_t *)"address";
879 softBusBcScanFilter.deviceName = (int8_t *)"deviceName";
880 softBusBcScanFilter.serviceUuid = 1;
881 softBusBcScanFilter.serviceDataLength = 1;
882 softBusBcScanFilter.manufactureId = 1;
883 softBusBcScanFilter.manufactureDataLength = 1;
884
885 int32_t filterSize = 1;
886 ret = MockBluetooth::interface->StartScan(GATT_SCAN_MAX_NUM, &scanParam, &softBusBcScanFilter, filterSize);
887 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
888
889 ret = MockBluetooth::interface->DeInit();
890 EXPECT_EQ(ret, SOFTBUS_OK);
891 }
892
893 /**
894 * @tc.name: SoftbusGetBroadcastHandle001
895 * @tc.desc: Test SoftbusGetBroadcastHandle is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
896 * @tc.type: FUNC
897 * @tc.require: NONE
898 */
899 HWTEST_F(SoftbusBleGattTest, SoftbusGetBroadcastHandle001, TestSize.Level1)
900 {
901 MockBluetooth mocker;
902 int32_t ret = MockBluetooth::interface->Init();
903 EXPECT_EQ(ret, SOFTBUS_OK);
904
905 int32_t bchand = 0;
906
907 ret = MockBluetooth::interface->GetBroadcastHandle(GATT_ADV_MAX_NUM, &bchand);
908 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
909
910 ret = MockBluetooth::interface->DeInit();
911 EXPECT_EQ(ret, SOFTBUS_OK);
912 }
913
914 /**
915 * @tc.name: SoftbusGetBroadcastHandle002
916 * @tc.desc: Test SoftbusGetBroadcastHandle is SOFTBUS_OK
917 * @tc.type: FUNC
918 * @tc.require: NONE
919 */
920 HWTEST_F(SoftbusBleGattTest, SoftbusGetBroadcastHandle002, TestSize.Level1)
921 {
922 MockBluetooth mocker;
923 int32_t ret = MockBluetooth::interface->Init();
924 EXPECT_EQ(ret, SOFTBUS_OK);
925
926 int32_t advld = 0;
927 int32_t bchand = 0;
928
929 EXPECT_CALL(mocker, BleRegisterScanCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
930 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
931 EXPECT_EQ(ret, SOFTBUS_OK);
932
933 EXPECT_CALL(mocker, GetAdvHandle).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
934 ret = MockBluetooth::interface->GetBroadcastHandle(advld, &bchand);
935 EXPECT_EQ(ret, SOFTBUS_OK);
936
937 ret = MockBluetooth::interface->DeInit();
938 EXPECT_EQ(ret, SOFTBUS_OK);
939 }
940
941 /**
942 * @tc.name: SoftbusEnableSyncDataToLp
943 * @tc.desc: Test SoftbusEnableSyncDataToLp is SOFTBUS_OK
944 * @tc.type: FUNC
945 * @tc.require: NONE
946 */
947 HWTEST_F(SoftbusBleGattTest, SoftbusEnableSyncDataToLp, TestSize.Level1)
948 {
949 MockBluetooth mocker;
950 int32_t ret = MockBluetooth::interface->Init();
951 EXPECT_EQ(ret, SOFTBUS_OK);
952
953 EXPECT_CALL(mocker, EnableSyncDataToLpDevice).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
954 ret = MockBluetooth::interface->EnableSyncDataToLpDevice();
955 EXPECT_EQ(ret, SOFTBUS_OK);
956
957 ret = MockBluetooth::interface->DeInit();
958 EXPECT_EQ(ret, SOFTBUS_OK);
959 }
960
961 /**
962 * @tc.name: SoftbusDisableSyncDataToLp
963 * @tc.desc: Test DisableSyncDataToLpDevice is SOFTBUS_OK
964 * @tc.type: FUNC
965 * @tc.require: NONE
966 */
967 HWTEST_F(SoftbusBleGattTest, DisableSyncDataToLpDevice, TestSize.Level1)
968 {
969 MockBluetooth mocker;
970 int32_t ret = MockBluetooth::interface->Init();
971 EXPECT_EQ(ret, SOFTBUS_OK);
972
973 EXPECT_CALL(mocker, DisableSyncDataToLpDevice).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
974 ret = MockBluetooth::interface->DisableSyncDataToLpDevice();
975 EXPECT_EQ(ret, SOFTBUS_OK);
976
977 ret = MockBluetooth::interface->DeInit();
978 EXPECT_EQ(ret, SOFTBUS_OK);
979 }
980
981 /**
982 * @tc.name: SoftbusSetScanReportChanToLp001
983 * @tc.desc: Test SoftbusSetScanReportChanToLp is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
984 * @tc.type: FUNC
985 * @tc.require: NONE
986 */
987 HWTEST_F(SoftbusBleGattTest, SoftbusSetScanReportChanToLp001, TestSize.Level1)
988 {
989 MockBluetooth mocker;
990 int32_t ret = MockBluetooth::interface->Init();
991 EXPECT_EQ(ret, SOFTBUS_OK);
992
993 ret = MockBluetooth::interface->SetScanReportChannelToLpDevice(GATT_ADV_MAX_NUM, false);
994 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
995
996 ret = MockBluetooth::interface->DeInit();
997 EXPECT_EQ(ret, SOFTBUS_OK);
998 }
999
1000 /**
1001 * @tc.name: SoftbusSetLpAdvParam
1002 * @tc.desc: Test SoftbusSetLpAdvParam is SOFTBUS_OK
1003 * @tc.type: FUNC
1004 * @tc.require: NONE
1005 */
1006 HWTEST_F(SoftbusBleGattTest, SoftbusSetLpAdvParam, TestSize.Level1)
1007 {
1008 MockBluetooth mocker;
1009 int32_t ret = MockBluetooth::interface->Init();
1010 EXPECT_EQ(ret, SOFTBUS_OK);
1011
1012 int32_t duration = 0;
1013 int32_t maxExtAdvEvents = 0;
1014 int32_t window = 0;
1015 int32_t interval = 0;
1016 int32_t bcHandle = 0;
1017
1018 EXPECT_CALL(mocker, SetLpDeviceAdvParam).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1019 ret = MockBluetooth::interface->SetLpDeviceParam(duration, maxExtAdvEvents, window, interval, bcHandle);
1020 EXPECT_EQ(ret, SOFTBUS_OK);
1021
1022 ret = MockBluetooth::interface->DeInit();
1023 EXPECT_EQ(ret, SOFTBUS_OK);
1024 }
1025
1026 /**
1027 * @tc.name: SoftbusStopScan001
1028 * @tc.desc: Test SoftbusStopScan is SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL
1029 * @tc.type: FUNC
1030 * @tc.require: NONE
1031 */
1032 HWTEST_F(SoftbusBleGattTest, SoftbusStopScan001, TestSize.Level1)
1033 {
1034 MockBluetooth mocker;
1035 int32_t ret = MockBluetooth::interface->Init();
1036 EXPECT_EQ(ret, SOFTBUS_OK);
1037
1038 ret = MockBluetooth::interface->StopScan(GATT_ADV_MAX_NUM);
1039 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1040
1041 ret = MockBluetooth::interface->DeInit();
1042 EXPECT_EQ(ret, SOFTBUS_OK);
1043 }
1044
1045 /**
1046 * @tc.name: TestWrapperAdvEnableCb
1047 * @tc.desc: Test WrapperAdvEnableCb
1048 * @tc.type: FUNC
1049 * @tc.require: NONE
1050 */
1051 HWTEST_F(SoftbusBleGattTest, TestWrapperAdvEnableCb, TestSize.Level1)
1052 {
1053 DISC_LOGI(DISC_TEST, "TestWrapperAdvEnableCb enter");
1054 MockBluetooth mocker;
1055 int32_t ret = MockBluetooth::interface->Init();
1056 EXPECT_EQ(ret, SOFTBUS_OK);
1057
1058 int32_t advld = 0;
1059
1060 ret = MockBluetooth::interface->RegisterBroadcaster(&advld, &g_softbusBcBleCbTest);
1061 EXPECT_EQ(ret, SOFTBUS_OK);
1062
1063 MockBluetooth::btGattCallback->advDataCb(advld, 1);
1064
1065 MockBluetooth::btGattCallback->advUpdateCb(advld, 1);
1066
1067 ret = MockBluetooth::interface->DeInit();
1068 EXPECT_EQ(ret, SOFTBUS_OK);
1069 }
1070
1071 /**
1072 * @tc.name: TestWrapperScanStateChangeCb0
1073 * @tc.desc: Test WrapperScanStateChangeCb0
1074 * @tc.type: FUNC
1075 * @tc.require: NONE
1076 */
1077 HWTEST_F(SoftbusBleGattTest, TestWrapperScanStateChangeCb0, TestSize.Level1)
1078 {
1079 DISC_LOGI(DISC_TEST, "TestWrapperAdvEnableCb enter");
1080 MockBluetooth mocker;
1081 int32_t ret = MockBluetooth::interface->Init();
1082 EXPECT_EQ(ret, SOFTBUS_OK);
1083
1084 int32_t scannerld = 0;
1085
1086 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
1087 EXPECT_EQ(ret, SOFTBUS_OK);
1088
1089 MockBluetooth::bleScanCallback->scanStateChangeCb(scannerld, true);
1090 MockBluetooth::bleScanCallback->scanStateChangeCb(scannerld, false);
1091
1092 ret = MockBluetooth::interface->DeInit();
1093 EXPECT_EQ(ret, SOFTBUS_OK);
1094 }
1095
1096 /**
1097 * @tc.name: TestWrapperLpDeviceInfoCb
1098 * @tc.desc: Test WrapperLpDeviceInfoCb
1099 * @tc.type: FUNC
1100 * @tc.require: NONE
1101 */
1102 HWTEST_F(SoftbusBleGattTest, TestWrapperLpDeviceInfoCb, TestSize.Level1)
1103 {
1104 DISC_LOGI(DISC_TEST, "TestWrapperAdvEnableCb enter");
1105 MockBluetooth mocker;
1106 int32_t ret = MockBluetooth::interface->Init();
1107 EXPECT_EQ(ret, SOFTBUS_OK);
1108
1109 int32_t scannerld = 0;
1110 BtUuid uuid = {};
1111 int32_t type = 0;
1112 uint8_t data = 0;
1113 uint32_t dataSize = 0;
1114
1115 ret = MockBluetooth::interface->RegisterScanListener(&scannerld, &g_softbusBcBleScanCbTest);
1116 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_REGISTER_FAIL);
1117
1118 MockBluetooth::bleScanCallback->lpDeviceInfoCb(&uuid, type, &data, dataSize);
1119
1120 ret = MockBluetooth::interface->DeInit();
1121 EXPECT_EQ(ret, SOFTBUS_OK);
1122 }
1123
1124 /**
1125 * @tc.name: TestIsLpAvailable
1126 * @tc.desc: Test IsLpAvailable
1127 * @tc.type: FUNC
1128 * @tc.require: NONE
1129 */
1130 HWTEST_F(SoftbusBleGattTest, TestIsLpAvailable, TestSize.Level1)
1131 {
1132 MockBluetooth mocker;
1133 int32_t ret = MockBluetooth::interface->Init();
1134 EXPECT_EQ(ret, SOFTBUS_OK);
1135
1136 ret = MockBluetooth::interface->IsLpDeviceAvailable();
1137 EXPECT_EQ(ret, true);
1138
1139 ret = MockBluetooth::interface->DeInit();
1140 EXPECT_EQ(ret, SOFTBUS_OK);
1141 }
1142
1143 /**
1144 * @tc.name: TestSoftbusSetLpParam001
1145 * @tc.desc: Test SoftbusSetLpParam
1146 * @tc.type: FUNC
1147 * @tc.require: NONE
1148 */
1149 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetLpParam001, TestSize.Level1)
1150 {
1151 MockBluetooth mocker;
1152 int32_t ret = MockBluetooth::interface->Init();
1153 EXPECT_EQ(ret, SOFTBUS_OK);
1154
1155 SoftBusLpBroadcastParam bcParam = {};
1156 SoftBusLpScanParam scanParam = {};
1157
1158 ret = MockBluetooth::interface->SetAdvFilterParam(SOFTBUS_BURST_TYPE, &bcParam, &scanParam);
1159 EXPECT_EQ(ret, false);
1160
1161 ret = MockBluetooth::interface->DeInit();
1162 EXPECT_EQ(ret, SOFTBUS_OK);
1163 }
1164
1165 /**
1166 * @tc.name: TestSoftbusSetLpParam002
1167 * @tc.desc: Test SoftbusSetLpParam when SetBtUuidByBroadCastType return error
1168 * @tc.type: FUNC
1169 * @tc.require: NONE
1170 */
1171 HWTEST_F(SoftbusBleGattTest, TestSoftbusSetLpParam002, TestSize.Level1)
1172 {
1173 MockBluetooth mocker;
1174 int32_t ret = MockBluetooth::interface->Init();
1175 EXPECT_EQ(ret, SOFTBUS_OK);
1176
1177 SoftBusLpBroadcastParam bcParam = {};
1178 SoftBusLpScanParam scanParam = {};
1179 scanParam.filterSize = 1;
1180
1181 ret = MockBluetooth::interface->SetAdvFilterParam(SOFTBUS_UNKNOW_TYPE, &bcParam, &scanParam);
1182 EXPECT_EQ(ret, false);
1183
1184 ret = MockBluetooth::interface->DeInit();
1185 EXPECT_EQ(ret, SOFTBUS_OK);
1186 }
1187
1188 /**
1189 * @tc.name: AdapterBleGattTest_RegisterScanListener
1190 * @tc.desc: test register scan listener
1191 * @tc.type: FUNC
1192 * @tc.require: NONE
1193 */
1194 HWTEST_F(SoftbusBleGattTest, RegisterScanListener, TestSize.Level3)
1195 {
1196 MockBluetooth mocker;
1197 int32_t scannerId = -1;
1198 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, nullptr), SOFTBUS_INVALID_PARAM);
1199 int32_t scanListerIds[GATT_SCAN_MAX_NUM] = {};
1200 int32_t ret = SOFTBUS_ERR;
1201 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
1202 ret = MockBluetooth::interface->RegisterScanListener(&scanListerIds[i], GetStubScanListener());
1203 ASSERT_EQ(ret, SOFTBUS_LOCK_ERR);
1204 }
1205
1206 ASSERT_EQ(MockBluetooth::interface->RegisterScanListener(&scannerId, GetStubScanListener()), SOFTBUS_LOCK_ERR);
1207
1208 for (size_t i = 0; i < GATT_SCAN_MAX_NUM; i++) {
1209 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scanListerIds[i]), SOFTBUS_LOCK_ERR);
1210 }
1211 }
1212
1213 /**
1214 * @tc.name: AdapterBleGattTest_UnRegisterScanListener
1215 * @tc.desc: test unregister scan listener
1216 * @tc.type: FUNC
1217 * @tc.require: NONE
1218 */
1219 HWTEST_F(SoftbusBleGattTest, UnRegisterScanListener, TestSize.Level3)
1220 {
1221 MockBluetooth mocker;
1222 int32_t scannerId = -1;
1223 auto result = PrepareScanListener(&scannerId);
1224
1225 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(-1), SOFTBUS_INVALID_PARAM);
1226 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(GATT_SCAN_MAX_NUM), SOFTBUS_INVALID_PARAM);
1227 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_INVALID_PARAM);
1228 }
1229
1230 /**
1231 * @tc.name: AdapterBleGattTest_ScanLifecycle
1232 * @tc.desc: test complete scan life cycle
1233 * @tc.type: FUNC
1234 * @tc.require: NONE
1235 */
1236 HWTEST_F(SoftbusBleGattTest, ScanLifecycle, TestSize.Level3)
1237 {
1238 MockBluetooth mocker;
1239 int32_t scannerId = -1;
1240 auto result = PrepareScanListener(&scannerId);
1241
1242 auto filter = CreateScanFilter();
1243 ASSERT_NE(filter, nullptr);
1244
1245 SoftBusBcScanParams scanParam = {
1246 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
1247 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
1248 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
1249 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
1250 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
1251 };
1252
1253 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1254 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_LOCK_ERR);
1255
1256 EXPECT_CALL(mocker, BleStopScan).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1257 ASSERT_EQ(MockBluetooth::interface->StopScan(scannerId), SOFTBUS_LOCK_ERR);
1258
1259 ASSERT_EQ(MockBluetooth::interface->UnRegisterScanListener(scannerId), SOFTBUS_INVALID_PARAM);
1260 }
1261
1262 /**
1263 * @tc.name: AdapterBleGattTest_ScanResultCb
1264 * @tc.desc: test scan result callback
1265 * @tc.type: FUNC
1266 * @tc.require: NONE
1267 */
1268 HWTEST_F(SoftbusBleGattTest, ScanResultCb, TestSize.Level3)
1269 {
1270 MockBluetooth mocker;
1271 int32_t scannerId = -1;
1272 auto result = PrepareScanListener(&scannerId);
1273
1274 auto filter = CreateScanFilter();
1275 ASSERT_NE(filter, nullptr);
1276
1277 SoftBusBcScanParams scanParam = {
1278 .scanInterval = SOFTBUS_BC_SCAN_WINDOW_P10,
1279 .scanWindow = SOFTBUS_BC_SCAN_INTERVAL_P10,
1280 .scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE,
1281 .scanPhy = SOFTBUS_BC_SCAN_PHY_1M,
1282 .scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL,
1283 };
1284
1285 EXPECT_CALL(mocker, BleStartScanEx).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1286 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, nullptr, filter, 1), SOFTBUS_INVALID_PARAM);
1287 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, nullptr, 1), SOFTBUS_INVALID_PARAM);
1288 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 0), SOFTBUS_INVALID_PARAM);
1289 ASSERT_EQ(MockBluetooth::interface->StartScan(scannerId, &scanParam, filter, 1), SOFTBUS_LOCK_ERR);
1290
1291 const unsigned char scanDataExample[] = { 0x02, 0x01, 0x02, 0x15, 0x16, 0xEE, 0xFD, 0x04, 0x05, 0x90, 0x00, 0x00,
1292 0x04, 0x00, 0x18, 0x33, 0x39, 0x36, 0x62, 0x33, 0x61, 0x33, 0x31, 0x21, 0x00, 0x02, 0x0A, 0xEF, 0x03, 0xFF,
1293 0x7D, 0x02 };
1294 SoftBusBcScanResult expectScanResult = { 0 };
1295 expectScanResult.data.bcData.payloadLen = sizeof(scanDataExample);
1296 expectScanResult.data.bcData.payload = (unsigned char *)scanDataExample;
1297 BtScanResultData mockScanResult = { 0 };
1298 mockScanResult.advLen = sizeof(scanDataExample);
1299 mockScanResult.advData = (unsigned char *)scanDataExample;
1300
1301 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
1302 mockScanResult.dataStatus = OHOS_BLE_DATA_COMPLETE;
1303 mockScanResult.addrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
1304 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
1305 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_NO_PACKET;
1306 mockScanResult.directAddrType = OHOS_BLE_PUBLIC_DEVICE_ADDRESS;
1307 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
1308
1309 mockScanResult.eventType = OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
1310 mockScanResult.dataStatus = OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
1311 mockScanResult.addrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
1312 mockScanResult.primaryPhy = OHOS_BLE_SCAN_PHY_1M;
1313 mockScanResult.secondaryPhy = OHOS_BLE_SCAN_PHY_1M;
1314 mockScanResult.directAddrType = OHOS_BLE_RANDOM_DEVICE_ADDRESS;
1315 ASSERT_FALSE(scanResultCtx.Expect(scannerId, &expectScanResult));
1316 }
1317
1318 /**
1319 * @tc.name: AdapterBleGattTest_RegisterBroadcaster
1320 * @tc.desc: test register adv callback
1321 * @tc.type: FUNC
1322 * @tc.require: NONE
1323 */
1324 HWTEST_F(SoftbusBleGattTest, RegisterBroadcaster, TestSize.Level3)
1325 {
1326 int32_t advId = -1;
1327 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, nullptr), SOFTBUS_INVALID_PARAM);
1328 int32_t advIds[GATT_ADV_MAX_NUM];
1329 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
1330 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advIds[i], GetStubAdvCallback()), SOFTBUS_LOCK_ERR);
1331 }
1332 ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, GetStubAdvCallback()), SOFTBUS_LOCK_ERR);
1333 for (size_t i = 0; i < GATT_ADV_MAX_NUM; i++) {
1334 ASSERT_EQ(MockBluetooth::interface->UnRegisterBroadcaster(advIds[i]), SOFTBUS_LOCK_ERR);
1335 }
1336 }
1337
ScanResultCtx(const char * identifier)1338 ScanResultCtx::ScanResultCtx(const char *identifier) : RecordCtx(identifier)
1339 {
1340 Reset();
1341 }
~ScanResultCtx()1342 ScanResultCtx::~ScanResultCtx()
1343 {
1344 Reset();
1345 }
1346
Reset()1347 void ScanResultCtx::Reset()
1348 {
1349 SoftBusFree(scanResult.data.bcData.payload);
1350 SoftBusFree(scanResult.data.rspData.payload);
1351 scanResult.data.bcData.payload = nullptr;
1352 scanResult.data.rspData.payload = nullptr;
1353 }
1354
Update(int32_t id,const SoftBusBcScanResult * scanResult)1355 bool ScanResultCtx::Update(int32_t id, const SoftBusBcScanResult *scanResult)
1356 {
1357 if (!RecordCtx::Update(id)) {
1358 return false;
1359 }
1360 this->scanResult = *scanResult;
1361 unsigned char *cpyAdvData = static_cast<unsigned char *>(SoftBusCalloc(this->scanResult.data.bcData.payloadLen));
1362 if (cpyAdvData == nullptr) {
1363 DISC_LOGE(DISC_TEST, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
1364 return false;
1365 }
1366
1367 if (memcpy_s(cpyAdvData, this->scanResult.data.bcData.payloadLen, scanResult->data.bcData.payload,
1368 scanResult->data.bcData.payloadLen) != EOK) {
1369 DISC_LOGE(DISC_TEST, "malloc failed in OnReportScanDataCallback, can not save ctx, id=%{public}d", id);
1370 SoftBusFree(cpyAdvData);
1371 return false;
1372 }
1373 this->scanResult.data.bcData.payload = cpyAdvData;
1374 return true;
1375 }
1376
Expect(int32_t id,const SoftBusBcScanResult * scanResultParam)1377 testing::AssertionResult ScanResultCtx::Expect(int32_t id, const SoftBusBcScanResult *scanResultParam)
1378 {
1379 auto result = RecordCtx::Expect(id);
1380 if (!result) {
1381 goto ClEANUP;
1382 }
1383
1384 if (this->scanResult.data.bcData.payloadLen == scanResultParam->data.bcData.payloadLen &&
1385 memcmp(this->scanResult.data.bcData.payload, scanResultParam->data.bcData.payload,
1386 scanResultParam->data.bcData.payloadLen) == 0) {
1387 result = testing::AssertionSuccess();
1388 goto ClEANUP;
1389 }
1390 result = testing::AssertionFailure() << identifier << " is call by unexpectedly scan result.";
1391 ClEANUP:
1392 Reset();
1393 return result;
1394 }
1395
1396 /**
1397 * @tc.name: SoftbusSetAdvParamterTest001
1398 * @tc.desc: Test SoftbusSetAdvParamter when param == NULL
1399 * @tc.type: FUNC
1400 * @tc.require: NONE
1401 */
1402 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest001, TestSize.Level1)
1403 {
1404 int32_t advId = 0;
1405 int32_t ret = MockBluetooth::interface->SetBroadcastingParam(advId, nullptr);
1406 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1407 }
1408
1409 /**
1410 * @tc.name: SoftbusSetAdvParamterTest002
1411 * @tc.desc: Test SoftbusSetAdvParamter when CheckAdvChanInUsed return false
1412 * @tc.type: FUNC
1413 * @tc.require: NONE
1414 */
1415 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest002, TestSize.Level1)
1416 {
1417 int32_t advId = GATT_ADV_MAX_NUM;
1418 SoftbusBroadcastParam params = {};
1419 MockBluetooth mocker;
1420 int32_t ret = MockBluetooth::interface->Init();
1421 EXPECT_EQ(ret, SOFTBUS_OK);
1422
1423 ret = MockBluetooth::interface->SetBroadcastingParam(advId, ¶ms);
1424 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1425
1426 ret = MockBluetooth::interface->DeInit();
1427 EXPECT_EQ(ret, SOFTBUS_OK);
1428 }
1429
1430 /**
1431 * @tc.name: SoftbusSetAdvParamterTest003
1432 * @tc.desc: Test SoftbusSetAdvParamter when isAdvertising is false
1433 * @tc.type: FUNC
1434 * @tc.require: NONE
1435 */
1436 HWTEST_F(SoftbusBleGattTest, SoftbusSetAdvParamterTest003, TestSize.Level1)
1437 {
1438 MockBluetooth mocker;
1439 int32_t ret = MockBluetooth::interface->Init();
1440 EXPECT_EQ(ret, SOFTBUS_OK);
1441
1442 int32_t advId = 0;
1443 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1444 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
1445 EXPECT_EQ(ret, SOFTBUS_OK);
1446
1447 SoftbusBroadcastParam params = {};
1448
1449 ret = MockBluetooth::interface->SetBroadcastingParam(advId, ¶ms);
1450 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
1451
1452 ret = MockBluetooth::interface->DeInit();
1453 EXPECT_EQ(ret, SOFTBUS_OK);
1454 }
1455
1456 /**
1457 * @tc.name: SoftbusEnableBroadcasting001
1458 * @tc.desc: Test SoftbusEnableBroadcasting when CheckAdvChanInUsed return false
1459 * @tc.type: FUNC
1460 * @tc.require: NONE
1461 */
1462 HWTEST_F(SoftbusBleGattTest, SoftbusEnableBroadcasting001, TestSize.Level1)
1463 {
1464 int32_t advId = GATT_ADV_MAX_NUM;
1465 MockBluetooth mocker;
1466 int32_t ret = MockBluetooth::interface->Init();
1467 EXPECT_EQ(ret, SOFTBUS_OK);
1468
1469 ret = MockBluetooth::interface->EnableBroadcasting(advId);
1470 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1471
1472 ret = MockBluetooth::interface->DeInit();
1473 EXPECT_EQ(ret, SOFTBUS_OK);
1474 }
1475
1476 /**
1477 * @tc.name: SoftbusEnableBroadcastingTest002
1478 * @tc.desc: Test SoftbusEnableBroadcasting when isAdvertising is false
1479 * @tc.type: FUNC
1480 * @tc.require: NONE
1481 */
1482 HWTEST_F(SoftbusBleGattTest, SoftbusEnableBroadcastingTest002, TestSize.Level1)
1483 {
1484 MockBluetooth mocker;
1485 int32_t ret = MockBluetooth::interface->Init();
1486 EXPECT_EQ(ret, SOFTBUS_OK);
1487
1488 int32_t advId = 0;
1489 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1490 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
1491 EXPECT_EQ(ret, SOFTBUS_OK);
1492
1493 ret = MockBluetooth::interface->EnableBroadcasting(advId);
1494 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
1495
1496 ret = MockBluetooth::interface->DeInit();
1497 EXPECT_EQ(ret, SOFTBUS_OK);
1498 }
1499
1500 /**
1501 * @tc.name: SoftbusDisableBroadcasting001
1502 * @tc.desc: Test SoftbusDisableBroadcasting when CheckAdvChanInUsed return false
1503 * @tc.type: FUNC
1504 * @tc.require: NONE
1505 */
1506 HWTEST_F(SoftbusBleGattTest, SoftbusDisableBroadcasting001, TestSize.Level1)
1507 {
1508 int32_t advId = GATT_ADV_MAX_NUM;
1509 MockBluetooth mocker;
1510 int32_t ret = MockBluetooth::interface->Init();
1511 EXPECT_EQ(ret, SOFTBUS_OK);
1512
1513 ret = MockBluetooth::interface->DisableBroadcasting(advId);
1514 EXPECT_EQ(ret, SOFTBUS_BC_ADAPTER_NOT_IN_USED_FAIL);
1515
1516 ret = MockBluetooth::interface->DeInit();
1517 EXPECT_EQ(ret, SOFTBUS_OK);
1518 }
1519
1520 /**
1521 * @tc.name: SoftbusDisableBroadcastingTest002
1522 * @tc.desc: Test SoftbusDisableBroadcasting when isAdvertising is false
1523 * @tc.type: FUNC
1524 * @tc.require: NONE
1525 */
1526 HWTEST_F(SoftbusBleGattTest, SoftbusDisableBroadcastingTest002, TestSize.Level1)
1527 {
1528 MockBluetooth mocker;
1529 int32_t ret = MockBluetooth::interface->Init();
1530 EXPECT_EQ(ret, SOFTBUS_OK);
1531
1532 int32_t advId = 0;
1533 EXPECT_CALL(mocker, BleGattRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
1534 ret = MockBluetooth::interface->RegisterBroadcaster(&advId, &g_softbusBcBleCbTest);
1535 EXPECT_EQ(ret, SOFTBUS_OK);
1536
1537 ret = MockBluetooth::interface->DisableBroadcasting(advId);
1538 EXPECT_EQ(ret, SOFTBUS_ALREADY_TRIGGERED);
1539
1540 ret = MockBluetooth::interface->DeInit();
1541 EXPECT_EQ(ret, SOFTBUS_OK);
1542 }
1543
1544 /**
1545 * @tc.name: SoftbusSetScanParamsTest001
1546 * @tc.desc: Test SoftbusSetScanParams when param is nullptr
1547 * @tc.type: FUNC
1548 * @tc.require: NONE
1549 */
1550 HWTEST_F(SoftbusBleGattTest, SoftbusSetScanParamsTest001, TestSize.Level1)
1551 {
1552 int32_t scannerId = 0;
1553 SoftBusBcScanFilter scanFilter = {};
1554 int32_t filterSize = 0;
1555 SoftbusSetFilterCmd cmdId = {};
1556 int32_t ret = MockBluetooth::interface->SetScanParams(scannerId, nullptr, &scanFilter, filterSize, cmdId);
1557 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1558 }
1559 } // namespace OHOS