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