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 "gtest/gtest.h"
17
18 #include "softbus_ble_utils.h"
19 #include "softbus_adapter_mem.h"
20 #include "softbus_broadcast_type.h"
21 #include "softbus_broadcast_utils.h"
22 #include "softbus_error_code.h"
23 #include <cstring>
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28
29 /**
30 * @tc.name: SoftbusBleUtilsTest_BtStatusToSoftBus
31 * @tc.desc: test bt status convert to softbus status
32 * @tc.type: FUNC
33 * @tc.require: 1
34 */
HWTEST(SoftbusBleUtilsTest, BtStatusToSoftBus, TestSize.Level3)35 HWTEST(SoftbusBleUtilsTest, BtStatusToSoftBus, TestSize.Level3)
36 {
37 int32_t status = BtStatusToSoftBus(OHOS_BT_STATUS_SUCCESS);
38 EXPECT_EQ(status, SOFTBUS_BC_STATUS_SUCCESS);
39
40 status = BtStatusToSoftBus(OHOS_BT_STATUS_FAIL);
41 EXPECT_EQ(status, SOFTBUS_BC_STATUS_FAIL);
42
43 status = BtStatusToSoftBus(OHOS_BT_STATUS_NOT_READY);
44 EXPECT_EQ(status, SOFTBUS_BC_STATUS_NOT_READY);
45
46 status = BtStatusToSoftBus(OHOS_BT_STATUS_NOMEM);
47 EXPECT_EQ(status, SOFTBUS_BC_STATUS_NOMEM);
48
49 status = BtStatusToSoftBus(OHOS_BT_STATUS_BUSY);
50 EXPECT_EQ(status, SOFTBUS_BC_STATUS_BUSY);
51
52 status = BtStatusToSoftBus(OHOS_BT_STATUS_DONE);
53 EXPECT_EQ(status, SOFTBUS_BC_STATUS_DONE);
54
55 status = BtStatusToSoftBus(OHOS_BT_STATUS_UNSUPPORTED);
56 EXPECT_EQ(status, SOFTBUS_BC_STATUS_UNSUPPORTED);
57
58 status = BtStatusToSoftBus(OHOS_BT_STATUS_PARM_INVALID);
59 EXPECT_EQ(status, SOFTBUS_BC_STATUS_PARM_INVALID);
60
61 status = BtStatusToSoftBus(OHOS_BT_STATUS_UNHANDLED);
62 EXPECT_EQ(status, SOFTBUS_BC_STATUS_UNHANDLED);
63
64 status = BtStatusToSoftBus(OHOS_BT_STATUS_AUTH_FAILURE);
65 EXPECT_EQ(status, SOFTBUS_BC_STATUS_AUTH_FAILURE);
66
67 status = BtStatusToSoftBus(OHOS_BT_STATUS_RMT_DEV_DOWN);
68 EXPECT_EQ(status, SOFTBUS_BC_STATUS_RMT_DEV_DOWN);
69
70 status = BtStatusToSoftBus(OHOS_BT_STATUS_AUTH_REJECTED);
71 EXPECT_EQ(status, SOFTBUS_BC_STATUS_AUTH_REJECTED);
72 }
73
74 /**
75 * @tc.name: SoftbusBleUtilsTest_SoftbusAdvParamToBt
76 * @tc.desc: test softbus adv param convert to bt adv params
77 * @tc.type: FUNC
78 * @tc.require: 1
79 */
HWTEST(SoftbusBleUtilsTest, SoftbusAdvParamToBt, TestSize.Level3)80 HWTEST(SoftbusBleUtilsTest, SoftbusAdvParamToBt, TestSize.Level3)
81 {
82 SoftbusBroadcastParam softbusAdvParam = {};
83 softbusAdvParam.minInterval = 1;
84 softbusAdvParam.maxInterval = 1;
85 softbusAdvParam.advType = 1;
86 softbusAdvParam.advFilterPolicy = 1;
87 softbusAdvParam.ownAddrType = 1;
88 softbusAdvParam.peerAddrType = 1;
89 softbusAdvParam.channelMap = 1;
90 softbusAdvParam.duration = 1;
91 softbusAdvParam.txPower = 1;
92
93 BleAdvParams bleAdvParams = {};
94 SoftbusAdvParamToBt(&softbusAdvParam, &bleAdvParams);
95
96 EXPECT_EQ(bleAdvParams.minInterval, softbusAdvParam.minInterval);
97 EXPECT_EQ(bleAdvParams.maxInterval, softbusAdvParam.maxInterval);
98 EXPECT_EQ(bleAdvParams.advType, softbusAdvParam.advType);
99 EXPECT_EQ(bleAdvParams.advFilterPolicy, softbusAdvParam.advFilterPolicy);
100 EXPECT_EQ(bleAdvParams.ownAddrType, softbusAdvParam.ownAddrType);
101 EXPECT_EQ(bleAdvParams.peerAddrType, softbusAdvParam.peerAddrType);
102 EXPECT_EQ(bleAdvParams.channelMap, softbusAdvParam.channelMap);
103 EXPECT_EQ(bleAdvParams.duration, softbusAdvParam.duration);
104 EXPECT_EQ(bleAdvParams.txPower, softbusAdvParam.txPower);
105 }
106
107 /**
108 * @tc.name: SoftbusBleUtilsTest_BtScanResultToSoftbus
109 * @tc.desc: test bt scan result convert to softbus scan result
110 * @tc.type: FUNC
111 * @tc.require: 1
112 */
HWTEST(SoftbusBleUtilsTest, BtScanResultToSoftbus, TestSize.Level3)113 HWTEST(SoftbusBleUtilsTest, BtScanResultToSoftbus, TestSize.Level3)
114 {
115 BtScanResultData btScanResult = {};
116 btScanResult.eventType = 1;
117 btScanResult.dataStatus = 1;
118 btScanResult.addrType = 1;
119 btScanResult.primaryPhy = 1;
120 btScanResult.secondaryPhy = 1;
121 btScanResult.advSid = 1;
122 btScanResult.txPower = 1;
123 btScanResult.rssi = 1;
124
125 SoftBusBcScanResult softbusScanResult = {};
126 BtScanResultToSoftbus(&btScanResult, &softbusScanResult);
127
128 EXPECT_EQ(softbusScanResult.eventType, btScanResult.eventType);
129 EXPECT_EQ(softbusScanResult.dataStatus, btScanResult.dataStatus);
130 EXPECT_EQ(softbusScanResult.addrType, btScanResult.addrType);
131 EXPECT_EQ(softbusScanResult.primaryPhy, btScanResult.primaryPhy);
132 EXPECT_EQ(softbusScanResult.secondaryPhy, btScanResult.secondaryPhy);
133 EXPECT_EQ(softbusScanResult.advSid, btScanResult.advSid);
134 EXPECT_EQ(softbusScanResult.txPower, btScanResult.txPower);
135 EXPECT_EQ(softbusScanResult.rssi, btScanResult.rssi);
136 }
137
138 /**
139 * @tc.name: SoftbusBleUtilsTest_SoftbusFilterToBt
140 * @tc.desc: test softbus scan filter convert to bt scan filter
141 * @tc.type: FUNC
142 * @tc.require: 1
143 */
HWTEST(SoftbusBleUtilsTest, SoftbusFilterToBt, TestSize.Level3)144 HWTEST(SoftbusBleUtilsTest, SoftbusFilterToBt, TestSize.Level3)
145 {
146 SoftBusBcScanFilter softBusBcScanFilter = {};
147 softBusBcScanFilter.address = (int8_t *)"address";
148 softBusBcScanFilter.deviceName = (int8_t *)"deviceName";
149 softBusBcScanFilter.serviceUuid = 1;
150 softBusBcScanFilter.serviceDataLength = 1;
151 softBusBcScanFilter.manufactureId = 1;
152 softBusBcScanFilter.manufactureDataLength = 1;
153
154 BleScanNativeFilter bleScanNativeFilter = {};
155 SoftbusFilterToBt(&bleScanNativeFilter, &softBusBcScanFilter, 1);
156 SoftBusFree(bleScanNativeFilter.serviceData);
157 SoftBusFree(bleScanNativeFilter.serviceDataMask);
158
159 EXPECT_EQ(bleScanNativeFilter.address, (char *)softBusBcScanFilter.address);
160 EXPECT_EQ(bleScanNativeFilter.deviceName, (char *)softBusBcScanFilter.deviceName);
161 EXPECT_EQ(bleScanNativeFilter.manufactureId, softBusBcScanFilter.manufactureId);
162 EXPECT_EQ(bleScanNativeFilter.manufactureDataLength, softBusBcScanFilter.manufactureDataLength);
163 }
164
165 /**
166 * @tc.name: SoftbusBleUtilsTest_FreeBtFilter
167 * @tc.desc: test free bt scan filter
168 * @tc.type: FUNC
169 * @tc.require: 1
170 */
HWTEST(SoftbusBleUtilsTest, FreeBtFilter, TestSize.Level3)171 HWTEST(SoftbusBleUtilsTest, FreeBtFilter, TestSize.Level3)
172 {
173 BleScanNativeFilter *bleScanNativeFilter = (BleScanNativeFilter *)calloc(1, sizeof(BleScanNativeFilter));
174 FreeBtFilter(bleScanNativeFilter, 1);
175 }
176
177 /**
178 * @tc.name: SoftbusBleUtilsTest_DumpBleScanFilter
179 * @tc.desc: test dump scan filter
180 * @tc.type: FUNC
181 * @tc.require: 1
182 */
HWTEST(SoftbusBleUtilsTest, DumpBleScanFilter, TestSize.Level3)183 HWTEST(SoftbusBleUtilsTest, DumpBleScanFilter, TestSize.Level3)
184 {
185 BleScanNativeFilter *bleScanNativeFilter = (BleScanNativeFilter *)calloc(1, sizeof(BleScanNativeFilter));
186 DumpBleScanFilter(bleScanNativeFilter, 1);
187 free(bleScanNativeFilter);
188 }
189
190 /**
191 * @tc.name: SoftbusBleUtilsTest_GetBtScanMode
192 * @tc.desc: test get bt scan mode
193 * @tc.type: FUNC
194 * @tc.require: 1
195 */
HWTEST(SoftbusBleUtilsTest, GetBtScanMode, TestSize.Level3)196 HWTEST(SoftbusBleUtilsTest, GetBtScanMode, TestSize.Level3)
197 {
198 int32_t scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P2, SOFTBUS_BC_SCAN_WINDOW_P2);
199 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_OP_P2_60_3000);
200
201 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P10, SOFTBUS_BC_SCAN_WINDOW_P10);
202 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_OP_P10_30_300);
203
204 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P25, SOFTBUS_BC_SCAN_WINDOW_P25);
205 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_OP_P25_60_240);
206
207 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P100, SOFTBUS_BC_SCAN_WINDOW_P100);
208 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_OP_P100_1000_1000);
209
210 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P2, SOFTBUS_BC_SCAN_WINDOW_P100);
211 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_LOW_POWER);
212
213 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P2_FAST, SOFTBUS_BC_SCAN_WINDOW_P2_FAST);
214 EXPECT_EQ(scanMode, OHOS_BLE_SCAN_MODE_OP_P2_30_1500);
215
216 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P2_FAST, SOFTBUS_BC_SCAN_WINDOW_P100);
217 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P2_30_1500);
218
219 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P10, SOFTBUS_BC_SCAN_WINDOW_P100);
220 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P10_30_300);
221
222 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P25, SOFTBUS_BC_SCAN_WINDOW_P100);
223 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P25_60_240);
224
225 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P50, SOFTBUS_BC_SCAN_WINDOW_P100);
226 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P50_30_60);
227
228 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P75, SOFTBUS_BC_SCAN_WINDOW_P100);
229 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P75_30_40);
230
231 scanMode = GetBtScanMode(SOFTBUS_BC_SCAN_INTERVAL_P100, SOFTBUS_BC_SCAN_WINDOW_P75);
232 EXPECT_NE(scanMode, OHOS_BLE_SCAN_MODE_OP_P75_30_40);
233 }
234
235 /**
236 * @tc.name: SoftbusBleUtilsTest_AssembleAdvData
237 * @tc.desc: test assemble ble adv data
238 * @tc.type: FUNC
239 * @tc.require: 1
240 */
HWTEST(SoftbusBleUtilsTest, AssembleAdvData, TestSize.Level3)241 HWTEST(SoftbusBleUtilsTest, AssembleAdvData, TestSize.Level3)
242 {
243 SoftbusBroadcastData *data = (SoftbusBroadcastData *)calloc(1, sizeof(SoftbusBroadcastData));
244 data->isSupportFlag = true;
245 data->flag = 1;
246 SoftbusBroadcastPayload bcData;
247 bcData.type = BROADCAST_DATA_TYPE_SERVICE;
248 bcData.id = 1;
249 uint8_t *payload = (uint8_t *)"00112233445566";
250 bcData.payloadLen = 15;
251 bcData.payload = payload;
252 data->bcData = bcData;
253 uint16_t dataLen = 0;
254 uint8_t *advData = AssembleAdvData(data, &dataLen);
255 uint16_t expectedDataLen = (data->isSupportFlag) ?
256 bcData.payloadLen + BC_HEAD_LEN : bcData.payloadLen + BC_HEAD_LEN - BC_FLAG_LEN;
257 EXPECT_EQ(dataLen, expectedDataLen);
258 EXPECT_NE(advData, nullptr);
259
260 SoftBusFree(advData);
261 free(data);
262 }
263
264 /**
265 * @tc.name: SoftbusBleUtilsTest_AssembleRspData
266 * @tc.desc: test assemble ble rsp data
267 * @tc.type: FUNC
268 * @tc.require: 1
269 */
HWTEST(SoftbusBleUtilsTest, AssembleRspData, TestSize.Level3)270 HWTEST(SoftbusBleUtilsTest, AssembleRspData, TestSize.Level3)
271 {
272 SoftbusBroadcastPayload rspData = {};
273 rspData.type = BROADCAST_DATA_TYPE_SERVICE;
274 rspData.id = 1;
275 uint8_t *payload = (uint8_t *)"00112233445566";
276 rspData.payloadLen = 15;
277 rspData.payload = payload;
278 uint16_t dataLen = 0;
279
280 uint8_t *data = AssembleRspData(&rspData, &dataLen);
281 EXPECT_NE(data, NULL);
282 uint16_t expectedDataLen = rspData.payloadLen + RSP_HEAD_LEN;
283 EXPECT_EQ(dataLen, expectedDataLen);
284 SoftBusFree(data);
285 }
286
287 /**
288 * @tc.name: SoftbusBleUtilsTest_ParseScanResult
289 * @tc.desc: test parse ble scan result as softbus scan result
290 * @tc.type: FUNC
291 * @tc.require: 1
292 */
HWTEST(SoftbusBleUtilsTest, ParseScanResult, TestSize.Level3)293 HWTEST(SoftbusBleUtilsTest, ParseScanResult, TestSize.Level3)
294 {
295 uint8_t *advData = (uint8_t *)"00112233445566";
296 uint8_t advLen = 23;
297 SoftBusBcScanResult softBusBcScanResult = {};
298 int32_t ret = ParseScanResult(advData, advLen, &softBusBcScanResult);
299 EXPECT_EQ(ret, SOFTBUS_OK);
300 SoftBusFree(softBusBcScanResult.data.bcData.payload);
301 SoftBusFree(softBusBcScanResult.data.rspData.payload);
302
303 EXPECT_EQ(softBusBcScanResult.data.isSupportFlag, false);
304 EXPECT_EQ(softBusBcScanResult.data.bcData.type, BROADCAST_DATA_TYPE_SERVICE);
305 }
306
307 } // namespace OHOS
308