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
31using namespace testing::ext;
32using ::testing::AtMost;
33using ::testing::Return;
34
35namespace OHOS {
36
37class ScanResultCtx : public RecordCtx {
38public:
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);
43private:
44    SoftBusBcScanResult scanResult;
45    void Reset();
46};
47
48class SoftbusBleGattTest : public testing::Test {
49public:
50    static ScanResultCtx scanResultCtx;
51
52    static StRecordCtx advEnableCtx;
53    static StRecordCtx advDisableCtx;
54    static StRecordCtx advDataCtx;
55    static StRecordCtx advUpdateCtx;
56    static int32_t btInnerAdvId;
57
58    static void SetUpTestCase(void);
59};
60
61ScanResultCtx SoftbusBleGattTest::scanResultCtx("OnReportScanDataCallback");
62
63StRecordCtx SoftbusBleGattTest::advEnableCtx("AdvEnableCallback");
64StRecordCtx SoftbusBleGattTest::advDisableCtx("AdvDisableCallback");
65StRecordCtx SoftbusBleGattTest::advDataCtx("AdvDataCallback");
66StRecordCtx SoftbusBleGattTest::advUpdateCtx("AdvUpdateCallback");
67int32_t SoftbusBleGattTest::btInnerAdvId = -1;
68
69void SoftbusBleGattTest::SetUpTestCase()
70{
71    MockBluetooth mocker;
72    SoftbusBleAdapterInit();
73    MockBluetooth::interface->Init();
74}
75
76static void StubOnScanResult(int32_t scannerId, const SoftBusBcScanResult *reportData)
77{
78    SoftbusBleGattTest::scanResultCtx.Update(scannerId, reportData);
79}
80
81static 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
92static void StubAdvEnableCallback(int32_t advId, int32_t status)
93{
94    SoftbusBleGattTest::advEnableCtx.Update(advId, status);
95}
96
97static void StubAdvDisableCallback(int32_t advId, int32_t status)
98{
99    SoftbusBleGattTest::advDisableCtx.Update(advId, status);
100}
101
102static void StubAdvUpdateCallback(int32_t advId, int32_t status)
103{
104    SoftbusBleGattTest::advUpdateCtx.Update(advId, status);
105}
106
107static void StubAdvDataCallback(int32_t advId, int32_t status)
108{
109    SoftbusBleGattTest::advDataCtx.Update(advId, status);
110}
111
112SoftbusBroadcastCallback *GetStubAdvCallback()
113{
114    static SoftbusBroadcastCallback callback = {
115        .OnStartBroadcastingCallback = StubAdvEnableCallback,
116        .OnStopBroadcastingCallback = StubAdvDisableCallback,
117        .OnUpdateBroadcastingCallback = StubAdvUpdateCallback,
118        .OnSetBroadcastingCallback = StubAdvDataCallback,
119    };
120    return &callback;
121}
122
123static testing::AssertionResult PrepareScanListener(int32_t *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
135static SoftBusBcScanFilter *CreateScanFilter()
136{
137    unsigned char serviceData[] = {0xE, 0xE, 0xF, 0xF, 0x04, 0x05};
138    int32_t 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;
156EXIT:
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 */
169HWTEST_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 */
184HWTEST_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 */
199HWTEST_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//充当参数
206static void FakeBcBleCallback(int32_t adapterBcld, int32_t status)
207{
208    (void)adapterBcld;
209    (void)status;
210}
211
212static 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 */
225HWTEST_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 */
238HWTEST_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 */
259HWTEST_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 */
279HWTEST_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 */
295HWTEST_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 */
308HWTEST_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 */
330HWTEST_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//充当参数
337static void FakeScanCallback(int32_t adapterScanld, int32_t status)
338{
339    (void)adapterScanld;
340    (void)status;
341}
342
343static void FakeReportScanDataCallback(int32_t adapterScanld, const SoftBusBcScanResult *reportData)
344{
345    (void)adapterScanld;
346    (void)reportData;
347}
348
349static void FakeScanStateChanged(int32_t resultCode, bool isStartScan)
350{
351    (void)resultCode;
352    (void)isStartScan;
353}
354
355static 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
363static 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 */
377HWTEST_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 */
390HWTEST_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 */
411HWTEST_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 */
438HWTEST_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 */
454HWTEST_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 */
467HWTEST_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 */
491HWTEST_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类型的数据填充
499const 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};
507const 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 */
515HWTEST_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 */
535HWTEST_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 */
564HWTEST_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 */
577HWTEST_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 */
595HWTEST_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 */
620HWTEST_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 */
648HWTEST_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 */
661HWTEST_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 */
680HWTEST_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 */
704HWTEST_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 */
734HWTEST_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 */
747HWTEST_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 */
772HWTEST_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 */
785HWTEST_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 */
815HWTEST_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 */
850HWTEST_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 */
871HWTEST_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 */
898HWTEST_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 */
918HWTEST_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 */
938HWTEST_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 */
957HWTEST_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 */
983HWTEST_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 */
1002HWTEST_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 */
1028HWTEST_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 */
1053HWTEST_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*/
1081HWTEST_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 */
1100HWTEST_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 */
1122HWTEST_F(SoftbusBleGattTest, RegisterScanListener, TestSize.Level3)
1123{
1124    MockBluetooth mocker;
1125    int32_t 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 */
1148HWTEST_F(SoftbusBleGattTest, UnRegisterScanListener, TestSize.Level3)
1149{
1150    MockBluetooth mocker;
1151    int32_t 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 */
1165HWTEST_F(SoftbusBleGattTest, ScanLifecycle, TestSize.Level3)
1166{
1167    MockBluetooth mocker;
1168    int32_t 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 */
1197HWTEST_F(SoftbusBleGattTest, ScanResultCb, TestSize.Level3)
1198{
1199    MockBluetooth mocker;
1200    int32_t 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 */
1253HWTEST_F(SoftbusBleGattTest, RegisterBroadcaster, TestSize.Level3)
1254{
1255    int32_t advId = -1;
1256    ASSERT_EQ(MockBluetooth::interface->RegisterBroadcaster(&advId, nullptr), SOFTBUS_INVALID_PARAM);
1257    int32_t 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
1268ScanResultCtx::ScanResultCtx(const char *identifier) : RecordCtx(identifier)
1269{
1270    Reset();
1271}
1272ScanResultCtx::~ScanResultCtx()
1273{
1274    Reset();
1275}
1276
1277void 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
1285bool ScanResultCtx::Update(int32_t 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
1307testing::AssertionResult ScanResultCtx::Expect(int32_t 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.";
1321ClEANUP:
1322    Reset();
1323    return result;
1324}
1325
1326} // namespace OHOS