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
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(int id, int st, SoftBusBtUuid *param);
42 testing::AssertionResult Expect(int id, int 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(int id, int st, int handle, SoftBusBtUuid *param);
52 testing::AssertionResult Expect(int id, int st, int handle, SoftBusBtUuid *param);
53 private:
54 int 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 int ActionBleGattsRegisterCallbacks(BtGattServerCallbacks *func)
80 {
81 AdapterBleGattServerTest::gattServerCallback = func;
82 return OHOS_BT_STATUS_SUCCESS;
83 }
84
85 // 回绕到注册通知中
ActionBleGattsRegister(BtUuid appUuid)86 int 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 */
114 HWTEST_F(AdapterBleGattServerTest, SoftBusRegisterGattsCallbacks, TestSize.Level3)
115 {
116 MockBluetooth mocker;
117 MockAll(mocker);
118 ASSERT_EQ(SoftBusRegisterGattsCallbacks(nullptr), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
119 << "nullptr gatts callback scenor";
120 // 清空状态，允许重入
121 SoftBusUnRegisterGattsCallbacks();
122 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
123 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
124 << "BleGattsRegisterCallbacks fail scenor";
125
126 EXPECT_CALL(mocker, BleGattsRegisterCallbacks).WillRepeatedly(ActionBleGattsRegisterCallbacks);
127 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(Return(OHOS_BT_STATUS_FAIL));
128 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_BLECONNECTION_REG_GATTS_CALLBACK_FAIL)
129 << "BleGattsRegister fail scenor";
130
131 EXPECT_CALL(mocker, BleGattsRegister).WillRepeatedly(ActionBleGattsRegister);
132 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
133 // 清空状态
134 SoftBusUnRegisterGattsCallbacks();
135 }
136
137 /**
138 * @tc.name: AdapterBleGattServerTest_SoftBusUnRegisterGattsCallbacks
139 * @tc.desc: test unregister gatt server callbacks
140 * @tc.type: FUNC
141 * @tc.require: NONE
142 */
143 HWTEST_F(AdapterBleGattServerTest, SoftBusUnRegisterGattsCallbacks, TestSize.Level3)
144 {
145 MockBluetooth mocker;
146 MockAll(mocker);
147 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
148
149 EXPECT_CALL(mocker, BleGattsUnRegister).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
150 SoftBusUnRegisterGattsCallbacks();
151
152 EXPECT_CALL(mocker, BleGattsUnRegister).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
153 SoftBusUnRegisterGattsCallbacks();
154 }
155
156 /**
157 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddService
158 * @tc.desc: test add gatt service
159 * @tc.type: FUNC
160 * @tc.require: NONE
161 */
162 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddService, TestSize.Level3)
163 {
164 MockBluetooth mocker;
165 MockAll(mocker);
166 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
167
168 // 注册service
169 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
170 SoftBusBtUuid service = {
171 .uuidLen = 0,
172 .uuid = nullptr,
173 };
174 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_ERR);
175
176 EXPECT_CALL(mocker, BleGattsAddService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
177 service.uuid = (char *)serviceUuid;
178 service.uuidLen = strlen(serviceUuid);
179 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_ERR);
180
181 EXPECT_CALL(mocker, BleGattsAddService).WillRepeatedly(Return(OHOS_BT_STATUS_SUCCESS));
182 ASSERT_EQ(SoftBusGattsAddService(service, true, 1), SOFTBUS_OK);
183 }
184
185 /**
186 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddCharacteristic
187 * @tc.desc: test add gatt characteristic
188 * @tc.type: FUNC
189 * @tc.require: NONE
190 */
191 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddCharacteristic, TestSize.Level3)
192 {
193 MockBluetooth mocker;
194 MockAll(mocker);
195 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
196
197 SoftBusBtUuid characteristic = {
198 .uuidLen = 0,
199 .uuid = nullptr,
200 };
201 int properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
202 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
203 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
204 int permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
205 ASSERT_EQ(
206 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_ERR);
207
208 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
209 characteristic.uuid = (char *)netCharacteristic;
210 characteristic.uuidLen = strlen(netCharacteristic);
211 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
212 ASSERT_EQ(
213 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_ERR);
214
215 EXPECT_CALL(mocker, BleGattsAddCharacteristic).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
216 ASSERT_EQ(
217 SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, permissions), SOFTBUS_OK);
218 }
219
220 /**
221 * @tc.name: AdapterBleGattServerTest_SoftBusGattsAddDescriptor
222 * @tc.desc: test add gatt descriptor
223 * @tc.type: FUNC
224 * @tc.require: NONE
225 */
226 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsAddDescriptor, TestSize.Level3)
227 {
228 MockBluetooth mocker;
229 MockAll(mocker);
230 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
231
232 SoftBusBtUuid desciptor = {
233 .uuidLen = 0,
234 .uuid = nullptr,
235 };
236 int permissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
237 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_ERR);
238
239 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
240 desciptor.uuid = (char *)connDesciptor;
241 desciptor.uuidLen = strlen(connDesciptor);
242
243 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
244 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_ERR);
245 EXPECT_CALL(mocker, BleGattsAddDescriptor).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
246 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, desciptor, permissions), SOFTBUS_OK);
247 }
248
249 /**
250 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStartService
251 * @tc.desc: test start gatt service
252 * @tc.type: FUNC
253 * @tc.require: NONE
254 */
255 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStartService, TestSize.Level3)
256 {
257 MockBluetooth mocker;
258 MockAll(mocker);
259 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
260
261 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
262 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_ERR);
263
264 EXPECT_CALL(mocker, BleGattsStartService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
265 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
266 }
267
268 /**
269 * @tc.name: AdapterBleGattServerTest_SoftBusGattsStopService
270 * @tc.desc: test stop gatt service
271 * @tc.type: FUNC
272 * @tc.require: NONE
273 */
274 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsStopService, TestSize.Level3)
275 {
276 MockBluetooth mocker;
277 MockAll(mocker);
278 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
279
280 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
281 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_ERR);
282
283 EXPECT_CALL(mocker, BleGattsStopService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
284 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
285 }
286
287 /**
288 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDeleteService
289 * @tc.desc: test delete gatt service
290 * @tc.type: FUNC
291 * @tc.require: NONE
292 */
293 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDeleteService, TestSize.Level3)
294 {
295 MockBluetooth mocker;
296 MockAll(mocker);
297 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
298
299 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
300 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_ERR);
301
302 EXPECT_CALL(mocker, BleGattsDeleteService).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
303 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
304 }
305
306 /**
307 * @tc.name: AdapterBleGattServerTest_SoftBusGattsDisconnect
308 * @tc.desc: test disconnect gatt connection
309 * @tc.type: FUNC
310 * @tc.require: NONE
311 */
312 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsDisconnect, TestSize.Level3)
313 {
314 MockBluetooth mocker;
315 MockAll(mocker);
316 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
317
318 int connId = 1;
319 SoftBusBtAddr addr = {
320 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
321 };
322 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
323 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_ERR);
324
325 EXPECT_CALL(mocker, BleGattsDisconnect).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
326 ASSERT_EQ(SoftBusGattsDisconnect(addr, connId), SOFTBUS_OK);
327 }
328
329 /**
330 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendResponse
331 * @tc.desc: test send gatt response
332 * @tc.type: FUNC
333 * @tc.require: NONE
334 */
335 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendResponse, TestSize.Level3)
336 {
337 MockBluetooth mocker;
338 MockAll(mocker);
339 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
340
341 SoftBusGattsResponse resp = {0};
342 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
343 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_ERR);
344
345 EXPECT_CALL(mocker, BleGattsSendResponse).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
346 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
347 }
348
349 /**
350 * @tc.name: AdapterBleGattServerTest_SoftBusGattsSendNotify
351 * @tc.desc: test send gatt notify
352 * @tc.type: FUNC
353 * @tc.require: NONE
354 */
355 HWTEST_F(AdapterBleGattServerTest, SoftBusGattsSendNotify, TestSize.Level3)
356 {
357 MockBluetooth mocker;
358 MockAll(mocker);
359 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
360
361 SoftBusGattsNotify notify = {0};
362 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_FAIL));
363 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_ERR);
364
365 EXPECT_CALL(mocker, BleGattsSendIndication).Times(1).WillOnce(Return(OHOS_BT_STATUS_SUCCESS));
366 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
367 }
368
369 /**
370 * @tc.name: AdapterBleGattServerTest_GattServerLifeCycle
371 * @tc.desc: test gatt server complete life cyclel, from a real usage perspective, important
372 * @tc.type: FUNC
373 * @tc.require: NONE
374 */
375 HWTEST_F(AdapterBleGattServerTest, GattServerLifeCycle, TestSize.Level3)
376 {
377 MockBluetooth mocker;
378 MockAll(mocker);
379 ASSERT_EQ(SoftBusRegisterGattsCallbacks(GetStubGattsCallback()), SOFTBUS_OK);
380
381 // 注册service
382 const char *serviceUuid = "11C8B310-80E4-4276-AFC0-F81590B2177F";
383 SoftBusBtUuid service = {
384 .uuidLen = strlen(serviceUuid),
385 .uuid = (char *)serviceUuid,
386 };
387 ASSERT_EQ(SoftBusGattsAddService(service, true, 8), SOFTBUS_OK);
388 BtUuid btService = {
389 .uuidLen = strlen(serviceUuid),
390 .uuid = (char *)serviceUuid,
391 };
392 gattServerCallback->serviceAddCb(
393 OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btService, MOCK_GATT_SERVICE_HANDLE);
394 ASSERT_TRUE(serviceAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, &service));
395
396 // 注册charateristic
397 const char *netCharacteristic = "00002B00-0000-1000-8000-00805F9B34FB";
398 SoftBusBtUuid characteristic = {
399 .uuidLen = strlen(netCharacteristic),
400 .uuid = (char *)netCharacteristic,
401 };
402 int properties = SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_READ | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP |
403 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_WRITE | SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_NOTIFY |
404 SOFTBUS_GATT_CHARACTER_PROPERTY_BIT_INDICATE;
405 int charaPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
406 ASSERT_EQ(SoftBusGattsAddCharacteristic(MOCK_GATT_SERVICE_HANDLE, characteristic, properties, charaPermissions),
407 SOFTBUS_OK);
408 BtUuid btCharacteristic = {
409 .uuidLen = strlen(netCharacteristic),
410 .uuid = (char *)netCharacteristic,
411 };
412 gattServerCallback->characteristicAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btCharacteristic,
413 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_CHARA_HANDLE);
414 ASSERT_TRUE(
415 characteristicAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_CHARA_HANDLE, &characteristic));
416
417 // 注册desciptor
418 const char *connDesciptor = "00002902-0000-1000-8000-00805F9B34FB";
419 int descriptorPermissions = SOFTBUS_GATT_PERMISSION_READ | SOFTBUS_GATT_PERMISSION_WRITE;
420 SoftBusBtUuid descriptor = {
421 .uuidLen = strlen(connDesciptor),
422 .uuid = (char *)connDesciptor,
423 };
424 ASSERT_EQ(SoftBusGattsAddDescriptor(MOCK_GATT_SERVICE_HANDLE, descriptor, descriptorPermissions), SOFTBUS_OK);
425 BtUuid btDescriptor = {
426 .uuidLen = strlen(connDesciptor),
427 .uuid = (char *)connDesciptor,
428 };
429 gattServerCallback->descriptorAddCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, &btDescriptor,
430 MOCK_GATT_SERVICE_HANDLE, MOCK_GATT_DESCRIPTOR_HANDLE);
431 ASSERT_TRUE(
432 descriptorAddCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK, MOCK_GATT_DESCRIPTOR_HANDLE, &descriptor));
433
434 // 启动Listen
435 ASSERT_EQ(SoftBusGattsStartService(MOCK_GATT_SERVICE_HANDLE), SOFTBUS_OK);
436 gattServerCallback->serviceStartCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
437 ASSERT_TRUE(serviceStartCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
438
439 // server建链
440 int connectionId = 1;
441 BdAddr bdAddr = {
442 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
443 };
444 gattServerCallback->connectServerCb(connectionId, MOCK_GATT_SERVER_HANDLE, &bdAddr);
445 SoftBusBtAddr addr = {
446 .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
447 };
448 ASSERT_TRUE(connectServerCtx.Expect(connectionId, &addr));
449
450 // 读写数据，及响应回复
451 const char *valueExample = "hello gatt server, this is client";
452 BtReqWriteCbPara btWriteParam = {
453 .connId = connectionId,
454 .transId = 0,
455 .bdAddr = &bdAddr,
456 .attrHandle = MOCK_GATT_CHARA_HANDLE,
457 .offset = 0,
458 .length = strlen(valueExample),
459 .needRsp = true,
460 .isPrep = false,
461 .value = (unsigned char *)valueExample,
462 };
463 gattServerCallback->requestWriteCb(btWriteParam);
464 SoftBusGattWriteRequest writeParam = {
465 .connId = connectionId,
466 .transId = 0,
467 .btAddr = &addr,
468 .attrHandle = MOCK_GATT_CHARA_HANDLE,
469 .offset = 0,
470 .length = strlen(valueExample),
471 .needRsp = true,
472 .isPrep = false,
473 .value = (unsigned char *)valueExample,
474 };
475 ASSERT_TRUE(ExpectGattWriteRequest(requestWriteCtx, writeParam));
476 SoftBusGattsResponse resp = {0};
477 ASSERT_EQ(SoftBusGattsSendResponse(&resp), SOFTBUS_OK);
478
479 BtReqReadCbPara btReadParam = {
480 .connId = connectionId,
481 .transId = 0,
482 .bdAddr = &bdAddr,
483 .attrHandle = MOCK_GATT_CHARA_HANDLE,
484 .offset = 0,
485 .isLong = false,
486 };
487 gattServerCallback->requestReadCb(btReadParam);
488 SoftBusGattReadRequest readParam = {
489 .connId = connectionId,
490 .transId = 0,
491 .btAddr = &addr,
492 .attrHandle = MOCK_GATT_CHARA_HANDLE,
493 .offset = 0,
494 .isLong = false,
495 };
496 ASSERT_TRUE(ExpectGattReadRequest(requestReadCtx, readParam));
497 SoftBusGattsNotify notify = {0};
498 ASSERT_EQ(SoftBusGattsSendNotify(¬ify), SOFTBUS_OK);
499
500 // server断链
501 ASSERT_EQ(SoftBusGattsDisconnect(addr, connectionId), SOFTBUS_OK);
502 gattServerCallback->disconnectServerCb(connectionId, MOCK_GATT_SERVER_HANDLE, &bdAddr);
503 ASSERT_TRUE(disconnectServerCtx.Expect(connectionId, &addr));
504
505 // 停止GATT service
506 ASSERT_EQ(SoftBusGattsStopService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
507 gattServerCallback->serviceStopCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
508 ASSERT_TRUE(serviceStopCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
509
510 // 删除GATT service
511 ASSERT_EQ(SoftBusGattsDeleteService(MOCK_GATT_SERVER_HANDLE), SOFTBUS_OK);
512 gattServerCallback->serviceDeleteCb(OHOS_BT_STATUS_SUCCESS, MOCK_GATT_SERVER_HANDLE, MOCK_GATT_SERVICE_HANDLE);
513 ASSERT_TRUE(serviceDeleteCtx.Expect(MOCK_GATT_SERVICE_HANDLE, SOFTBUS_OK));
514 }
515
BtUuidRecordCtx(const char * identifier)516 BtUuidRecordCtx::BtUuidRecordCtx(const char *identifier) : StRecordCtx(identifier)
517 {
518 Reset();
519 }
~BtUuidRecordCtx()520 BtUuidRecordCtx::~BtUuidRecordCtx()
521 {
522 Reset();
523 }
524
Reset()525 void BtUuidRecordCtx::Reset()
526 {
527 SoftBusFree(uuid.uuid);
528 uuid.uuid = nullptr;
529 uuid.uuidLen = 0;
530 }
531
Update(int id,int st,SoftBusBtUuid * param)532 bool BtUuidRecordCtx::Update(int id, int st, SoftBusBtUuid *param)
533 {
534 if (!StRecordCtx::Update(id, st)) {
535 return false;
536 }
537 uuid.uuid = (char *)SoftBusCalloc(param->uuidLen);
538 if (uuid.uuid == nullptr) {
539 return false;
540 }
541 if (memcpy_s(uuid.uuid, param->uuidLen, param->uuid, param->uuidLen) != EOK) {
542 return false;
543 }
544 uuid.uuidLen = param->uuidLen;
545 return true;
546 }
547
Expect(int id,int st,SoftBusBtUuid * param)548 testing::AssertionResult BtUuidRecordCtx::Expect(int id, int st, SoftBusBtUuid *param)
549 {
550 auto result = StRecordCtx::Expect(id, st);
551 if (!result) {
552 goto ClEANUP;
553 }
554 if (uuid.uuidLen != param->uuidLen || memcmp(uuid.uuid, param->uuid, uuid.uuidLen) != 0) {
555 result = testing::AssertionFailure() << identifier << " is call by unexpectedly uuid";
556 goto ClEANUP;
557 }
558 result = testing::AssertionSuccess();
559 ClEANUP:
560 Reset();
561 return result;
562 }
563
BtGattRecordCtx(const char * identifier)564 BtGattRecordCtx::BtGattRecordCtx(const char *identifier) : BtUuidRecordCtx(identifier)
565 {
566 handle = -1;
567 }
568
Update(int id,int st,int handleParam,SoftBusBtUuid * param)569 bool BtGattRecordCtx::Update(int id, int st, int handleParam, SoftBusBtUuid *param)
570 {
571 if (!BtUuidRecordCtx::Update(id, st, param)) {
572 return false;
573 }
574 this->handle = handleParam;
575 return true;
576 }
577
Expect(int id,int st,int handleParam,SoftBusBtUuid * param)578 testing::AssertionResult BtGattRecordCtx::Expect(int id, int st, int handleParam, SoftBusBtUuid *param)
579 {
580 auto result = BtUuidRecordCtx::Expect(id, st, param);
581 if (!result) {
582 goto ClEANUP;
583 }
584 if (this->handle != handleParam) {
585 result = testing::AssertionFailure() << identifier << " is call by unexpectedly state,"
586 << "want: " << handleParam << ", actual: " << this->handle;
587 goto ClEANUP;
588 }
589 result = testing::AssertionSuccess();
590 ClEANUP:
591 this->handle = -1;
592 return result;
593 }
594
595 BtGattServerCallbacks *AdapterBleGattServerTest::gattServerCallback = nullptr;
596 BtUuidRecordCtx AdapterBleGattServerTest::serviceAddCtx("ServiceAddCallback");
597 BtGattRecordCtx AdapterBleGattServerTest::characteristicAddCtx("CharacteristicAddCallback");
598 BtGattRecordCtx AdapterBleGattServerTest::descriptorAddCtx("DescriptorAddCallback");
599 StRecordCtx AdapterBleGattServerTest::serviceStartCtx("ServiceStartCallback");
600 StRecordCtx AdapterBleGattServerTest::serviceStopCtx("ServiceStopCallback");
601 StRecordCtx AdapterBleGattServerTest::serviceDeleteCtx("ServiceDeleteCallback");
602 BtAddrRecordCtx AdapterBleGattServerTest::connectServerCtx("ConnectServerCallback");
603 BtAddrRecordCtx AdapterBleGattServerTest::disconnectServerCtx("DisconnectServerCallback");
604 SoftBusGattReadRequest AdapterBleGattServerTest::requestReadCtx = {0};
605 SoftBusGattWriteRequest AdapterBleGattServerTest::requestWriteCtx = {0};
606 StRecordCtx AdapterBleGattServerTest::responseConfirmationCtx("ResponseConfirmationCallback");
607 StRecordCtx AdapterBleGattServerTest::notifySentCtx("NotifySentCallback");
608 StRecordCtx AdapterBleGattServerTest::mtuChangeCtx("MtuChangeCallback");
609
StubServiceAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle)610 static void StubServiceAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle)
611 {
612 AdapterBleGattServerTest::serviceAddCtx.Update(srvcHandle, status, uuid);
613 }
614
StubCharacteristicAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle,int characteristicHandle)615 static void StubCharacteristicAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle, int characteristicHandle)
616 {
617 AdapterBleGattServerTest::characteristicAddCtx.Update(srvcHandle, status, characteristicHandle, uuid);
618 }
619
StubDescriptorAddCallback(int status,SoftBusBtUuid * uuid,int srvcHandle,int descriptorHandle)620 static void StubDescriptorAddCallback(int status, SoftBusBtUuid *uuid, int srvcHandle, int descriptorHandle)
621 {
622 AdapterBleGattServerTest::descriptorAddCtx.Update(srvcHandle, status, descriptorHandle, uuid);
623 }
624
StubServiceStartCallback(int status,int srvcHandle)625 static void StubServiceStartCallback(int status, int srvcHandle)
626 {
627 AdapterBleGattServerTest::serviceStartCtx.Update(srvcHandle, status);
628 }
629
StubServiceStopCallback(int status,int srvcHandle)630 static void StubServiceStopCallback(int status, int srvcHandle)
631 {
632 AdapterBleGattServerTest::serviceStopCtx.Update(srvcHandle, status);
633 }
634
StubServiceDeleteCallback(int status,int srvcHandle)635 static void StubServiceDeleteCallback(int status, int srvcHandle)
636 {
637 AdapterBleGattServerTest::serviceDeleteCtx.Update(srvcHandle, status);
638 }
639
StubConnectServerCallback(int connId,const SoftBusBtAddr * btAddr)640 static void StubConnectServerCallback(int connId, const SoftBusBtAddr *btAddr)
641 {
642 AdapterBleGattServerTest::connectServerCtx.Update(connId, btAddr);
643 }
644
StubDisconnectServerCallback(int connId,const SoftBusBtAddr * btAddr)645 static void StubDisconnectServerCallback(int connId, const SoftBusBtAddr *btAddr)
646 {
647 AdapterBleGattServerTest::disconnectServerCtx.Update(connId, btAddr);
648 }
649
StubRequestReadCallback(SoftBusGattReadRequest readCbPara)650 static void StubRequestReadCallback(SoftBusGattReadRequest readCbPara)
651 {
652 AdapterBleGattServerTest::requestReadCtx = readCbPara;
653 }
654
StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)655 static void StubRequestWriteCallback(SoftBusGattWriteRequest writeCbPara)
656 {
657 AdapterBleGattServerTest::requestWriteCtx = writeCbPara;
658 }
659
StubResponseConfirmationCallback(int status,int handle)660 static void StubResponseConfirmationCallback(int status, int handle)
661 {
662 AdapterBleGattServerTest::responseConfirmationCtx.Update(handle, status);
663 }
StubNotifySentCallback(int connId,int status)664 static void StubNotifySentCallback(int connId, int status)
665 {
666 AdapterBleGattServerTest::notifySentCtx.Update(connId, status);
667 }
StubMtuChangeCallback(int connId,int mtu)668 static void StubMtuChangeCallback(int connId, int mtu)
669 {
670 AdapterBleGattServerTest::mtuChangeCtx.Update(connId, mtu);
671 }
672
GetStubGattsCallback()673 static SoftBusGattsCallback *GetStubGattsCallback()
674 {
675 static SoftBusGattsCallback callbacks = {
676 .ServiceAddCallback = StubServiceAddCallback,
677 .CharacteristicAddCallback = StubCharacteristicAddCallback,
678 .DescriptorAddCallback = StubDescriptorAddCallback,
679 .ServiceStartCallback = StubServiceStartCallback,
680 .ServiceStopCallback = StubServiceStopCallback,
681 .ServiceDeleteCallback = StubServiceDeleteCallback,
682 .ConnectServerCallback = StubConnectServerCallback,
683 .DisconnectServerCallback = StubDisconnectServerCallback,
684 .RequestReadCallback = StubRequestReadCallback,
685 .RequestWriteCallback = StubRequestWriteCallback,
686 .ResponseConfirmationCallback = StubResponseConfirmationCallback,
687 .NotifySentCallback = StubNotifySentCallback,
688 .MtuChangeCallback = StubMtuChangeCallback,
689 };
690 return &callbacks;
691 }
692
ExpectGattWriteRequest(SoftBusGattWriteRequest actual,SoftBusGattWriteRequest want)693 static testing::AssertionResult ExpectGattWriteRequest(SoftBusGattWriteRequest actual, SoftBusGattWriteRequest want)
694 {
695 if (want.connId != actual.connId ||
696 want.transId != actual.transId ||
697 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 ||
698 want.attrHandle != actual.attrHandle ||
699 want.offset != actual.offset ||
700 want.length != actual.length ||
701 !(want.needRsp ? actual.needRsp : !actual.needRsp) ||
702 !(want.isPrep ? actual.isPrep : !actual.isPrep) ||
703 memcmp(want.value, actual.value, want.length) != 0) {
704 return testing::AssertionFailure() << "SoftBusGattWriteRequest is unexpected";
705 }
706 return testing::AssertionSuccess();
707 }
708
ExpectGattReadRequest(SoftBusGattReadRequest actual,SoftBusGattReadRequest want)709 static testing::AssertionResult ExpectGattReadRequest(SoftBusGattReadRequest actual, SoftBusGattReadRequest want)
710 {
711 if (want.connId != actual.connId ||
712 want.transId != actual.transId ||
713 memcmp(want.btAddr->addr, actual.btAddr->addr, BT_ADDR_LEN) != 0 ||
714 want.attrHandle != actual.attrHandle ||
715 want.offset != actual.offset ||
716 !(want.isLong ? actual.isLong : !actual.isLong)) {
717 return testing::AssertionFailure() << "SoftBusGattReadRequest is unexpected";
718 }
719 return testing::AssertionSuccess();
720 }
721
722 } // namespace OHOS