1 /*
2 * Copyright (c) 2021-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 #include <cstdio>
16 #include <cstring>
17
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include "softbus_feature_config.h"
21 #include "softbus_conn_ble_client.h"
22 #include "conn_log.h"
23 #include "bus_center_event.h"
24 #include "softbus_conn_manager.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_adapter_ble_conflict.h"
29 #include "bus_center_info_key.h"
30 #include "softbus_conn_ble_manager.h"
31 #include "ble_protocol_interface_factory.h"
32 #include "softbus_conn_ble_client_mock.h"
33
34 using namespace testing::ext;
35 using namespace testing;
36 using namespace std;
37
38 static SoftBusGattcCallback *gattCb = nullptr;
39 namespace OHOS {
40
41 extern "C" {
ConnGattServerStartService(void)42 int32_t ConnGattServerStartService(void)
43 {
44 return SOFTBUS_OK;
45 }
46
ConnGattServerStopService(void)47 int32_t ConnGattServerStopService(void)
48 {
49 return SOFTBUS_OK;
50 }
51
ConnGattServerDisconnect(ConnBleConnection * connection)52 int32_t ConnGattServerDisconnect(ConnBleConnection *connection)
53 {
54 return SOFTBUS_OK;
55 }
56
ConnGattServerConnect(ConnBleConnection * connection)57 int32_t ConnGattServerConnect(ConnBleConnection *connection)
58 {
59 return SOFTBUS_OK;
60 }
61
ConnGattServerSend(ConnBleConnection * connection,const uint8_t * data,uint32_t dataLen,int32_t module)62 int32_t ConnGattServerSend(ConnBleConnection *connection, const uint8_t *data, uint32_t dataLen, int32_t module)
63 {
64 return SOFTBUS_OK;
65 }
66
SoftbusGattcRegisterCallback(SoftBusGattcCallback * cb,int32_t clientId)67 int32_t SoftbusGattcRegisterCallback(SoftBusGattcCallback *cb, int32_t clientId)
68 {
69 gattCb = cb;
70 return SOFTBUS_OK;
71 }
72
ConnBleInitTransModule(ConnBleTransEventListener * listener)73 int32_t ConnBleInitTransModule(ConnBleTransEventListener *listener)
74 {
75 return SOFTBUS_OK;
76 }
77
SoftBusAddBtStateListener(const SoftBusBtStateListener * listener,int32_t * listenerId)78 int32_t SoftBusAddBtStateListener(const SoftBusBtStateListener *listener, int32_t *listenerId)
79 {
80 (void)listener;
81 (void)listenerId;
82 return SOFTBUS_OK;
83 }
84
SoftbusBleConflictRegisterListener(SoftBusBleConflictListener * listener)85 void SoftbusBleConflictRegisterListener(SoftBusBleConflictListener *listener)
86 {
87 (void)listener;
88 }
89
LnnGetRemoteStrInfo(const char * networkId,InfoKey key,char * info,uint32_t len)90 int32_t LnnGetRemoteStrInfo(const char *networkId, InfoKey key, char *info, uint32_t len)
91 {
92 return SOFTBUS_OK;
93 }
94
ConnGattInitServerModule(SoftBusLooper * looper,const ConnBleServerEventListener * listener)95 int32_t ConnGattInitServerModule(SoftBusLooper *looper, const ConnBleServerEventListener *listener)
96 {
97 return SOFTBUS_OK;
98 }
99
InitSoftbusAdapterClient(void)100 int32_t InitSoftbusAdapterClient(void)
101 {
102 return SOFTBUS_OK;
103 }
ConnGetHeadSize(void)104 uint32_t ConnGetHeadSize(void)
105 {
106 return SOFTBUS_OK;
107 }
108
SoftbusBleConflictNotifyDateReceive(int32_t underlayerHandle,const uint8_t * data,uint32_t dataLen)109 void SoftbusBleConflictNotifyDateReceive(int32_t underlayerHandle, const uint8_t *data, uint32_t dataLen)
110 {
111 (void)underlayerHandle;
112 (void)data;
113 (void)dataLen;
114 }
115
SoftbusBleConflictNotifyDisconnect(const char * addr,const char * udid)116 void SoftbusBleConflictNotifyDisconnect(const char *addr, const char *udid)
117 {
118 (void)addr;
119 (void)udid;
120 }
121
LnnGetConnSubFeatureByUdidHashStr(const char * udidHashStr,uint64_t * connSubFeature)122 int32_t LnnGetConnSubFeatureByUdidHashStr(const char *udidHashStr, uint64_t *connSubFeature)
123 {
124 (void)udidHashStr;
125 (void)connSubFeature;
126 return SOFTBUS_OK;
127 }
128
LnnRegisterEventHandler(LnnEventType event,LnnEventHandler handler)129 int32_t LnnRegisterEventHandler(LnnEventType event, LnnEventHandler handler)
130 {
131 (void)event;
132 (void)handler;
133 return SOFTBUS_OK;
134 }
135
SoftbusBleConflictNotifyConnectResult(uint32_t requestId,int32_t underlayerHandle,bool status)136 void SoftbusBleConflictNotifyConnectResult(uint32_t requestId, int32_t underlayerHandle, bool status)
137 {
138 (void)requestId;
139 (void)underlayerHandle;
140 (void)status;
141 }
142
ConnBleTransConfigPostLimit(const LimitConfiguration * configuration)143 int32_t ConnBleTransConfigPostLimit(const LimitConfiguration *configuration)
144 {
145 (void)configuration;
146 return SOFTBUS_OK;
147 }
148
ConnBlePackCtlMessage(BleCtlMessageSerializationContext ctx,uint8_t ** outData,uint32_t * outDataLen)149 int64_t ConnBlePackCtlMessage(BleCtlMessageSerializationContext ctx, uint8_t **outData, uint32_t *outDataLen)
150 {
151 (void)ctx;
152 (void)outData;
153 (void)outDataLen;
154 return SOFTBUS_OK;
155 }
156
SoftbusGattcUnRegister(int32_t clientId)157 int32_t SoftbusGattcUnRegister(int32_t clientId)
158 {
159 (void)clientId;
160 return SOFTBUS_OK;
161 }
162
SoftbusGattcRegister(void)163 int32_t SoftbusGattcRegister(void)
164 {
165 int32_t id = 100;
166 return id;
167 }
168 }
169
OnConnected(uint32_t connectionId,const ConnectionInfo * info)170 void OnConnected(uint32_t connectionId, const ConnectionInfo *info)
171 {
172 (void)connectionId;
173 (void)info;
174 }
175
OnReusedConnected(uint32_t connectionId,const ConnectionInfo * info)176 void OnReusedConnected(uint32_t connectionId, const ConnectionInfo *info)
177 {
178 (void)connectionId;
179 (void)info;
180 }
181
OnDisconnected(uint32_t connectionId,const ConnectionInfo * info)182 void OnDisconnected(uint32_t connectionId, const ConnectionInfo *info)
183 {
184 (void)connectionId;
185 (void)info;
186 }
187
OnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)188 void OnDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
189 {
190 (void)connectionId;
191 (void)moduleId;
192 (void)seq;
193 (void)data;
194 (void)len;
195 }
196
197 class ClientConnectionTest : public testing::Test {
198 public:
SetUpTestCase()199 static void SetUpTestCase() {}
TearDownTestCase()200 static void TearDownTestCase() {}
201 void SetUp();
202 void TearDown();
203 };
204
SetUp()205 void ClientConnectionTest::SetUp()
206 {
207 SoftbusConfigInit();
208 ConnectCallback connectCb = {
209 .OnConnected = OnConnected,
210 .OnReusedConnected = OnReusedConnected,
211 .OnDisconnected = OnDisconnected,
212 .OnDataReceived = OnDataReceived,
213 };
214 LooperInit();
215 ConnInitBle(&connectCb);
216 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
217 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect).
218 WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
219 }
220
TearDown()221 void ClientConnectionTest::TearDown()
222 {
223 LooperDeinit();
224 }
225
226 /*
227 * @tc.name: ClientConnectionTest001
228 * @tc.desc: Test ConnectionStateCallback for disconenct.
229 * @tc.in: Test module, Test number, Test Levels.
230 * @tc.out: Zero
231 * @tc.type: FUNC
232 * @tc.require:
233 */
234 HWTEST_F(ClientConnectionTest, ConnectionStateCallback001, TestSize.Level1)
235 {
236 const char *addr = "11:22:33:44:55:66";
237 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 100, false);
238
239 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
240 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_OK));
241 int32_t ret = ConnGattClientConnect(connection);
242
243 EXPECT_EQ(SOFTBUS_OK, ret);
244 connection->fastestConnectEnable = true;
245 connection->connectionRc = 0;
246 ret = ConnBleSaveConnection(connection);
247 EXPECT_EQ(SOFTBUS_OK, ret);
248 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
249 EXPECT_CALL(bleMock, SoftbusGattcSetFastestConn).WillRepeatedly(Return(SOFTBUS_OK));
250 ret = ConnGattClientConnect(connection);
251 uint64_t delta = 500;
252 SoftBusSleepMs(BLE_FAST_CONNECT_TIMEOUT + delta); // to call timeout event
253 EXPECT_EQ(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR, ret);
254 }
255 /*
256 * @tc.name: ClientConnectionTest002
257 * @tc.desc: Test ConnectionStateCallback for disconenct.
258 * @tc.in: Test module, Test number, Test Levels.
259 * @tc.out: Zero
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(ClientConnectionTest, ConnectionStateCallback002, TestSize.Level1)
264 {
265 const char *addr = "11:22:33:44:77:99";
266 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 130, false);
267 ASSERT_NE(nullptr, connection);
268
269 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
270 EXPECT_CALL(bleMock, SoftbusGattcSetFastestConn).WillRepeatedly(Return(
271 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
272 EXPECT_CALL(bleMock, SoftbusGattcConnect).WillRepeatedly(Return(SOFTBUS_OK));
273 int32_t ret = ConnGattClientConnect(connection);
274 EXPECT_EQ(SOFTBUS_OK, ret);
275
276 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
277 ret = ConnBleSaveConnection(connection);
278 EXPECT_EQ(SOFTBUS_OK, ret);
279 gattCb->connectionStateCallback(connection->underlayerHandle, 5, SOFTBUS_OK);
280 gattCb->connectionStateCallback(0, SOFTBUS_BT_CONNECT, SOFTBUS_OK);
281
282 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect).WillRepeatedly(Return(
283 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
284 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_DISCONNECT,
285 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR);
286
287 connection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
288 ret = ConnBleSaveConnection(connection);
289 EXPECT_EQ(SOFTBUS_OK, ret);
290
291 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_DISCONNECT,
292 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR);
293 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_CONNECT,
294 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR);
295
296 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_CONNECT,
297 SOFTBUS_OK);
298 SoftBusSleepMs(1500);
299 }
300
301 /*
302 * @tc.name: ServiceCompleteCallback001
303 * @tc.desc: Test ConnectionStateCallback for connect.
304 * @tc.in: Test module, Test number, Test Levels.
305 * @tc.out: Zero
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(ClientConnectionTest, ServiceCompleteCallback001, TestSize.Level1)
310 {
311 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
312 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect).WillRepeatedly(Return(
313 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
314 const char *addr = "11:22:33:44:55:12";
315 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 100, false);
316 EXPECT_NE(nullptr, connection);
317
318 connection->fastestConnectEnable = true;
319 connection->connectionRc = 0;
320 connection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHED;
321 int32_t ret = ConnBleSaveConnection(connection);
322 EXPECT_EQ(SOFTBUS_OK, ret);
323
324 gattCb->serviceCompleteCallback(10, SOFTBUS_OK);
325 gattCb->serviceCompleteCallback(connection->underlayerHandle, SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR);
326 gattCb->serviceCompleteCallback(connection->underlayerHandle, SOFTBUS_OK);
327 connection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
328
329 const char *bleAddr = "11:22:33:44:55:33";
330 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 2, false);
331 EXPECT_NE(nullptr, connection);
332 bleConnection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
333 bleConnection->retrySearchServiceCnt = 0;
334 ret = ConnBleSaveConnection(bleConnection);
335 EXPECT_EQ(SOFTBUS_OK, ret);
336 EXPECT_CALL(bleMock, SoftbusGattcGetService)
337 .WillRepeatedly(Return(SOFTBUS_OK));
338 EXPECT_CALL(bleMock, SoftbusGattcRegisterNotification)
339 .WillRepeatedly(Return(SOFTBUS_OK));
340 gattCb->serviceCompleteCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
341
342 EXPECT_CALL(bleMock, SoftbusGattcGetService)
343 .WillRepeatedly(Return( SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_GET_SERVICE_ERR));
344 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
345 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_INTERNAL_ERR));
346 gattCb->serviceCompleteCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
347
348 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
349 .WillRepeatedly(Return(SOFTBUS_OK));
350 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
351 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_INTERNAL_ERR));
352 gattCb->serviceCompleteCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
353 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
354 .WillRepeatedly(Return(SOFTBUS_OK));
355 SoftBusSleepMs(500);
356 }
357
358 /*
359 * @tc.name: ServiceCompleteCallback002
360 * @tc.desc: Test ConnectionStateCallback for connect.
361 * @tc.in: Test module, Test number, Test Levels.
362 * @tc.out: Zero
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(ClientConnectionTest, ServiceCompleteCallback002, TestSize.Level1)
367 {
368 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
369 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect)
370 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
371 const char *bleAddr = "11:22:33:44:55:00";
372 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 3, false);
373 EXPECT_NE(nullptr, bleConnection);
374 bleConnection->retrySearchServiceCnt = 0;
375 bleConnection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
376 int32_t ret = ConnBleSaveConnection(bleConnection);
377 EXPECT_EQ(SOFTBUS_OK, ret);
378 EXPECT_CALL(bleMock, SoftbusGattcGetService)
379 .WillRepeatedly(Return(SOFTBUS_OK));
380 EXPECT_CALL(bleMock, SoftbusGattcRegisterNotification)
381 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_INTERNAL_ERR));
382 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
383 .WillOnce(Return(SOFTBUS_CONN_BLE_INTERNAL_ERR));
384 gattCb->serviceCompleteCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
385 SoftBusSleepMs(500);
386
387 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
388 .WillOnce(Return(SOFTBUS_OK));
389 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
390 .WillOnce(Return(SOFTBUS_CONN_BLE_INTERNAL_ERR));
391 bleConnection->retrySearchServiceCnt = 0;
392 bleConnection->state = BLE_CONNECTION_STATE_SERVICE_SEARCHING;
393 ret = ConnBleSaveConnection(bleConnection);
394 EXPECT_EQ(SOFTBUS_OK, ret);
395 gattCb->serviceCompleteCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
396 SoftBusSleepMs(500);
397 }
398
399 /*
400 * @tc.name: RegistNotificationCallback001
401 * @tc.desc: Test ConnectionStateCallback for connect.
402 * @tc.in: Test module, Test number, Test Levels.
403 * @tc.out: Zero
404 * @tc.type: FUNC
405 * @tc.require:
406 */
407 HWTEST_F(ClientConnectionTest, RegistNotificationCallback001, TestSize.Level1)
408 {
409 gattCb->registNotificationCallback(100, SOFTBUS_OK);
410 const char *bleAddr = "11:22:33:44:55:66";
411 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 4, false);
412 EXPECT_NE(nullptr, bleConnection);
413 bleConnection->retrySearchServiceCnt = 0;
414 bleConnection->state = BLE_CONNECTION_STATE_CONNECTED;
415 int32_t ret = ConnBleSaveConnection(bleConnection);
416 EXPECT_EQ(SOFTBUS_OK, ret);
417 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
418 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
419 .WillRepeatedly(Return(SOFTBUS_OK));
420 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
421 .WillRepeatedly(Return(SOFTBUS_OK));
422 gattCb->registNotificationCallback(bleConnection->underlayerHandle, SOFTBUS_CONN_BLE_INTERNAL_ERR);
423 SoftBusSleepMs(500);
424
425 bleConnection->retrySearchServiceCnt = 5;
426 bleConnection->state = BLE_CONNECTION_STATE_CONN_NOTIFICATING;
427 ret = ConnBleSaveConnection(bleConnection);
428 EXPECT_EQ(SOFTBUS_OK, ret);
429 gattCb->registNotificationCallback(bleConnection->underlayerHandle, SOFTBUS_CONN_BLE_INTERNAL_ERR);
430 SoftBusSleepMs(500);
431 }
432
433 /*
434 * @tc.name: RegistNotificationCallback002
435 * @tc.desc: Test ConnectionStateCallback for connect.
436 * @tc.in: Test module, Test number, Test Levels.
437 * @tc.out: Zero
438 * @tc.type: FUNC
439 * @tc.require:
440 */
441 HWTEST_F(ClientConnectionTest, RegistNotificationCallback002, TestSize.Level1)
442 {
443 const char *bleAddr = "11:22:33:44:44:99";
444 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 5, false);
445 EXPECT_NE(nullptr, bleConnection);
446 bleConnection->retrySearchServiceCnt = 0;
447 bleConnection->state = BLE_CONNECTION_STATE_CONN_NOTIFICATING;
448 int32_t ret = ConnBleSaveConnection(bleConnection);
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
451 EXPECT_CALL(bleMock, SoftbusGattcRegisterNotification)
452 .WillOnce(Return(SOFTBUS_OK));
453 gattCb->registNotificationCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
454 SoftBusSleepMs(500);
455
456 bleConnection->retrySearchServiceCnt = 0;
457 bleConnection->state = BLE_CONNECTION_STATE_CONN_NOTIFICATING;
458 ret = ConnBleSaveConnection(bleConnection);
459 EXPECT_CALL(bleMock, SoftbusGattcRegisterNotification)
460 .WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_REGISTER_NOTIFICATION_ERR));
461 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
462 .WillOnce(Return(SOFTBUS_OK));
463 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
464 .WillOnce(Return(SOFTBUS_OK));
465 gattCb->registNotificationCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
466 SoftBusSleepMs(500);
467 }
468
469 /*
470 * @tc.name: RegistNotificationCallback003
471 * @tc.desc: Test RegistNotificationCallback for connect.
472 * @tc.in: Test module, Test number, Test Levels.
473 * @tc.out: Zero
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(ClientConnectionTest, RegistNotificationCallback003, TestSize.Level1)
478 {
479 const char *bleAddr = "11:22:33:44:44:37";
480 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 16, false);
481 EXPECT_NE(nullptr, bleConnection);
482
483 bleConnection->state = BLE_CONNECTION_STATE_NET_NOTIFICATING;
484 int32_t ret = ConnBleSaveConnection(bleConnection);
485 EXPECT_EQ(SOFTBUS_OK, ret);
486 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
487 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect)
488 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
489 EXPECT_CALL(bleMock, SoftbusGattcConfigureMtuSize)
490 .WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONFIGURE_MTU_ERR));
491 gattCb->registNotificationCallback(bleConnection->underlayerHandle, SOFTBUS_OK);
492 SoftBusSleepMs(500);
493
494 const char *addr = "11:22:33:44:44:37";
495 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 17, false);
496 EXPECT_NE(nullptr, connection);
497
498 connection->state = BLE_CONNECTION_STATE_NET_NOTIFICATING;
499 ret = ConnBleSaveConnection(connection);
500 EXPECT_EQ(SOFTBUS_OK, ret);
501 EXPECT_CALL(bleMock, SoftbusGattcConfigureMtuSize)
502 .WillOnce(Return(SOFTBUS_OK));
503 gattCb->registNotificationCallback(connection->underlayerHandle, SOFTBUS_OK);
504 SoftBusSleepMs(500);
505
506 connection->state = BLE_CONNECTION_STATE_CLOSED;
507 ret = ConnBleSaveConnection(connection);
508 EXPECT_EQ(SOFTBUS_OK, ret);
509 gattCb->registNotificationCallback(connection->underlayerHandle, SOFTBUS_OK);
510 SoftBusSleepMs(500);
511 }
512
513
514 /*
515 * @tc.name: NotificationReceiveCallback001
516 * @tc.desc: Test NotificationReceiveCallback
517 * @tc.in: Test module, Test number, Test Levels.
518 * @tc.out: Zero
519 * @tc.type: FUNC
520 * @tc.require:
521 */
522 HWTEST_F(ClientConnectionTest, NotificationReceiveCallback001, TestSize.Level1)
523 {
524 const char *bleAddr = "11:00:33:44:44:99";
525 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 5, false);
526 EXPECT_NE(nullptr, bleConnection);
527
528 int32_t ret = ConnBleSaveConnection(bleConnection);
529 EXPECT_EQ(SOFTBUS_OK, ret);
530 SoftBusGattcNotify param = {
531 .dataLen = 50,
532 .charaUuid.uuidLen = strlen(SOFTBUS_SERVICE_UUID),
533 };
534 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
535 ASSERT_NE(nullptr, param.charaUuid.uuid);
536 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_SERVICE_UUID);
537 EXPECT_EQ(EOK, ret);
538
539 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m,
540 SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_REGISTER_NOTIFICATION_ERR);
541 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
542 SoftBusSleepMs(500);
543 SoftBusFree(param.charaUuid.uuid);
544 param.charaUuid.uuid = nullptr;
545
546 param.charaUuid.uuidLen = strlen(SOFTBUS_CHARA_BLECONN_UUID);
547 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
548 ASSERT_NE(nullptr, param.charaUuid.uuid);
549 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_CHARA_BLECONN_UUID);
550 EXPECT_EQ(EOK, ret);
551 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
552 EXPECT_CALL(bleMock, ConnGattTransRecv).WillOnce(Return(nullptr));
553 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
554
555 SoftBusFree(param.charaUuid.uuid);
556 param.charaUuid.uuid = nullptr;
557 param.charaUuid.uuidLen = strlen(SOFTBUS_CHARA_BLENET_UUID);
558 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
559 ASSERT_NE(nullptr, param.charaUuid.uuid);
560 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
561 EXPECT_EQ(EOK, ret);
562 SoftBusSleepMs(500);
563 EXPECT_CALL(bleMock, ConnGattTransRecv).WillOnce(Return(nullptr));
564 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
565 SoftBusSleepMs(500);
566 }
567
568 /*
569 * @tc.name: NotificationReceiveCallback002
570 * @tc.desc: Test NotificationReceiveCallback
571 * @tc.in: Test module, Test number, Test Levels.
572 * @tc.out: Zero
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(ClientConnectionTest, NotificationReceiveCallback002, TestSize.Level1)
577 {
578 const char *bleAddr = "11:22:33:44:44:99";
579 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 6, false);
580 EXPECT_NE(nullptr, bleConnection);
581
582 bleConnection->buffer.seq = 0;
583 bleConnection->buffer.total = 0;
584 int32_t ret = ConnBleSaveConnection(bleConnection);
585 EXPECT_EQ(SOFTBUS_OK, ret);
586 SoftBusGattcNotify param = {
587 .dataLen = 50,
588 .charaUuid.uuidLen = strlen(SOFTBUS_CHARA_BLECONN_UUID),
589 };
590 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
591 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_CHARA_BLECONN_UUID);
592 EXPECT_EQ(EOK, ret);
593
594 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
595 EXPECT_CALL(bleMock, ConnGattTransRecv)
596 .WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnConnModule);
597 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
598 SoftBusSleepMs(500);
599
600 EXPECT_CALL(bleMock, ConnGattTransRecv)
601 .WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnOldNearby);
602 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
603 SoftBusSleepMs(500);
604
605 EXPECT_CALL(bleMock, ConnGattTransRecv).WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnDefult);
606 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
607 SoftBusSleepMs(500);
608 }
609
610 /*
611 * @tc.name: NotificationReceiveCallback002
612 * @tc.desc: Test NotificationReceiveCallback
613 * @tc.in: Test module, Test number, Test Levels.
614 * @tc.out: Zero
615 * @tc.type: FUNC
616 * @tc.require:
617 */
618 HWTEST_F(ClientConnectionTest, NotificationReceiveCallback003, TestSize.Level1)
619 {
620 const char *bleAddr = "11:22:33:44:22:99";
621 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 7, false);
622 EXPECT_NE(nullptr, bleConnection);
623
624 bleConnection->buffer.seq = 0;
625 bleConnection->buffer.total = 0;
626 bleConnection->state = BLE_CONNECTION_STATE_CONNECTED;
627 int32_t ret = ConnBleSaveConnection(bleConnection);
628 EXPECT_EQ(SOFTBUS_OK, ret);
629 SoftBusGattcNotify param = {
630 .dataLen = 50,
631 .charaUuid.uuidLen = strlen(SOFTBUS_CHARA_BLENET_UUID),
632 };
633 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
634 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
635 EXPECT_EQ(EOK, ret);
636
637 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
638 EXPECT_CALL(bleMock, ConnGattTransRecv)
639 .WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnConnModule);
640 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
641 SoftBusSleepMs(500);
642
643 bleConnection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
644 ret = ConnBleSaveConnection(bleConnection);
645 EXPECT_EQ(SOFTBUS_OK, ret);
646 EXPECT_CALL(bleMock, ConnGattTransRecv).WillOnce(ConnectionBleClientInterfaceMock::ActionOfConnGattTransRecv);
647 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect)
648 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
649 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
650 SoftBusSleepMs(500);
651 }
652
653
654 /*
655 * @tc.name: NotificationReceiveCallback004
656 * @tc.desc: Test NotificationReceiveCallback
657 * @tc.in: Test module, Test number, Test Levels.
658 * @tc.out: Zero
659 * @tc.type: FUNC
660 * @tc.require:
661 */
662 HWTEST_F(ClientConnectionTest, NotificationReceiveCallback004, TestSize.Level1)
663 {
664 const char *bleAddr = "11:22:33:44:22:03";
665 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 8, false);
666 EXPECT_NE(nullptr, bleConnection);
667
668 bleConnection->buffer.seq = 0;
669 bleConnection->buffer.total = 0;
670 bleConnection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
671 int32_t ret = ConnBleSaveConnection(bleConnection);
672 EXPECT_EQ(SOFTBUS_OK, ret);
673 SoftBusGattcNotify param = {
674 .dataLen = 50,
675 .charaUuid.uuidLen = strlen(SOFTBUS_CHARA_BLENET_UUID),
676 };
677 param.charaUuid.uuid = (char *)SoftBusCalloc(param.charaUuid.uuidLen + 1);
678 ret = strcpy_s(param.charaUuid.uuid, param.charaUuid.uuidLen + 1, SOFTBUS_CHARA_BLENET_UUID);
679 EXPECT_EQ(EOK, ret);
680
681 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
682 EXPECT_CALL(bleMock, ConnGattTransRecv)
683 .WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnConnModule1);
684 gattCb->notificationReceiveCallback(bleConnection->underlayerHandle, ¶m, SOFTBUS_OK);
685 SoftBusSleepMs(500);
686
687 const char *addr = "11:22:33:44:22:06";
688 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 9, false);
689 EXPECT_NE(nullptr, connection);
690 connection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
691 ret = ConnBleSaveConnection(connection);
692 EXPECT_EQ(SOFTBUS_OK, ret);
693 EXPECT_CALL(bleMock, ConnGattTransRecv)
694 .WillOnce(ConnectionBleClientInterfaceMock::ConnGattTransRecvReturnConnModule);
695 gattCb->notificationReceiveCallback(connection->underlayerHandle, ¶m, SOFTBUS_OK);
696 SoftBusSleepMs(500);
697 }
698
699 /*
700 * @tc.name: ConfigureMtuSizeCallback001
701 * @tc.desc: Test ConfigureMtuSizeCallback
702 * @tc.in: Test module, Test number, Test Levels.
703 * @tc.out: Zero
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(ClientConnectionTest, ConfigureMtuSizeCallback001, TestSize.Level1)
708 {
709 gattCb->configureMtuSizeCallback(100, 20, SOFTBUS_OK);
710 SoftBusSleepMs(500);
711
712 const char *bleAddr = "11:22:33:44:22:05";
713 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 10, false);
714 EXPECT_NE(nullptr, bleConnection);
715 int32_t ret = ConnBleSaveConnection(bleConnection);
716 EXPECT_EQ(SOFTBUS_OK, ret);
717
718 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
719 EXPECT_CALL(bleMock, SoftbusBleGattcDisconnect)
720 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
721 gattCb->configureMtuSizeCallback(bleConnection->underlayerHandle, 20, SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR);
722 SoftBusSleepMs(500);
723
724 gattCb->configureMtuSizeCallback(bleConnection->underlayerHandle, 20, SOFTBUS_OK);
725 SoftBusSleepMs(500);
726 const char *addr = "11:22:33:44:22:06";
727 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 11, false);
728 EXPECT_NE(nullptr, connection);
729 connection->state = BLE_CONNECTION_STATE_MTU_SETTING;
730 ret = ConnBleSaveConnection(connection);
731 EXPECT_EQ(SOFTBUS_OK, ret);
732
733 EXPECT_CALL(bleMock, LnnGetLocalStrInfo)
734 .WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
735
736 gattCb->configureMtuSizeCallback(connection->underlayerHandle, 21, SOFTBUS_OK);
737 SoftBusSleepMs(500);
738 }
739
740 /*
741 * @tc.name: ConfigureMtuSizeCallback002
742 * @tc.desc: Test ConfigureMtuSizeCallback
743 * @tc.in: Test module, Test number, Test Levels.
744 * @tc.out: Zero
745 * @tc.type: FUNC
746 * @tc.require:
747 */
748 HWTEST_F(ClientConnectionTest, ConfigureMtuSizeCallback002, TestSize.Level1)
749 {
750 const char *addr = "11:22:33:44:22:05";
751 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 12, false);
752 EXPECT_NE(nullptr, connection);
753 connection->state = BLE_CONNECTION_STATE_MTU_SETTING;
754 int32_t ret = ConnBleSaveConnection(connection);
755 EXPECT_EQ(SOFTBUS_OK, ret);
756
757 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
758 EXPECT_CALL(bleMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_OK));
759 EXPECT_CALL(bleMock, LnnGetLocalNumInfo)
760 .WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
761 gattCb->configureMtuSizeCallback(connection->underlayerHandle, 21, SOFTBUS_OK);
762 SoftBusSleepMs(500);
763
764 const char *bleAddr = "11:22:33:44:22:56";
765 ConnBleConnection *bleConnection = ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, 13, false);
766 EXPECT_NE(nullptr, bleConnection);
767 bleConnection->state = BLE_CONNECTION_STATE_MTU_SETTING;
768 ret = ConnBleSaveConnection(bleConnection);
769 EXPECT_EQ(SOFTBUS_OK, ret);
770 EXPECT_CALL(bleMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_OK));
771 EXPECT_CALL(bleMock, LnnGetLocalNumInfo).WillOnce(Return(SOFTBUS_OK));
772 EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_OK));
773 gattCb->configureMtuSizeCallback(bleConnection->underlayerHandle, 21, SOFTBUS_OK);
774 SoftBusSleepMs(500);
775
776 const char *addrBle = "11:22:33:44:22:56";
777 ConnBleConnection *connectionBle = ConnBleCreateConnection(addrBle, BLE_GATT, CONN_SIDE_CLIENT, 14, false);
778 EXPECT_NE(nullptr, connectionBle);
779 connectionBle->state = BLE_CONNECTION_STATE_MTU_SETTING;
780 ret = ConnBleSaveConnection(connectionBle);
781 EXPECT_EQ(SOFTBUS_OK, ret);
782 EXPECT_CALL(bleMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_OK));
783 EXPECT_CALL(bleMock, LnnGetLocalNumInfo).WillOnce(Return(SOFTBUS_OK));
784 EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
785 gattCb->configureMtuSizeCallback(connectionBle->underlayerHandle, 22, SOFTBUS_OK);
786 SoftBusSleepMs(500);
787 }
788
789 /*
790 * @tc.name: ClientConnectionTest001
791 * @tc.desc: Test ConnectionStateCallback for disconenct.
792 * @tc.in: Test module, Test number, Test Levels.
793 * @tc.out: Zero
794 * @tc.type: FUNC
795 * @tc.require:
796 */
797 HWTEST_F(ClientConnectionTest, ConnectionStateCallback003, TestSize.Level1)
798 {
799 const char *addr = "12:23:33:44:55:67";
800 ConnBleConnection *connection = ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, 110, false);
801 ASSERT_NE(nullptr, connection);
802 NiceMock<ConnectionBleClientInterfaceMock> bleMock;
803 EXPECT_CALL(bleMock, SoftbusGattcSearchServices).WillRepeatedly(Return(SOFTBUS_OK));
804
805 connection->fastestConnectEnable = true;
806 connection->connectionRc = 0;
807 connection->retrySearchServiceCnt = BLE_CLIENT_MAX_RETRY_SEARCH_SERVICE_TIMES;
808 connection->state = BLE_CONNECTION_STATE_CONNECTING;
809 int32_t ret = ConnBleSaveConnection(connection);
810 EXPECT_EQ(SOFTBUS_OK, ret);
811 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_CONNECT, SOFTBUS_OK);
812
813 EXPECT_CALL(bleMock, SoftbusGattcSearchServices)
814 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_SEARCH_SERVICE_ERR));
815 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices)
816 .WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_SEARCH_SERVICE_ERR));
817 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_CONNECT, SOFTBUS_OK);
818
819 EXPECT_CALL(bleMock, SoftbusGattcRefreshServices).WillRepeatedly(Return(SOFTBUS_OK));
820 EXPECT_CALL(bleMock, SoftbusGattcSearchServices).WillRepeatedly(Return(SOFTBUS_OK));
821 gattCb->connectionStateCallback(connection->underlayerHandle, SOFTBUS_BT_CONNECT, SOFTBUS_OK);
822 SoftBusSleepMs(500);
823 }
824 }