1 /*
2 * Copyright (c) 2022 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 #include "conn_log.h"
19 #include "bluetooth_mock.h"
20 #include "c_header/ohos_bt_def.h"
21 #include "c_header/ohos_bt_gatt_server.h"
22 #include "softbus_adapter_ble_gatt_server.h"
23 #include "softbus_error_code.h"
24
25 #include "assert_helper.h"
26
27 using namespace testing::ext;
28 using ::testing::Return;
29
30 #define MOCK_GATT_SERVER_HANDLE 0
31 #define MOCK_GATT_SERVICE_HANDLE 1
32 #define MOCK_GATT_CHARA_HANDLE 2
33 #define MOCK_GATT_DESCRIPTOR_HANDLE 3
34
35 namespace OHOS {
36
37 class BtUuidRecordCtx : public StRecordCtx {
38 public:
39 explicit BtUuidRecordCtx(const char *identifier);
40 ~BtUuidRecordCtx();
41 bool Update(int32_t id, int32_t st, SoftBusBtUuid *param);
42 testing::AssertionResult Expect(int32_t id, int32_t st, SoftBusBtUuid *param);
43 private:
44 SoftBusBtUuid uuid;
45 void Reset();
46 };
47
48 class BtGattRecordCtx : public BtUuidRecordCtx {
49 public:
50 explicit BtGattRecordCtx(const char *identifier);
51 bool Update(int32_t id, int32_t st, int32_t handle, SoftBusBtUuid *param);
52 testing::AssertionResult Expect(int32_t id, int32_t st, int32_t handle, SoftBusBtUuid *param);
53 private:
54 int32_t handle;
55 };
56
57 class AdapterBleGattServerTest : public testing::Test {
58 public:
59 static BtGattServerCallbacks *gattServerCallback;
60 static BtUuidRecordCtx serviceAddCtx;
61 static BtGattRecordCtx characteristicAddCtx;
62 static BtGattRecordCtx descriptorAddCtx;
63 static StRecordCtx serviceStartCtx;
64 static StRecordCtx serviceStopCtx;
65 static StRecordCtx serviceDeleteCtx;
66 static BtAddrRecordCtx connectServerCtx;
67 static BtAddrRecordCtx disconnectServerCtx;
68 static SoftBusGattReadRequest requestReadCtx;
69 static SoftBusGattWriteRequest requestWriteCtx;
70 static StRecordCtx responseConfirmationCtx;
71 static StRecordCtx notifySentCtx;
72 static StRecordCtx mtuChangeCtx;
73 };
74
75 static SoftBusGattsCallback *GetStubGattsCallback();
76 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want);
77 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want);
78
ActionBleGattsRegisterCallbacks(BtGattServerCallbacks *func)79 int32_t ActionBleGattsRegisterCallbacks(BtGattServerCallbacks *func)
80 {
81 AdapterBleGattServerTest::gattServerCallback = func;
82 return OHOS_BT_STATUS_SUCCESS;
83 }
84
85 // 回绕到注册通知中
ActionBleGattsRegister(BtUuid appUuid)86 int32_t ActionBleGattsRegister(BtUuid appUuid)
87 {
88 AdapterBleGattServerTest::gattServerCallback->registerServerCb(0, MOCK_GATT_SERVER_HANDLE, &appUuid);
89 return OHOS_BT_STATUS_SUCCESS;
90 }
91
MockAll(MockBluetooth &mocker)92 static void MockAll(MockBluetooth &mocker)
93 {
94 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
95 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
96 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
97 EXPECT_CALL(mocker, BleGattsUnRegister).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
98 EXPECT_CALL(mocker, BleGattsAddCharacteristic).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
99 EXPECT_CALL(mocker, BleGattsAddDescriptor).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
100 EXPECT_CALL(mocker, BleGattsStartService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
101 EXPECT_CALL(mocker, BleGattsStopService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
102 EXPECT_CALL(mocker, BleGattsDeleteService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
103 EXPECT_CALL(mocker, BleGattsDisconnect).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
104 EXPECT_CALL(mocker, BleGattsSendResponse).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
105 EXPECT_CALL(mocker, BleGattsSendIndication).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
106 }
107
108 /**
109 * @tc.name: AdapterBleGattServerTest_SoftBusRegisterGattsCallbacks
110 * @tc.desc: test register gatt server callbacks
111 * @tc.type: FUNC
112 * @tc.require: NONE
113 */
HWTEST_F(AdapterBleGattServerTest, SoftBusRegisterGattsCallbacks, TestSize.Level3)114 HWTEST_F(AdapterBleGattServerTest, SoftBusRegisterGattsCallbacks, TestSize.Level3)
115 {
116 InitSoftbusAdapterServer();
117 MockBluetooth mocker;
118 MockAll(mocker);
119 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
120 SoftBusBtUuid service = {
121 .uuidLen = strlen(serviceUuid),
122 .uuid = (char *)serviceUuid,
123 };
124
125 ASSERT_EQ(SoftBusRegisterGattsCallbacks(nullptr, service),
126 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
127 << "nullptr gatts callback scenor";
128 // 清空状态，允许重入
129 SoftBusUnRegisterGattsCallbacks(service);
130 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
131 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service),
132 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
133 << "BleGattsRegisterCallbacks fail scenor";
134
135 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
136 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
137 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service),
138 SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
139 << "BleGattsRegister fail scenor";
140
141 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
142 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
143 // 清空状态
144 SoftBusUnRegisterGattsCallbacks(service);
145 }
146
147 /**
148 * @tc.name: AdapterBleGattServerTest_SoftBusUnRegisterGattsCallbacks
149 * @tc.desc: test unregister gatt server callbacks
150 * @tc.type: FUNC
151 * @tc.require: NONE
152 */
HWTEST_F(AdapterBleGattServerTest, SoftBusUnRegisterGattsCallbacks, TestSize.Level3)153 HWTEST_F(AdapterBleGattServerTest, SoftBusUnRegisterGattsCallbacks, TestSize.Level3)
154 {
155 InitSoftbusAdapterServer();
156 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
157 SoftBusBtUuid service = {
158 .uuidLen = strlen(serviceUuid),
159 .uuid = (char *)serviceUuid,
160 };
161 MockBluetooth mocker;
162 MockAll(mocker);
163 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
164 SoftBusUnRegisterGattsCallbacks(service);
165 }
166
167 /**
168 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddService
169 * @tc.desc: test add gatt service
170 * @tc.type: FUNC
171 * @tc.require: NONE
172 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddService, TestSize.Level3)173 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddService, TestSize.Level3)
174 {
175 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
176 SoftBusBtUuid service1 = {
177 .uuidLen = strlen(serviceUuid),
178 .uuid = (char *)serviceUuid,
179 };
180 MockBluetooth mocker;
181 MockAll(mocker);
182 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service1), SOFTBUS_OK);
183
184 // 注册service
185 SoftBusBtUuid service = {
186 .uuidLen = 0,
187 .uuid = nullptr,
188 };
189 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_INVALID_PARAM);
190
191 EXPECT_CALL(mocker, BleGattsAddService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
192 service.uuid = (char *)serviceUuid;
193 service.uuidLen = strlen(serviceUuid);
194 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR);
195
196 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
197 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_OK);
198 }
199
200 /**
201 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddCharacteristic
202 * @tc.desc: test add gatt characteristic
203 * @tc.type: FUNC
204 * @tc.require: NONE
205 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddCharacteristic, TestSize.Level3)206 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddCharacteristic, TestSize.Level3)
207 {
208 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
209 SoftBusBtUuid service = {
210 .uuidLen = strlen(serviceUuid),
211 .uuid = (char *)serviceUuid,
212 };
213 MockBluetooth mocker;
214 MockAll(mocker);
215 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
216
217 SoftBusBtUuid characteristic = {
218 .uuidLen = 0,
219 .uuid = nullptr,
220 };
221 int32_t properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
222 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
223 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
224 int32_t permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
225 ASSERT_EQ(
226 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
227 SOFTBUS_INVALID_PARAM);
228
229 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
230 characteristic.uuid = (char *)netCharacteristic;
231 characteristic.uuidLen = strlen(netCharacteristic);
232 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
233 ASSERT_EQ(
234 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions),
235 SOFTBUS_CONN_BLE_UNDERLAY_CHARACTERISTIC_ADD_ERR);
236
237 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
238 ASSERT_EQ(
239 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_OK);
240 }
241
242 /**
243 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddDescriptor
244 * @tc.desc: test add gatt descriptor
245 * @tc.type: FUNC
246 * @tc.require: NONE
247 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddDescriptor, TestSize.Level3)248 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddDescriptor, TestSize.Level3)
249 {
250 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
251 SoftBusBtUuid service = {
252 .uuidLen = strlen(serviceUuid),
253 .uuid = (char *)serviceUuid,
254 };
255 MockBluetooth mocker;
256 MockAll(mocker);
257 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
258
259 SoftBusBtUuid desciptor = {
260 .uuidLen = 0,
261 .uuid = nullptr,
262 };
263 int32_t permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
264 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_INVALID_PARAM);
265
266 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
267 desciptor.uuid = (char *)connDesciptor;
268 desciptor.uuidLen = strlen(connDesciptor);
269
270 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
271 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions),
272 SOFTBUS_CONN_BLE_UNDERLAY_DESCRIPTOR_ADD_ERR);
273 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
274 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_OK);
275 }
276
277 /**
278 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStartService
279 * @tc.desc: test start gatt service
280 * @tc.type: FUNC
281 * @tc.require: NONE
282 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStartService, TestSize.Level3)283 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStartService, TestSize.Level3)
284 {
285 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
286 SoftBusBtUuid service = {
287 .uuidLen = strlen(serviceUuid),
288 .uuid = (char *)serviceUuid,
289 };
290 MockBluetooth mocker;
291 MockAll(mocker);
292 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
293
294 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
295 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_START_ERR);
296
297 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
298 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
299 }
300
301 /**
302 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStopService
303 * @tc.desc: test stop gatt service
304 * @tc.type: FUNC
305 * @tc.require: NONE
306 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStopService, TestSize.Level3)307 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStopService, TestSize.Level3)
308 {
309 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
310 SoftBusBtUuid service = {
311 .uuidLen = strlen(serviceUuid),
312 .uuid = (char *)serviceUuid,
313 };
314 MockBluetooth mocker;
315 MockAll(mocker);
316 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
317
318 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
319 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_STOP_ERR);
320
321 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
322 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
323 }
324
325 /**
326 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDeleteService
327 * @tc.desc: test delete gatt service
328 * @tc.type: FUNC
329 * @tc.require: NONE
330 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDeleteService, TestSize.Level3)331 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDeleteService, TestSize.Level3)
332 {
333 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
334 SoftBusBtUuid service = {
335 .uuidLen = strlen(serviceUuid),
336 .uuid = (char *)serviceUuid,
337 };
338 MockBluetooth mocker;
339 MockAll(mocker);
340 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
341
342 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
343 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_CONN_BLE_UNDERLAY_SERVICE_DELETE_ERR);
344
345 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
346 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
347 }
348
349 /**
350 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDisconnect
351 * @tc.desc: test disconnect gatt connection
352 * @tc.type: FUNC
353 * @tc.require: NONE
354 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDisconnect, TestSize.Level3)355 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDisconnect, TestSize.Level3)
356 {
357 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
358 SoftBusBtUuid service = {
359 .uuidLen = strlen(serviceUuid),
360 .uuid = (char *)serviceUuid,
361 };
362 MockBluetooth mocker;
363 MockAll(mocker);
364 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
365
366 int32_t connId = 1;
367 SoftBusBtAddr addr = {
368 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
369 };
370 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
371 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_DISCONNECT_ERR);
372
373 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
374 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_OK);
375 }
376
377 /**
378 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendResponse
379 * @tc.desc: test send gatt response
380 * @tc.type: FUNC
381 * @tc.require: NONE
382 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendResponse, TestSize.Level3)383 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendResponse, TestSize.Level3)
384 {
385 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
386 SoftBusBtUuid service = {
387 .uuidLen = strlen(serviceUuid),
388 .uuid = (char *)serviceUuid,
389 };
390 MockBluetooth mocker;
391 MockAll(mocker);
392 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
393
394 SoftBusGattsResponse resp = {0};
395 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
396 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_RESPONSE_ERR);
397
398 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
399 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
400 }
401
402 /**
403 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendNotify
404 * @tc.desc: test send gatt notify
405 * @tc.type: FUNC
406 * @tc.require: NONE
407 */
HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendNotify, TestSize.Level3)408 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendNotify, TestSize.Level3)
409 {
410 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
411 SoftBusBtUuid service = {
412 .uuidLen = strlen(serviceUuid),
413 .uuid = (char *)serviceUuid,
414 };
415 MockBluetooth mocker;
416 MockAll(mocker);
417 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
418
419 SoftBusGattsNotify notify = {0};
420 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
421 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_CONN_BLE_UNDERLAY_SERVER_SEND_INDICATION_ERR);
422
423 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
424 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
425 }
426
427 /**
428 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
429 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
430 * @tc.type: FUNC
431 * @tc.require: NONE
432 */
HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle1, TestSize.Level3)433 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle1, TestSize.Level3)
434 {
435 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
436 SoftBusBtUuid service = {
437 .uuidLen = strlen(serviceUuid),
438 .uuid = (char *)serviceUuid,
439 };
440 MockBluetooth mocker;
441 MockAll(mocker);
442 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
443
444 ASSERT_EQ(SoftBusGattsAddService(service, true, 8), SOFTBUS_OK);
445 BtUuid btService = {
446 .uuidLen = strlen(serviceUuid),
447 .uuid = (char *)serviceUuid,
448 };
449 gattServerCallback->serviceAddCb(
450 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btService, MOCK_GATT_SERVICE_HANDLE);
451 ASSERT_TRUE(serviceAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, &service));
452
453 // 注册charateristic
454 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
455 SoftBusBtUuid characteristic = {
456 .uuidLen = strlen(netCharacteristic),
457 .uuid = (char *)netCharacteristic,
458 };
459 int32_t properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
460 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
461 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
462 int32_t charaPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
463 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, charaPermissions),
464 SOFTBUS_OK);
465 BtUuid btCharacteristic = {
466 .uuidLen = strlen(netCharacteristic),
467 .uuid = (char *)netCharacteristic,
468 };
469 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btCharacteristic,
470 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_CHARA_HANDLE);
471 ASSERT_TRUE(
472 characteristicAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_CHARA_HANDLE, &characteristic));
473 }
474
475 /**
476 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
477 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
478 * @tc.type: FUNC
479 * @tc.require: NONE
480 */
HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle2, TestSize.Level3)481 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle2, TestSize.Level3)
482 {
483 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
484 SoftBusBtUuid service = {
485 .uuidLen = strlen(serviceUuid),
486 .uuid = (char *)serviceUuid,
487 };
488 MockBluetooth mocker;
489 MockAll(mocker);
490 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
491
492 // 注册desciptor
493 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
494 int32_t descriptorPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
495 SoftBusBtUuid descriptor = {
496 .uuidLen = strlen(connDesciptor),
497 .uuid = (char *)connDesciptor,
498 };
499 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, descriptor, descriptorPermissions), SOFTBUS_OK);
500 BtUuid btDescriptor = {
501 .uuidLen = strlen(connDesciptor),
502 .uuid = (char *)connDesciptor,
503 };
504 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btDescriptor,
505 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_DESCRIPTOR_HANDLE);
506 ASSERT_TRUE(
507 descriptorAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_DESCRIPTOR_HANDLE, &descriptor));
508 // 启动Listen
509 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
510 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
511 ASSERT_TRUE(serviceStartCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
512 }
513
514 /**
515 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
516 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
517 * @tc.type: FUNC
518 * @tc.require: NONE
519 */
HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle3, TestSize.Level3)520 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle3, TestSize.Level3)
521 {
522 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
523 SoftBusBtUuid service = {
524 .uuidLen = strlen(serviceUuid),
525 .uuid = (char *)serviceUuid,
526 };
527 MockBluetooth mocker;
528 MockAll(mocker);
529 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
530 // server建链
531 BdAddr bdAddr = {
532 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
533 };
534 gattServerCallback->connectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
535 SoftBusBtAddr addr = {
536 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
537 };
538 GetStubGattsCallback()->connectServerCallback(1, &addr);
539 ASSERT_TRUE(connectServerCtx.Expect(1, &addr));
540 // 读写数据，及响应回复
541 const char *valueExample = "hello gatt server, this is client";
542 BtReqWriteCbPara btWriteParam = {
543 .connId = 1,
544 .transId = 0,
545 .bdAddr = &bdAddr,
546 .attrHandle = MOCK_GATT_CHARA_HANDLE,
547 .offset = 0,
548 .length = strlen(valueExample),
549 .needRsp = true,
550 .isPrep = false,
551 .value = (unsigned char *)valueExample,
552 };
553 gattServerCallback->requestWriteCb(btWriteParam);
554 SoftBusGattWriteRequest writeParam = {
555 .connId = 1,
556 .transId = 0,
557 .btAddr = &addr,
558 .attrHandle = MOCK_GATT_CHARA_HANDLE,
559 .offset = 0,
560 .length = strlen(valueExample),
561 .needRsp = true,
562 .isPrep = false,
563 .value = (unsigned char *)valueExample,
564 };
565 GetStubGattsCallback()->requestWriteCallback(writeParam);
566 ASSERT_TRUE(ExpectGattWriteRequest(requestWriteCtx, writeParam));
567 SoftBusGattsResponse resp = {0};
568 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
569 }
570
571 /**
572 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
573 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
574 * @tc.type: FUNC
575 * @tc.require: NONE
576 */
HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle4, TestSize.Level3)577 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle4, TestSize.Level3)
578 {
579 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
580 SoftBusBtUuid service = {
581 .uuidLen = strlen(serviceUuid),
582 .uuid = (char *)serviceUuid,
583 };
584 MockBluetooth mocker;
585 MockAll(mocker);
586 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback(), service), SOFTBUS_OK);
587 BdAddr bdAddr = {
588 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
589 };
590 SoftBusBtAddr addr = {
591 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
592 };
593 BtReqReadCbPara btReadParam = {
594 .connId = 1,
595 .transId = 0,
596 .bdAddr = &bdAddr,
597 .attrHandle = MOCK_GATT_CHARA_HANDLE,
598 .offset = 0,
599 .isLong = false,
600 };
601 gattServerCallback->requestReadCb(btReadParam);
602 SoftBusGattReadRequest readParam = {
603 .connId = 1,
604 .transId = 0,
605 .btAddr = &addr,
606 .attrHandle = MOCK_GATT_CHARA_HANDLE,
607 .offset = 0,
608 .isLong = false,
609 };
610 GetStubGattsCallback()->requestReadCallback(readParam);
611 ASSERT_TRUE(ExpectGattReadRequest(requestReadCtx, readParam));
612 SoftBusGattsNotify notify = {0};
613 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
614 // server断链
615 ASSERT_EQ(SoftBusGattsDisconnect(addr, 1), SOFTBUS_OK);
616 gattServerCallback->disconnectServerCb(1, MOCK_GATT_SERVER_HANDLE, &bdAddr);
617
618 // 停止GATT service
619 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
620 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
621 ASSERT_TRUE(serviceStopCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
622
623 // 删除GATT service
624 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
625 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
626 ASSERT_TRUE(serviceDeleteCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
627 }
628
BtUuidRecordCtx(const char *identifier)629 BtUuidRecordCtx::BtUuidRecordCtx(const char *identifier) : StRecordCtx(identifier)
630 {
631 Reset();
632 }
~BtUuidRecordCtx()633 BtUuidRecordCtx::~BtUuidRecordCtx()
634 {
635 Reset();
636 }
637
Reset()638 void BtUuidRecordCtx::Reset()
639 {
640 SoftBusFree(uuid.uuid);
641 uuid.uuid = nullptr;
642 uuid.uuidLen = 0;
643 }
644
Update(int32_t id, int32_t st, SoftBusBtUuid *param)645 bool BtUuidRecordCtx::Update(int32_t id, int32_t st, SoftBusBtUuid *param)
646 {
647 if (!StRecordCtx::Update(id, st)) {
648 return false;
649 }
650 uuid.uuid = (char *)SoftBusCalloc(param->uuidLen);
651 if (uuid.uuid == nullptr) {
652 return false;
653 }
654 if (memcpy_s(uuid.uuid, param->uuidLen, param->uuid, param->uuidLen) != EOK) {
655 return false;
656 }
657 uuid.uuidLen = param->uuidLen;
658 return true;
659 }
660
Expect(int32_t id, int32_t st, SoftBusBtUuid *param)661 testing::AssertionResult BtUuidRecordCtx::Expect(int32_t id, int32_t st, SoftBusBtUuid *param)
662 {
663 auto result = StRecordCtx::Expect(id, st);
664 if (!result) {
665 goto ClEANUP;
666 }
667 if (uuid.uuidLen != param->uuidLen || memcmp(uuid.uuid, param->uuid, uuid.uuidLen) != 0) {
668 result = testing::AssertionFailure() << identifier << " is call by unexpectedly uuid";
669 goto ClEANUP;
670 }
671 result = testing::AssertionSuccess();
672 ClEANUP:
673 Reset();
674 return result;
675 }
676
BtGattRecordCtx(const char *identifier)677 BtGattRecordCtx::BtGattRecordCtx(const char *identifier) : BtUuidRecordCtx(identifier)
678 {
679 handle = -1;
680 }
681
Update(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)682 bool BtGattRecordCtx::Update(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)
683 {
684 if (!BtUuidRecordCtx::Update(id, st, param)) {
685 return false;
686 }
687 this->handle = handleParam;
688 return true;
689 }
690
Expect(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)691 testing::AssertionResult BtGattRecordCtx::Expect(int32_t id, int32_t st, int32_t handleParam, SoftBusBtUuid *param)
692 {
693 auto result = BtUuidRecordCtx::Expect(id, st, param);
694 if (!result) {
695 goto ClEANUP;
696 }
697 if (this->handle != handleParam) {
698 result = testing::AssertionFailure() << identifier << " is call by unexpectedly state,"
699 << "want: " << handleParam << ", actual: " << this->handle;
700 goto ClEANUP;
701 }
702 result = testing::AssertionSuccess();
703 ClEANUP:
704 this->handle = -1;
705 return result;
706 }
707
708 BtGattServerCallbacks *AdapterBleGattServerTest::gattServerCallback = nullptr;
709 BtUuidRecordCtx AdapterBleGattServerTest::serviceAddCtx("ServiceAddCallback");
710 BtGattRecordCtx AdapterBleGattServerTest::characteristicAddCtx("CharacteristicAddCallback");
711 BtGattRecordCtx AdapterBleGattServerTest::descriptorAddCtx("DescriptorAddCallback");
712 StRecordCtx AdapterBleGattServerTest::serviceStartCtx("ServiceStartCallback");
713 StRecordCtx AdapterBleGattServerTest::serviceStopCtx("ServiceStopCallback");
714 StRecordCtx AdapterBleGattServerTest::serviceDeleteCtx("ServiceDeleteCallback");
715 BtAddrRecordCtx AdapterBleGattServerTest::connectServerCtx("ConnectServerCallback");
716 BtAddrRecordCtx AdapterBleGattServerTest::disconnectServerCtx("DisconnectServerCallback");
717 SoftBusGattReadRequest AdapterBleGattServerTest::requestReadCtx = {0};
718 SoftBusGattWriteRequest AdapterBleGattServerTest::requestWriteCtx = {0};
719 StRecordCtx AdapterBleGattServerTest::responseConfirmationCtx("ResponseConfirmationCallback");
720 StRecordCtx AdapterBleGattServerTest::notifySentCtx("NotifySentCallback");
721 StRecordCtx AdapterBleGattServerTest::mtuChangeCtx("MtuChangeCallback");
722
StubServiceAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle)723 static void StubServiceAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle)
724 {
725 AdapterBleGattServerTest::serviceAddCtx.Update(srvcHandle, status, uuid);
726 }
727
StubCharacteristicAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle, int32_t characteristicHandle)728 static void StubCharacteristicAddCallback(int32_t status, SoftBusBtUuid *uuid,
729 int32_t srvcHandle, int32_t characteristicHandle)
730 {
731 AdapterBleGattServerTest::characteristicAddCtx.Update(srvcHandle, status, characteristicHandle, uuid);
732 }
733
StubDescriptorAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle, int32_t descriptorHandle)734 static void StubDescriptorAddCallback(int32_t status, SoftBusBtUuid *uuid, int32_t srvcHandle, int32_t descriptorHandle)
735 {
736 AdapterBleGattServerTest::descriptorAddCtx.Update(srvcHandle, status, descriptorHandle, uuid);
737 }
738
StubServiceStartCallback(int32_t status, int32_t srvcHandle)739 static void StubServiceStartCallback(int32_t status, int32_t srvcHandle)
740 {
741 AdapterBleGattServerTest::serviceStartCtx.Update(srvcHandle, status);
742 }
743
StubServiceStopCallback(int32_t status, int32_t srvcHandle)744 static void StubServiceStopCallback(int32_t status, int32_t srvcHandle)
745 {
746 AdapterBleGattServerTest::serviceStopCtx.Update(srvcHandle, status);
747 }
748
StubServiceDeleteCallback(int32_t status, int32_t srvcHandle)749 static void StubServiceDeleteCallback(int32_t status, int32_t srvcHandle)
750 {
751 AdapterBleGattServerTest::serviceDeleteCtx.Update(srvcHandle, status);
752 }
753
StubConnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)754 static void StubConnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)
755 {
756 AdapterBleGattServerTest::connectServerCtx.Update(connId, btAddr);
757 }
758
StubDisconnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)759 static void StubDisconnectServerCallback(int32_t connId, const SoftBusBtAddr *btAddr)
760 {
761 AdapterBleGattServerTest::disconnectServerCtx.Update(connId, btAddr);
762 }
763
StubRequestReadCallback(SoftBusGattReadRequest readCbPara)764 static void StubRequestReadCallback(SoftBusGattReadRequest readCbPara)
765 {
766 AdapterBleGattServerTest::requestReadCtx = readCbPara;
767 }
768
StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)769 static void StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)
770 {
771 AdapterBleGattServerTest::requestWriteCtx = writeCbPara;
772 }
773
StubResponseConfirmationCallback(int32_t status, int32_t handle)774 static void StubResponseConfirmationCallback(int32_t status, int32_t handle)
775 {
776 AdapterBleGattServerTest::responseConfirmationCtx.Update(handle, status);
777 }
StubNotifySentCallback(int32_t connId, int32_t status)778 static void StubNotifySentCallback(int32_t connId, int32_t status)
779 {
780 AdapterBleGattServerTest::notifySentCtx.Update(connId, status);
781 }
StubMtuChangeCallback(int32_t connId, int32_t mtu)782 static void StubMtuChangeCallback(int32_t connId, int32_t mtu)
783 {
784 AdapterBleGattServerTest::mtuChangeCtx.Update(connId, mtu);
785 }
786
GetStubGattsCallback()787 static SoftBusGattsCallback *GetStubGattsCallback()
788 {
789 static SoftBusGattsCallback callbacks = {
790 .serviceAddCallback = StubServiceAddCallback,
791 .characteristicAddCallback = StubCharacteristicAddCallback,
792 .descriptorAddCallback = StubDescriptorAddCallback,
793 .serviceStartCallback = StubServiceStartCallback,
794 .serviceStopCallback = StubServiceStopCallback,
795 .serviceDeleteCallback = StubServiceDeleteCallback,
796 .connectServerCallback = StubConnectServerCallback,
797 .disconnectServerCallback = StubDisconnectServerCallback,
798 .requestReadCallback = StubRequestReadCallback,
799 .requestWriteCallback = StubRequestWriteCallback,
800 .responseConfirmationCallback = StubResponseConfirmationCallback,
801 .notifySentCallback = StubNotifySentCallback,
802 .mtuChangeCallback = StubMtuChangeCallback,
803 };
804 return &callbacks;
805 }
806
ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want)807 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want)
808 {
809 if (want.connId != actual.connId ||
810 want.transId != actual.transId ||
811 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 ||
812 want.attrHandle != actual.attrHandle ||
813 want.offset != actual.offset ||
814 want.length != actual.length ||
815 !(want.needRsp ? actual.needRsp : !actual.needRsp) ||
816 !(want.isPrep ? actual.isPrep : !actual.isPrep) ||
817 memcmp(want.value, actual.value, want.length) != 0) {
818 return testing::AssertionFailure() << "SoftBusGattWriteRequest is unexpected";
819 }
820 return testing::AssertionSuccess();
821 }
822
ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want)823 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want)
824 {
825 if (want.connId != actual.connId ||
826 want.transId != actual.transId ||
827 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 ||
828 want.attrHandle != actual.attrHandle ||
829 want.offset != actual.offset ||
830 !(want.isLong ? actual.isLong : !actual.isLong)) {
831 return testing::AssertionFailure() << "SoftBusGattReadRequest is unexpected";
832 }
833 return testing::AssertionSuccess();
834 }
835
836 } // namespace OHOS
837