1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <cstdio>
17 #include <cstring>
18 
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 
22 #include "ble_protocol_interface_factory.h"
23 #include "connection_ble_manager_mock.h"
24 #include "softbus_adapter_ble_conflict.h"
25 #include "softbus_adapter_bt_common.h"
26 #include "softbus_adapter_crypto.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_conn_ble_connection.h"
29 #include "softbus_conn_ble_manager.h"
30 #include "softbus_conn_ble_trans.h"
31 #include "softbus_conn_interface.h"
32 #include "softbus_errcode.h"
33 #include "softbus_feature_config.h"
34 #include "softbus_utils.h"
35 
36 using namespace testing::ext;
37 using namespace testing;
38 namespace OHOS {
39 
40 #define SHORT_UDID_HASH_LEN 8
41 #define MAX_SIZE            100
42 #define SLEEP_TIME_MS       1000
43 #define WAIT_UPDATE_TIME_MS 3500
44 
45 static ConnBleTransEventListener g_transEventListener = { 0 };
46 static SoftBusBtStateListener g_btListener = { 0 };
47 static SoftBusBleConflictListener g_conflictListener = { 0 };
48 static int32_t g_listenerId = 0;
49 static ConnectFuncInterface *g_bleInterface = NULL;
OnConnected(uint32_t connectionId,const ConnectionInfo * info)50 void OnConnected(uint32_t connectionId, const ConnectionInfo *info)
51 {
52     (void)connectionId;
53     (void)info;
54 }
55 
OnReusedConnected(uint32_t connectionId,const ConnectionInfo * info)56 void OnReusedConnected(uint32_t connectionId, const ConnectionInfo *info)
57 {
58     (void)connectionId;
59     (void)info;
60 }
61 
OnDisconnected(uint32_t connectionId,const ConnectionInfo * info)62 void OnDisconnected(uint32_t connectionId, const ConnectionInfo *info)
63 {
64     (void)connectionId;
65     (void)info;
66 }
67 
OnDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int32_t len)68 void OnDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
69 {
70     (void)connectionId;
71     (void)moduleId;
72     (void)seq;
73     (void)data;
74     (void)len;
75 }
76 
OnConnectSuccessed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * info)77 void OnConnectSuccessed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *info)
78 {
79     (void)requestId;
80     (void)connectionId;
81     (void)info;
82 }
83 
OnConnectFailed(uint32_t requestId,int32_t reason)84 void OnConnectFailed(uint32_t requestId, int32_t reason)
85 {
86     (void)requestId;
87     (void)reason;
88 }
89 
90 extern "C" {
ConnBleInitTransModule(ConnBleTransEventListener * listener)91 int32_t ConnBleInitTransModule(ConnBleTransEventListener *listener)
92 {
93     if (listener == NULL) {
94         return SOFTBUS_INVALID_PARAM;
95     }
96     g_transEventListener = *listener;
97     return SOFTBUS_OK;
98 }
99 
SoftBusAddBtStateListener(const SoftBusBtStateListener * listener)100 int SoftBusAddBtStateListener(const SoftBusBtStateListener *listener)
101 {
102     if (listener == NULL) {
103         return SOFTBUS_INVALID_PARAM;
104     }
105     g_btListener = *listener;
106     if (g_listenerId > MAX_SIZE) {
107         g_listenerId = 0;
108     }
109     return g_listenerId++;
110 }
111 
SoftbusBleConflictNotifyDateReceive(int32_t underlayerHandle,const uint8_t * data,uint32_t dataLen)112 void SoftbusBleConflictNotifyDateReceive(int32_t underlayerHandle, const uint8_t *data, uint32_t dataLen)
113 {
114     (void)underlayerHandle;
115     (void)data;
116     (void)dataLen;
117 }
118 
SoftbusBleConflictNotifyDisconnect(const char * addr,const char * udid)119 void SoftbusBleConflictNotifyDisconnect(const char *addr, const char *udid)
120 {
121     (void)addr;
122     (void)udid;
123 }
124 
SoftbusBleConflictNotifyConnectResult(uint32_t requestId,int32_t underlayerHandle,bool status)125 void SoftbusBleConflictNotifyConnectResult(uint32_t requestId, int32_t underlayerHandle, bool status)
126 {
127     (void)requestId;
128     (void)underlayerHandle;
129     (void)status;
130 }
131 
LegacyBleReturnConnection(ConnBleConnection ** connection)132 void LegacyBleReturnConnection(ConnBleConnection **connection)
133 {
134     (void)connection;
135 }
136 
SoftbusBleConflictRegisterListener(SoftBusBleConflictListener * listener)137 void SoftbusBleConflictRegisterListener(SoftBusBleConflictListener *listener)
138 {
139     if (listener == NULL) {
140         return;
141     }
142     g_conflictListener = *listener;
143 }
144 }
145 class ConnectionBleManagerTest : public testing::Test {
146 public:
SetUpTestCase()147     static void SetUpTestCase() {};
148     static void TearDownTestCase();
SetUp()149     void SetUp() override
150     {
151         ConnectCallback connectCb = { 0 };
152         connectCb.OnConnected = OnConnected;
153         connectCb.OnReusedConnected = OnReusedConnected;
154         connectCb.OnDisconnected = OnDisconnected;
155         connectCb.OnDataReceived = OnDataReceived;
156 
157         LooperInit();
158         SoftbusConfigInit();
159 
160         NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
161         EXPECT_CALL(bleMock, ConnGattInitClientModule).WillRepeatedly(Return(SOFTBUS_OK));
162         EXPECT_CALL(bleMock, ConnGattInitServerModule).WillRepeatedly(Return(SOFTBUS_OK));
163         g_bleInterface = ConnInitBle(&connectCb);
164         ASSERT_NE(g_bleInterface, NULL);
165     }
TearDown()166     void TearDown() override
167     {
168         LooperDeinit();
169     }
170 };
171 
TearDownTestCase()172 void ConnectionBleManagerTest::TearDownTestCase()
173 {
174     SoftBusSleepMs(SLEEP_TIME_MS);
175 }
176 /*
177  * @tc.name: TestTransListener001
178  * @tc.desc: Test TransListener.
179  * @tc.in: Test module, Test number, Test Levels.
180  * @tc.out: Zero
181  * @tc.type: FUNC
182  * @tc.require:
183  */
184 HWTEST_F(ConnectionBleManagerTest, TestTransListener001, TestSize.Level1)
185 {
186     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
187     EXPECT_CALL(bleMock, ConnGattClientDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
188     g_btListener.OnBtStateChanged(g_listenerId, SOFTBUS_BLE_STATE_TURN_OFF);
189 
190     EXPECT_CALL(bleMock, ConnGattServerStartService).WillOnce(Return(SOFTBUS_OK));
191     g_btListener.OnBtStateChanged(g_listenerId, SOFTBUS_BLE_STATE_TURN_ON);
192 
193     uint32_t connectionId = 13000;
194     uint32_t len = 100;
195     int32_t pid = 0;
196     int32_t flag = 1;
197     int32_t module = MODULE_CONNECTION;
198     int64_t seq = 1000;
199     int32_t error = SOFTBUS_INVALID_PARAM;
200     g_transEventListener.onPostBytesFinished(connectionId, len, pid, flag, module, seq, error);
201 
202     const char *addr = "22:33:44:55:66:77";
203     ConnBleConnection *connection =
204         ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, true);
205     ASSERT_NE(connection, NULL);
206     connection->underlayerHandle = 3;
207     int32_t ret = ConnBleSaveConnection(connection);
208     ASSERT_EQ(SOFTBUS_OK, ret);
209     g_transEventListener.onPostBytesFinished(connection->connectionId, len, pid, flag, module, seq, error);
210     SoftBusSleepMs(SLEEP_TIME_MS);
211 }
212 
213 /*
214  * @tc.name: TestConflictGetConnection001
215  * @tc.desc: Test ConflictGetConnection.
216  * @tc.in: Test module, Test number, Test Level
217  * @tc.out: Zero
218  * @tc.type: FUNC
219  * @tc.require:
220  */
221 HWTEST_F(ConnectionBleManagerTest, TestConflictGetConnection001, TestSize.Level1)
222 {
223     const char *addr = "11:22:33:44:55:66";
224     const char *udid = "1111222233334444";
225 
226     g_conflictListener.cancelOccupy(udid);
227     ConnBleConnection *connection =
228         ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, true);
229     ASSERT_NE(connection, NULL);
230     int32_t ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
231     ASSERT_EQ(EOK, ret);
232 
233     connection->underlayerHandle = 2;
234     ret = ConnBleSaveConnection(connection);
235     ASSERT_EQ(SOFTBUS_OK, ret);
236     ret = g_conflictListener.getConnection(udid);
237     EXPECT_EQ(2, ret);
238 
239     int32_t underlayHandle = 2;
240     uint8_t *data = (uint8_t *)malloc(sizeof(uint8_t));
241     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
242     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_OK));
243     bool res = g_conflictListener.postBytes(underlayHandle, data, sizeof(uint8_t));
244     EXPECT_EQ(true, res);
245 
246     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_INVALID_PARAM));
247     res = g_conflictListener.postBytes(underlayHandle, data, sizeof(uint8_t));
248     EXPECT_EQ(false, res);
249 
250     g_conflictListener.occupy(udid, 1000);
251     g_conflictListener.occupy(udid, 1500);
252     g_conflictListener.cancelOccupy(udid);
253     char invaildUdid[100] = { 0 };
254     (void)memset_s(invaildUdid, 100, '1', 100);
255     g_conflictListener.occupy(invaildUdid, 2000);
256 }
257 
258 /*
259  * @tc.name: TestConflictDisconnect001
260  * @tc.desc: Test ConflictDisconnect.
261  * @tc.in: Test module, Test number, Test Levels.
262  * @tc.out: Zero
263  * @tc.type: FUNC
264  * @tc.require:
265  */
266 HWTEST_F(ConnectionBleManagerTest, TestConflictDisconnect001, TestSize.Level1)
267 {
268     const char *addr = "11:22:33:44:55:66";
269     const char *udid = "1111222233334444";
270     ConnBleConnection *connection =
271         ConnBleCreateConnection(addr, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, true);
272     ASSERT_NE(connection, NULL);
273     int32_t ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
274     ASSERT_EQ(EOK, ret);
275 
276     connection->underlayerHandle = 1;
277     connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
278     ret = ConnBleSaveConnection(connection);
279     EXPECT_EQ(SOFTBUS_OK, ret);
280     uint32_t requestId = 1;
281     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
282     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillOnce(Return(10));
283     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_OK));
284     ret = g_conflictListener.reuseConnection(addr, udid, requestId);
285     EXPECT_EQ(1, ret);
286     const char *invaildAddr = "11:22:33:44:55:66:77:88:99";
287 
288     ret = g_conflictListener.reuseConnection(invaildAddr, udid, requestId);
289     EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
290 
291     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillOnce(Return(10));
292     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_INVALID_PARAM));
293     ret = g_conflictListener.reuseConnection(addr, udid, requestId);
294     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
295     EXPECT_CALL(bleMock, ConnGattClientDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
296     g_conflictListener.disconnect(1, true);
297 
298     const char *bleAddr = "00:22:33:44:55:66";
299     const char *bleUdid = "1100222233334444";
300     ConnBleConnection *bleConnection =
301         ConnBleCreateConnection(bleAddr, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, true);
302     ASSERT_NE(NULL, bleConnection);
303     ret = strcpy_s(bleConnection->udid, UDID_BUF_LEN, bleUdid);
304     ASSERT_EQ(EOK, ret);
305     bleConnection->underlayerHandle = 10;
306     ret = ConnBleSaveConnection(bleConnection);
307     ASSERT_EQ(SOFTBUS_OK, ret);
308     EXPECT_CALL(bleMock, ConnGattClientDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
309     g_conflictListener.disconnect(10, false);
310 }
311 
312 /*
313  * @tc.name: TestBleInterface001
314  * @tc.desc: Test BleInterface.
315  * @tc.in: Test module, Test number, Test Levels.
316  * @tc.out: Zero
317  * @tc.type: FUNC
318  * @tc.require:
319  */
320 HWTEST_F(ConnectionBleManagerTest, TestBleInterface001, TestSize.Level1)
321 {
322     const char *deviceId = "1234567";
323     const char *bleMac = "11:22:33:44:33:00";
324     const char *udid = "1119222233334440";
325     ConnectOption option = {
326         .type = CONNECT_BLE,
327         .bleOption.bleMac = "",
328         .bleOption.deviceIdHash = "",
329         .bleOption.protocol = BLE_GATT,
330         .bleOption.psm = 5,
331         .bleOption.challengeCode = 0,
332     };
333     int32_t ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, bleMac);
334     ASSERT_EQ(EOK, ret);
335     ret = memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, deviceId, UDID_HASH_LEN);
336     ASSERT_EQ(EOK, ret);
337     uint32_t requestId = 10;
338     ConnectResult result = {
339         .OnConnectSuccessed = OnConnectSuccessed,
340         .OnConnectFailed = OnConnectFailed,
341     };
342     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
343     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
344     g_bleInterface->ConnectDevice(&option, requestId, &result);
345 
346     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillRepeatedly(Return(SOFTBUS_OK));
347     uint32_t connectionId = 131001;
348     uint8_t *data = (uint8_t *)malloc(sizeof(uint8_t));
349     uint32_t dataLen = sizeof(uint8_t);
350     int32_t pid = 0;
351     int32_t flag = 2;
352     int32_t module = MODULE_CONNECTION;
353     int64_t seq = 100;
354     ret = g_bleInterface->PostBytes(connectionId, data, dataLen, pid, flag, module, seq);
355     EXPECT_EQ(SOFTBUS_OK, ret);
356 
357     ConnBleConnection *connection =
358         ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
359     ASSERT_NE(connection, NULL);
360     ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
361     ASSERT_EQ(EOK, ret);
362     connection->underlayerHandle = 2;
363     ret = ConnBleSaveConnection(connection);
364     EXPECT_EQ(SOFTBUS_OK, ret);
365     ret = g_bleInterface->DisconnectDevice(connection->connectionId);
366     EXPECT_EQ(SOFTBUS_OK, ret);
367     SoftBusSleepMs(SLEEP_TIME_MS);
368 }
369 
370 /*
371  * @tc.name: TestBleInterface002
372  * @tc.desc: Test BleInterface.
373  * @tc.in: Test module, Test number, Test Levels.
374  * @tc.out: Zero
375  * @tc.type: FUNC
376  * @tc.require:
377  */
378 HWTEST_F(ConnectionBleManagerTest, TestBleInterface002, TestSize.Level1)
379 {
380     const char *bleMac = "44:11:33:44:33:00";
381     const char *udid = "1119222233334419";
382 
383     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
384     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
385     ConnBleConnection *connection =
386         ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
387     ASSERT_NE(connection, NULL);
388     int32_t ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
389 
390     ASSERT_EQ(EOK, ret);
391     connection->underlayerHandle = 10;
392     ret = ConnBleSaveConnection(connection);
393     EXPECT_EQ(SOFTBUS_OK, ret);
394 
395     ConnectOption option = {
396         .type = CONNECT_BLE,
397         .bleOption.bleMac = "",
398         .bleOption.deviceIdHash = "",
399         .bleOption.protocol = BLE_GATT,
400         .bleOption.psm = 5,
401         .bleOption.challengeCode = 0,
402     };
403     ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, bleMac);
404     ASSERT_EQ(EOK, ret);
405     EXPECT_CALL(bleMock, ConnGattClientDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
406     ret = g_bleInterface->DisconnectDeviceNow(&option);
407     EXPECT_EQ(SOFTBUS_OK, ret);
408 
409     ConnBleConnection *serverConnection =
410         ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_SERVER, INVALID_UNDERLAY_HANDLE, false);
411     ASSERT_NE(serverConnection, NULL);
412     serverConnection->underlayerHandle = 50;
413     ret = ConnBleSaveConnection(serverConnection);
414     EXPECT_EQ(SOFTBUS_OK, ret);
415     EXPECT_CALL(bleMock, ConnGattServerDisconnect).WillRepeatedly(Return(SOFTBUS_OK));
416     ret = g_bleInterface->DisconnectDeviceNow(&option);
417     EXPECT_EQ(SOFTBUS_OK, ret);
418     SoftBusSleepMs(SLEEP_TIME_MS);
419 }
420 
421 /*
422  * @tc.name: TestBleInterface003
423  * @tc.desc: Test BleInterface.
424  * @tc.in: Test module, Test number, Test Levels.
425  * @tc.out: Zero
426  * @tc.type: FUNC
427  * @tc.require:
428  */
429 HWTEST_F(ConnectionBleManagerTest, TestBleInterface003, TestSize.Level1)
430 {
431     const char *bleMac = "77:22:33:44:33:00";
432     const char *udid = "1254222233334419";
433     const char *invaildMac = "77:22:33:44:33:00999";
434     const char *networkId = "testnetworkid123";
435     ConnBleConnection *connection =
436         ConnBleCreateConnection(invaildMac, BLE_COC, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
437     EXPECT_EQ(connection, NULL);
438     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
439     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
440     ConnBleConnection *bleConnection =
441         ConnBleCreateConnection(bleMac, BLE_COC, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
442     ASSERT_NE(bleConnection, NULL);
443     bleConnection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
444     bleConnection->featureBitSet = false;
445     bleConnection->psm = 10;
446     int32_t ret = strcpy_s(bleConnection->udid, UDID_BUF_LEN, udid);
447     EXPECT_EQ(ret, EOK);
448     ret = strncpy_s(bleConnection->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId));
449     EXPECT_EQ(ret, EOK);
450     ret = ConnBleSaveConnection(bleConnection);
451     EXPECT_EQ(SOFTBUS_OK, ret);
452     EXPECT_CALL(bleMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
453     ConnectionInfo info = { 0 };
454     ret = g_bleInterface->GetConnectionInfo(bleConnection->connectionId, &info);
455     EXPECT_EQ(SOFTBUS_OK, ret);
456 
457     ConnBleConnection *invalidConnection =
458         ConnBleCreateConnection(bleMac, BLE_COC, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
459     ASSERT_NE(invalidConnection, NULL);
460     invalidConnection->state = BLE_CONNECTION_STATE_EXCHANGING_BASIC_INFO;
461     invalidConnection->featureBitSet = true;
462     invalidConnection->psm = 10;
463     const char *invaildUdid = "";
464     ret = strcpy_s(invalidConnection->udid, UDID_BUF_LEN, invaildUdid);
465     EXPECT_EQ(ret, EOK);
466     ret = strncpy_s(invalidConnection->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId));
467     EXPECT_EQ(ret, EOK);
468     ret = ConnBleSaveConnection(invalidConnection);
469     EXPECT_EQ(SOFTBUS_OK, ret);
470     ret = g_bleInterface->GetConnectionInfo(invalidConnection->connectionId, &info);
471     EXPECT_EQ(SOFTBUS_OK, ret);
472 
473     invalidConnection->featureBitSet = false;
474     invalidConnection->protocol = BLE_GATT;
475     ret = ConnBleSaveConnection(invalidConnection);
476     EXPECT_EQ(SOFTBUS_OK, ret);
477 
478     ret = g_bleInterface->GetConnectionInfo(invalidConnection->connectionId, &info);
479     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
480 }
481 
482 /*
483  * @tc.name: TestBleInterface004
484  * @tc.desc: Test BleInterface.
485  * @tc.in: Test module, Test number, Test Levels.
486  * @tc.out: Zero
487  * @tc.type: FUNC
488  * @tc.require:
489  */
490 HWTEST_F(ConnectionBleManagerTest, TestBleInterface004, TestSize.Level1)
491 {
492     LocalListenerInfo info = {};
493     int32_t ret = g_bleInterface->StartLocalListening(&info);
494     EXPECT_EQ(SOFTBUS_OK, ret);
495 
496     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
497     EXPECT_CALL(bleMock, ConnGattServerStopService).WillOnce(Return(SOFTBUS_OK));
498     ret = g_bleInterface->StopLocalListening(&info);
499     EXPECT_EQ(SOFTBUS_OK, ret);
500 
501     ret = g_bleInterface->StopLocalListening(&info);
502     EXPECT_EQ(SOFTBUS_OK, ret);
503 
504     EXPECT_CALL(bleMock, ConnGattServerStartService)
505         .WillOnce(Return(SOFTBUS_CONN_BLE_UNDERLAY_SERVER_ADD_SERVICE_ERR));
506     ret = g_bleInterface->StartLocalListening(&info);
507     EXPECT_EQ(SOFTBUS_OK, ret);
508 }
509 
510 /*
511  * @tc.name: TestBleInterface005
512  * @tc.desc: Test BleInterface.
513  * @tc.in: Test module, Test number, Test Levels.
514  * @tc.out: Zero
515  * @tc.type: FUNC
516  * @tc.require:
517  */
518 HWTEST_F(ConnectionBleManagerTest, TestBleInterface005, TestSize.Level1)
519 {
520     ConnectOption option = {};
521     option.type = CONNECT_BLE;
522     const char *udid = "1234";
523 
524     int32_t ret = memcpy_s(option.bleOption.deviceIdHash, sizeof(udid), udid, sizeof(udid));
525     EXPECT_EQ(ret, EOK);
526     option.bleOption.protocol = BLE_GATT;
527     char hashStr[HEXIFY_LEN(SHORT_UDID_HASH_LEN)] = { 0 };
528     ret = ConvertBytesToHexString(
529         hashStr, HEXIFY_LEN(SHORT_UDID_HASH_LEN), (unsigned char *)option.bleOption.deviceIdHash, SHORT_UDID_HASH_LEN);
530     EXPECT_EQ(ret, SOFTBUS_OK);
531 
532     const char *bleMac = "77:02:33:44:33:00";
533     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
534     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
535     ConnBleConnection *bleConnection =
536         ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
537     ASSERT_NE(bleConnection, NULL);
538 
539     ret = memcpy_s(bleConnection->udid, UDID_HASH_LEN, hashStr, UDID_HASH_LEN);
540     EXPECT_EQ(ret, EOK);
541     bleConnection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
542     ret = ConnBleSaveConnection(bleConnection);
543     EXPECT_EQ(ret, EOK);
544 
545     EXPECT_CALL(bleMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
546     bool res = g_bleInterface->CheckActiveConnection(&option, false);
547     EXPECT_EQ(res, true);
548 
549     UpdateOption options = {
550         .type = CONNECT_BLE,
551         .bleOption = {
552             .priority = CONN_BLE_PRIORITY_BALANCED,
553         }
554     };
555     EXPECT_CALL(bleMock, ConnGattClientUpdatePriority).WillRepeatedly(Return(SOFTBUS_OK));
556     ret = g_bleInterface->UpdateConnection(bleConnection->connectionId, &options);
557     EXPECT_EQ(ret, SOFTBUS_OK);
558     bleConnection->side = CONN_SIDE_SERVER;
559     ret = ConnBleSaveConnection(bleConnection);
560     EXPECT_EQ(ret, EOK);
561     ret = g_bleInterface->UpdateConnection(bleConnection->connectionId, &options);
562     EXPECT_EQ(ret, SOFTBUS_FUNC_NOT_SUPPORT);
563 }
564 
565 /*
566  * @tc.name: NotifyReusedConnected001
567  * @tc.desc: Test NotifyReusedConnected.
568  * @tc.in: Test module, Test number, Test Levels.
569  * @tc.out: Zero
570  * @tc.type: FUNC
571  * @tc.require:
572  */
573 HWTEST_F(ConnectionBleManagerTest, NotifyReusedConnected001, TestSize.Level1)
574 {
575     const char *bleMac = "21:12:33:44:33:00";
576     const char *udid = "dcba";
577     const char *networkId = "testnetworkid123";
578     ConnBleConnection *bleConnection =
579         ConnBleCreateConnection(bleMac, BLE_GATT, CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, false);
580     ASSERT_NE(bleConnection, NULL);
581     int32_t ret = memcpy_s(bleConnection->udid, UDID_HASH_LEN, udid, UDID_HASH_LEN);
582     EXPECT_EQ(ret, EOK);
583 
584     bleConnection->featureBitSet = true;
585     bleConnection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
586     bleConnection->psm = 101;
587 
588     ret = ConnBleSaveConnection(bleConnection);
589     EXPECT_EQ(ret, EOK);
590     uint16_t challengeCode = 0x12;
591     NotifyReusedConnected(bleConnection->connectionId, challengeCode);
592     ret = strcpy_s(bleConnection->networkId, NETWORK_ID_BUF_LEN, networkId);
593     EXPECT_EQ(ret, EOK);
594     ConnBleRemoveConnection(bleConnection);
595     ConnBleRemoveConnection(bleConnection);
596 }
597 
598 /*
599  * @tc.name: OnBtStateChanged001
600  * @tc.desc: Test OnBtStateChanged.
601  * @tc.in: Test module, Test number, Test Levels.
602  * @tc.out: Zero
603  * @tc.type: FUNC
604  * @tc.require:
605  */
606 HWTEST_F(ConnectionBleManagerTest, OnBtStateChanged001, TestSize.Level1)
607 {
608     const char *deviceId = "1234567";
609     const char *bleMac = "11:22:33:44:33:00";
610     ConnectOption option = {
611         .type = CONNECT_BLE,
612         .bleOption.bleMac = "",
613         .bleOption.deviceIdHash = "",
614         .bleOption.protocol = BLE_GATT,
615         .bleOption.psm = 5,
616         .bleOption.challengeCode = 0,
617     };
618     int32_t ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, bleMac);
619     ASSERT_EQ(EOK, ret);
620     ret = memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, deviceId, UDID_HASH_LEN);
621     ASSERT_EQ(EOK, ret);
622     uint32_t requestId = 10;
623     ConnectResult result = {
624         .OnConnectSuccessed = OnConnectSuccessed,
625         .OnConnectFailed = OnConnectFailed,
626     };
627     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
628     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
629     ret = g_bleInterface->ConnectDevice(&option, requestId, &result);
630     EXPECT_EQ(ret, SOFTBUS_OK);
631     g_btListener.OnBtStateChanged(g_listenerId, SOFTBUS_BLE_STATE_TURN_OFF);
632     SoftBusSleepMs(SLEEP_TIME_MS);
633 }
634 
635 /*
636  * @tc.name: ConnectDevice001
637  * @tc.desc: Test ConnectDevice.
638  * @tc.in: Test module, Test number, Test Levels.
639  * @tc.out: Zero
640  * @tc.type: FUNC
641  * @tc.require:
642  */
643 HWTEST_F(ConnectionBleManagerTest, ConnectDevice001, TestSize.Level1)
644 {
645     const char *deviceId = "1234567";
646     const char *bleMac = "11:22:33:44:33:00";
647     ConnectOption option = {
648         .type = CONNECT_BLE,
649         .bleOption.bleMac = "",
650         .bleOption.deviceIdHash = "",
651         .bleOption.protocol = BLE_GATT,
652         .bleOption.psm = 5,
653         .bleOption.challengeCode = 0,
654     };
655     int32_t ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, bleMac);
656     ASSERT_EQ(EOK, ret);
657     ret = memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, deviceId, UDID_HASH_LEN);
658     ASSERT_EQ(EOK, ret);
659     uint32_t requestId = 10;
660     ConnectResult result = {
661         .OnConnectSuccessed = OnConnectSuccessed,
662         .OnConnectFailed = OnConnectFailed,
663     };
664     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
665     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
666     ret = g_bleInterface->ConnectDevice(&option, requestId, &result);
667     EXPECT_EQ(ret, SOFTBUS_OK);
668     g_bleInterface->ConnectDevice(&option, requestId, &result);
669     EXPECT_EQ(ret, SOFTBUS_OK);
670     SoftBusSleepMs(SLEEP_TIME_MS);
671 }
672 
673 /*
674  * @tc.name: ConnectDevice002
675  * @tc.desc: Test ConnectDevice.
676  * @tc.in: Test module, Test number, Test Levels.
677  * @tc.out: Zero
678  * @tc.type: FUNC
679  * @tc.require:
680  */
681 HWTEST_F(ConnectionBleManagerTest, ConnectDevice002, TestSize.Level1)
682 {
683     const char *deviceId = "1234568";
684     const char *bleMac = "11:22:33:44:33:56";
685     ConnectOption option = {
686         .type = CONNECT_BLE,
687         .bleOption.bleMac = "",
688         .bleOption.deviceIdHash = "",
689         .bleOption.protocol = BLE_GATT,
690         .bleOption.psm = 5,
691         .bleOption.challengeCode = 0,
692     };
693     int32_t ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, bleMac);
694     ASSERT_EQ(EOK, ret);
695     ret = memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, deviceId, UDID_HASH_LEN);
696     ASSERT_EQ(EOK, ret);
697     uint32_t requestId = 5;
698     ConnectResult result = {
699         .OnConnectSuccessed = OnConnectSuccessed,
700         .OnConnectFailed = OnConnectFailed,
701     };
702     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
703     EXPECT_CALL(bleMock, LnnGetConnSubFeatureByUdidHashStr).WillRepeatedly(Return(SOFTBUS_OK));
704     EXPECT_CALL(bleMock, ConnGattClientConnect).WillRepeatedly(Return(SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_CONNECT_ERR));
705     ret = g_bleInterface->ConnectDevice(&option, requestId, &result);
706     EXPECT_EQ(ret, SOFTBUS_OK);
707     EXPECT_CALL(bleMock, ConnGattClientConnect).WillRepeatedly(Return(SOFTBUS_OK));
708     requestId = 6;
709     const char *mac = "11:33:44:22:33:56";
710     const char *bleDeviceId = "1234569";
711     ret = strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, mac);
712     ASSERT_EQ(EOK, ret);
713     ret = memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, bleDeviceId, UDID_HASH_LEN);
714     ASSERT_EQ(EOK, ret);
715     ret = g_bleInterface->ConnectDevice(&option, requestId, &result);
716     EXPECT_EQ(ret, SOFTBUS_OK);
717     SoftBusSleepMs(SLEEP_TIME_MS);
718 }
719 
720 /*
721  * @tc.name: ConnBleUpdateConnectionRc001
722  * @tc.desc: Test ConnBleUpdateConnectionRc.
723  * @tc.in: Test module, Test number, Test Levels.
724  * @tc.out: Zero
725  * @tc.type: FUNC
726  * @tc.require:
727  */
728 HWTEST_F(ConnectionBleManagerTest, ConnBleUpdateConnectionRc001, TestSize.Level1)
729 {
730     ConnBleConnection connection;
731     connection.connectionId = 196600;
732     connection.side = CONN_SIDE_CLIENT;
733     connection.featureBitSet = 0;
734     int32_t ret = SoftBusMutexInit(&connection.lock, NULL);
735     ASSERT_EQ(EOK, ret);
736 
737     connection.underlayerHandle = 10;
738     connection.connectionRc = 1;
739     const char *bleMac = "11:22:33:44:33:56";
740     ret = strcpy_s(connection.addr, BT_MAC_LEN, bleMac);
741     ASSERT_EQ(EOK, ret);
742     ret = ConnBleUpdateConnectionRc(&connection, 0, -1);
743     EXPECT_EQ(ret, SOFTBUS_OK);
744 
745     connection.connectionId = 196601;
746     connection.featureBitSet = 2;
747     connection.connectionRc = 1;
748     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
749     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillOnce(Return(-1)).WillRepeatedly(Return(100));
750     ret = ConnBleUpdateConnectionRc(&connection, 0, -1);
751     EXPECT_EQ(ret, -1);
752 
753     connection.connectionRc = 1;
754     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillRepeatedly(Return(SOFTBUS_OK));
755     ret = ConnBleUpdateConnectionRc(&connection, 0, -1);
756     EXPECT_EQ(ret, SOFTBUS_OK);
757 
758     connection.connectionRc = 2;
759     ret = ConnBleUpdateConnectionRc(&connection, 0, -1);
760     EXPECT_EQ(ret, SOFTBUS_OK);
761 }
762 
763 /*
764  * @tc.name: ConnBleOnReferenceRequest001
765  * @tc.desc: Test ConnBleOnReferenceRequest.
766  * @tc.in: Test module, Test number, Test Levels.
767  * @tc.out: Zero
768  * @tc.type: FUNC
769  * @tc.require:
770  */
771 HWTEST_F(ConnectionBleManagerTest, ConnBleOnReferenceRequest001, TestSize.Level1)
772 {
773     ConnBleConnection connection;
774     int32_t ret = SoftBusMutexInit(&connection.lock, NULL);
775     ASSERT_EQ(EOK, ret);
776     connection.connectionRc = 1;
777     connection.state = BLE_CONNECTION_STATE_NEGOTIATION_CLOSING;
778     cJSON json = { 0 };
779     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
780     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem).WillOnce(Return(false));
781     ret = ConnBleOnReferenceRequest(&connection, &json);
782     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
783 
784     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem).WillOnce(Return(true)).WillOnce(Return(false));
785     ret = ConnBleOnReferenceRequest(&connection, &json);
786     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
787 }
788 
789 /*
790  * @tc.name: ConnBleOnReferenceRequest002
791  * @tc.desc: Test ConnBleOnReferenceRequest.
792  * @tc.in: Test module, Test number, Test Levels.
793  * @tc.out: Zero
794  * @tc.type: FUNC
795  * @tc.require:
796  */
797 HWTEST_F(ConnectionBleManagerTest, ConnBleOnReferenceRequest002, TestSize.Level1)
798 {
799     ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
800     ASSERT_NE(nullptr, connection);
801     int32_t ret = SoftBusMutexInit(&connection->lock, NULL);
802     ASSERT_EQ(EOK, ret);
803     const char *bleMac = "11:22:33:44:33:56";
804     const char *udid = "1254222233334419";
805     ret = strcpy_s(connection->addr, BT_MAC_LEN, bleMac);
806     ASSERT_EQ(EOK, ret);
807     ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
808     EXPECT_EQ(EOK, ret);
809 
810     connection->protocol = BLE_GATT;
811     connection->connectionRc = 1;
812     connection->state = BLE_CONNECTION_STATE_NEGOTIATION_CLOSING;
813     connection->side = CONN_SIDE_SERVER;
814     ret = ConnBleSaveConnection(connection);
815     ASSERT_EQ(SOFTBUS_OK, ret);
816 
817     cJSON json = { 0 };
818     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
819     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem)
820         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetdelta)
821         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetPeerRc1);
822     EXPECT_CALL(bleMock, GetJsonObjectNumber16Item).WillOnce(Return(false));
823     ret = ConnBleOnReferenceRequest(connection, &json);
824     EXPECT_EQ(SOFTBUS_OK, ret);
825 
826     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem)
827         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetdelta)
828         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetPeerRc1);
829     connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
830     EXPECT_CALL(bleMock, GetJsonObjectNumber16Item).WillOnce(Return(true));
831     ret = ConnBleOnReferenceRequest(connection, &json);
832     EXPECT_EQ(SOFTBUS_OK, ret);
833 }
834 
835 /*
836  * @tc.name: ConnBleOnReferenceRequest003
837  * @tc.desc: Test ConnBleOnReferenceRequest.
838  * @tc.in: Test module, Test number, Test Levels.
839  * @tc.out: Zero
840  * @tc.type: FUNC
841  * @tc.require:
842  */
843 HWTEST_F(ConnectionBleManagerTest, ConnBleOnReferenceRequest003, TestSize.Level1)
844 {
845     ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
846     ASSERT_NE(nullptr, connection);
847     int32_t ret = SoftBusMutexInit(&connection->lock, NULL);
848     ASSERT_EQ(EOK, ret);
849     const char *bleMac = "11:22:33:44:33:56";
850     const char *udid = "1254222233334419";
851     ret = strcpy_s(connection->addr, BT_MAC_LEN, bleMac);
852     ASSERT_EQ(EOK, ret);
853     ret = strcpy_s(connection->udid, UDID_BUF_LEN, udid);
854     EXPECT_EQ(EOK, ret);
855 
856     connection->protocol = BLE_GATT;
857     connection->connectionRc = 1;
858     connection->state = BLE_CONNECTION_STATE_NEGOTIATION_CLOSING;
859     connection->side = CONN_SIDE_SERVER;
860     ret = ConnBleSaveConnection(connection);
861     ASSERT_EQ(SOFTBUS_OK, ret);
862     cJSON json = { 0 };
863 
864     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
865     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem)
866         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetdelta)
867         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetPeerRc0);
868 
869     EXPECT_CALL(bleMock, GetJsonObjectNumber16Item).WillRepeatedly(Return(false));
870     EXPECT_CALL(bleMock, ConnGattServerDisconnect).WillOnce(Return(SOFTBUS_OK));
871 
872     ret = ConnBleOnReferenceRequest(connection, &json);
873     EXPECT_EQ(SOFTBUS_OK, ret);
874 
875     connection->connectionRc = 3;
876     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem)
877         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetdelta)
878         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetPeerRc0);
879     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillOnce(Return(SOFTBUS_CREATE_JSON_ERR));
880     ret = ConnBleOnReferenceRequest(connection, &json);
881     EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
882 
883     EXPECT_CALL(bleMock, GetJsonObjectSignedNumberItem)
884         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetdelta)
885         .WillOnce(ConnectionBleManagerInterfaceMock::ActionOfGetPeerRc0);
886     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillOnce(Return(100));
887     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillOnce(Return(SOFTBUS_OK));
888     ret = ConnBleOnReferenceRequest(connection, &json);
889     EXPECT_EQ(SOFTBUS_OK, ret);
890 }
891 
892 /*
893  * @tc.name: ConnBleSend001
894  * @tc.desc: Test ConnBleSend.
895  * @tc.in: Test module, Test number, Test Levels.
896  * @tc.out: Zero
897  * @tc.type: FUNC
898  * @tc.require:
899  */
900 HWTEST_F(ConnectionBleManagerTest, ConnBleSend001, TestSize.Level1)
901 {
902     ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
903     ASSERT_NE(nullptr, connection);
904     int32_t ret = SoftBusMutexInit(&connection->lock, NULL);
905     ASSERT_EQ(EOK, ret);
906     connection->protocol = BLE_GATT;
907     connection->side = CONN_SIDE_SERVER;
908     uint8_t *data = (uint8_t *)SoftBusMalloc(sizeof(uint8_t));
909     uint32_t dataLen = sizeof(uint8_t);
910 
911     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
912     EXPECT_CALL(bleMock, ConnGattServerSend).WillOnce(Return(SOFTBUS_OK));
913     ret = ConnBleSend(connection, data, dataLen, MODULE_CONNECTION);
914     EXPECT_EQ(SOFTBUS_OK, ret);
915     connection->side = CONN_SIDE_CLIENT;
916     EXPECT_CALL(bleMock, ConnGattClientSend).WillOnce(Return(SOFTBUS_OK));
917     ret = ConnBleSend(connection, data, dataLen, MODULE_CONNECTION);
918     EXPECT_EQ(SOFTBUS_OK, ret);
919     ret = ConnBleSaveConnection(connection);
920     ASSERT_EQ(SOFTBUS_OK, ret);
921     ConnBleRefreshIdleTimeout(connection);
922 }
923 
924 /*
925  * @tc.name: ConnBleOccupy001
926  * @tc.desc: Test ConnBleOccupy.
927  * @tc.in: Test module, Test number, Test Levels.
928  * @tc.out: Zero
929  * @tc.type: FUNC
930  * @tc.require:
931  */
932 HWTEST_F(ConnectionBleManagerTest, ConnBleOccupy001, TestSize.Level1)
933 {
934     const char *bleMac = "11:22:33:44:55:66";
935     ConnBleConnection *connection = ConnBleCreateConnection(bleMac, BLE_GATT,
936     CONN_SIDE_CLIENT, INVALID_UNDERLAY_HANDLE, true);
937     ASSERT_NE(nullptr, connection);
938     int32_t ret = ConnBleSaveConnection(connection);
939     ASSERT_EQ(SOFTBUS_OK, ret);
940     ConnBleOccupy(connection);
941     NiceMock<ConnectionBleManagerInterfaceMock> bleMock;
942     EXPECT_CALL(bleMock, ConnBlePackCtlMessage).WillRepeatedly(Return(100));
943     EXPECT_CALL(bleMock, ConnBlePostBytesInner).WillRepeatedly(Return(SOFTBUS_OK));
944     ret = ConnBleUpdateConnectionRc(connection, 1, 1);
945     EXPECT_EQ(ret, SOFTBUS_OK);
946 
947     ret = ConnBleUpdateConnectionRc(connection, 1, -1);
948     EXPECT_EQ(ret, SOFTBUS_OK);
949     SoftBusSleepMs(WAIT_UPDATE_TIME_MS); // sleep 3.5s to retry update Rc
950     EXPECT_EQ(connection->state, BLE_CONNECTION_STATE_NEGOTIATION_CLOSING);
951     ConnBleRemoveConnection(connection);
952     ConnBleReturnConnection(&connection);
953 }
954 } // namespace OHOS
955