1 /*
2  * Copyright (c) 2023 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 <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 
22 #include "common_list.h"
23 #include "connection_br_mock.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_conn_br_connection.c"
26 #include "softbus_conn_br_manager.c"
27 #include "softbus_conn_br_pending_packet.h"
28 #include "softbus_conn_br_send_queue.h"
29 #include "softbus_conn_interface.h"
30 #include "softbus_conn_manager.h"
31 #include "softbus_errcode.h"
32 #include "softbus_feature_config.c"
33 #include "softbus_feature_config.h"
34 
35 #define SOFTBUS_CHARA_CONN_UUID "00002B01-0000-1000-8000-00805F9B34FB"
36 #define DATASIZE                256
37 
38 using namespace testing::ext;
39 using namespace testing;
40 
41 namespace OHOS {
GetRemoteDeviceInfo(int32_t clientFd,const BluetoothRemoteDevice * device)42 int32_t GetRemoteDeviceInfo(int32_t clientFd, const BluetoothRemoteDevice *device)
43 {
44     (void)device;
45     return clientFd;
46 }
47 
OnConnectFailed(uint32_t requestId,int32_t reason)48 void OnConnectFailed(uint32_t requestId, int32_t reason)
49 {
50     (void)requestId;
51     (void)reason;
52     return;
53 }
54 
OnConnectSuccessed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * info)55 void OnConnectSuccessed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *info)
56 {
57     (void)requestId;
58     (void)connectionId;
59     (void)info;
60     return;
61 }
62 
PostMessageDelay(const SoftBusLooper * looper,SoftBusMessage * msg,uint64_t delayMillis)63 void PostMessageDelay(const SoftBusLooper *looper, SoftBusMessage *msg, uint64_t delayMillis)
64 {
65     (void)looper;
66     (void)msg;
67     (void)delayMillis;
68     return;
69 }
70 
DeviceAction(ConnBrDevice * device,const char * anomizeAddress)71 int32_t DeviceAction(ConnBrDevice *device, const char *anomizeAddress)
72 {
73     return (int32_t)(device->state);
74 }
75 
OnConnected(uint32_t connectionId,const ConnectionInfo * info)76 void OnConnected(uint32_t connectionId, const ConnectionInfo *info)
77 {
78     (void)connectionId;
79     (void)info;
80     return;
81 }
82 
OnDisconnected(uint32_t connectionId,const ConnectionInfo * info)83 void OnDisconnected(uint32_t connectionId, const ConnectionInfo *info)
84 {
85     (void)connectionId;
86     (void)info;
87     return;
88 }
89 
MessageDelay(const SoftBusLooper * looper,SoftBusMessage * msg,uint64_t delayMillis)90 void MessageDelay(const SoftBusLooper *looper, SoftBusMessage *msg, uint64_t delayMillis)
91 {
92     (void)looper;
93     (void)msg;
94     (void)delayMillis;
95     return;
96 }
97 
RvMessageCustom(const SoftBusLooper * looper,const SoftBusHandler * handler,int32_t (* customFunc)(const SoftBusMessage *,void *),void * args)98 void RvMessageCustom(const SoftBusLooper *looper, const SoftBusHandler *handler,
99     int32_t (*customFunc)(const SoftBusMessage *, void *), void *args)
100 {
101     (void)looper;
102     (void)handler;
103     (void)customFunc;
104     (void)args;
105     return;
106 }
107 
HandlePendingRequest(void)108 void HandlePendingRequest(void)
109 {
110     return;
111 }
112 
connectRequest(const ConnBrConnectRequestContext * ctx)113 void connectRequest(const ConnBrConnectRequestContext *ctx)
114 {
115     (void)ctx;
116     return;
117 }
118 
clientConnected(uint32_t connectionId)119 void clientConnected(uint32_t connectionId)
120 {
121     (void)connectionId;
122     return;
123 }
124 
clientConnectTimeout(uint32_t connectionId,const char * address)125 void clientConnectTimeout(uint32_t connectionId, const char *address)
126 {
127     (void)connectionId;
128     (void)address;
129     return;
130 }
131 
clientConnectFailed(uint32_t connectionId,int32_t error)132 void clientConnectFailed(uint32_t connectionId, int32_t error)
133 {
134     (void)connectionId;
135     (void)error;
136     return;
137 }
138 
serverAccepted(uint32_t connectionId)139 void serverAccepted(uint32_t connectionId)
140 {
141     (void)connectionId;
142     return;
143 }
144 
dataReceived(ConnBrDataReceivedContext * ctx)145 void dataReceived(ConnBrDataReceivedContext *ctx)
146 {
147     (void)ctx;
148     return;
149 }
150 
connectionException(uint32_t connectionId,int32_t error)151 void connectionException(uint32_t connectionId, int32_t error)
152 {
153     (void)connectionId;
154     (void)error;
155     return;
156 }
157 
connectionResume(uint32_t connectionId)158 void connectionResume(uint32_t connectionId)
159 {
160     (void)connectionId;
161     return;
162 }
163 
disconnectRequest(uint32_t connectionId)164 void disconnectRequest(uint32_t connectionId)
165 {
166     (void)connectionId;
167     return;
168 }
Unpend(const char * addr)169 void Unpend(const char *addr)
170 {
171     (void)addr;
172     return;
173 }
174 
Reset(int32_t reason)175 void Reset(int32_t reason)
176 {
177     (void)reason;
178     return;
179 }
180 
181 class ConnectionBrConnectionTest : public testing::Test {
182 public:
ConnectionBrConnectionTest()183     ConnectionBrConnectionTest() { }
~ConnectionBrConnectionTest()184     ~ConnectionBrConnectionTest() { }
185     static void SetUpTestCase(void);
186     static void TearDownTestCase(void);
187     void SetUp();
188     void TearDown();
189 };
190 
SetUpTestCase(void)191 void ConnectionBrConnectionTest::SetUpTestCase(void)
192 {
193     LooperInit();
194     SoftbusConfigInit();
195     ConnServerInit();
196 }
197 
TearDownTestCase(void)198 void ConnectionBrConnectionTest::TearDownTestCase(void)
199 {
200     LooperDeinit();
201 }
202 
SetUp(void)203 void ConnectionBrConnectionTest::SetUp(void) { }
204 
TearDown(void)205 void ConnectionBrConnectionTest::TearDown(void) { }
206 
207 HWTEST_F(ConnectionBrConnectionTest, testBrConnection001, TestSize.Level1)
208 {
209     int ret;
210     char mac[BT_MAC_LEN] = { 0 };
211     int32_t socketHandle = 111;
212     ConnBrConnection *connection = ConnBrCreateConnection(mac, CONN_SIDE_SERVER, socketHandle);
213     ConnBrSaveConnection(connection);
214     const cJSON *json = nullptr;
215     NiceMock<ConnectionBrInterfaceMock> brMock;
216 
217     EXPECT_CALL(brMock, GetJsonObjectSignedNumberItem).WillRepeatedly(Return(false));
218     ret = ConnBrOnReferenceRequest(connection, json);
219     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
220 
221     EXPECT_CALL(brMock, GetJsonObjectSignedNumberItem).WillRepeatedly(Return(true));
222     EXPECT_CALL(brMock, AddNumberToJsonObject).WillRepeatedly(Return(false));
223     ret = ConnBrOnReferenceRequest(connection, json);
224     EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
225 
226     EXPECT_CALL(brMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
227     EXPECT_CALL(brMock, AddNumber64ToJsonObject).WillRepeatedly(Return(true));
228     ret = ConnBrOnReferenceRequest(connection, json);
229     EXPECT_EQ(SOFTBUS_OK, ret);
230 }
231 
232 HWTEST_F(ConnectionBrConnectionTest, testBrConnection002, TestSize.Level1)
233 {
234     int ret;
235     char mac[BT_MAC_LEN] = { 0 };
236     int32_t socketHandle = 222;
237     ConnBrConnection *connection = ConnBrCreateConnection(mac, CONN_SIDE_SERVER, socketHandle);
238     ConnBrSaveConnection(connection);
239     int32_t delta;
240     NiceMock<ConnectionBrInterfaceMock> brMock;
241 
242     EXPECT_CALL(brMock, AddNumberToJsonObject).WillRepeatedly(Return(false));
243     delta = 0;
244     ret = ConnBrUpdateConnectionRc(connection, delta);
245     EXPECT_EQ(SOFTBUS_CREATE_JSON_ERR, ret);
246 
247     EXPECT_CALL(brMock, AddNumberToJsonObject).WillRepeatedly(Return(true));
248     delta = 0;
249     ret = ConnBrUpdateConnectionRc(connection, delta);
250     EXPECT_EQ(SOFTBUS_OK, ret);
251 }
252 
253 HWTEST_F(ConnectionBrConnectionTest, testBrConnection003, TestSize.Level1)
254 {
255     int ret;
256     ConnBrConnection connection;
257 
258     connection.socketHandle = MAX_BR_READ_BUFFER_CAPACITY;
259     ret = ConnBrDisconnectNow(&connection);
260     EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
261 }
262 
263 HWTEST_F(ConnectionBrConnectionTest, testBrConnection004, TestSize.Level1)
264 {
265     int32_t result = 0;
266     int32_t status = 0;
267 
268     BdAddr addr = {
269         .addr = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
270     };
271     BtUuid uuid = {
272         .uuid = (char *)SOFTBUS_CHARA_CONN_UUID,
273         .uuidLen = strlen(SOFTBUS_CHARA_CONN_UUID),
274     };
275     EXPECT_NO_FATAL_FAILURE(BrConnectStatusCallback(&addr, uuid, result, status));
276 }
277 
278 HWTEST_F(ConnectionBrConnectionTest, testBrConnection005, TestSize.Level1)
279 {
280     int ret;
281     ConnBrConnection connection;
282     const cJSON *json = nullptr;
283     NiceMock<ConnectionBrInterfaceMock> brMock;
284 
285     EXPECT_CALL(brMock, GetJsonObjectSignedNumberItem).WillRepeatedly(Return(false));
286     ret = ConnBrOnReferenceResponse(&connection, json);
287     EXPECT_EQ(SOFTBUS_PARSE_JSON_ERR, ret);
288 
289     EXPECT_CALL(brMock, GetJsonObjectSignedNumberItem).WillRepeatedly(Return(true));
290     SoftBusMutexInit(&connection.lock, nullptr);
291     ret = ConnBrOnReferenceResponse(&connection, json);
292     EXPECT_EQ(SOFTBUS_OK, ret);
293 }
294 
295 HWTEST_F(ConnectionBrConnectionTest, testBrConnection006, TestSize.Level1)
296 {
297     int ret;
298     ServerState serverState;
299 
300     g_serverState = &serverState;
301     ret = ConnBrStartServer();
302     EXPECT_EQ(SOFTBUS_OK, ret);
303 
304     g_serverState = nullptr;
305     ret = ConnBrStartServer();
306     EXPECT_EQ(SOFTBUS_OK, ret);
307 }
308 
309 HWTEST_F(ConnectionBrConnectionTest, testBrConnection007, TestSize.Level1)
310 {
311     int ret;
312 
313     g_serverState->serverId = 1;
314     ret = ConnBrStopServer();
315     EXPECT_EQ(SOFTBUS_OK, ret);
316 
317     g_serverState = nullptr;
318     ret = ConnBrStopServer();
319     EXPECT_EQ(SOFTBUS_OK, ret);
320 }
321 
322 HWTEST_F(ConnectionBrConnectionTest, testBrConnection008, TestSize.Level1)
323 {
324     SoftBusMessage msg;
325 
326     msg.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
327     EXPECT_NO_FATAL_FAILURE(BrConnectionMsgHandler(&msg));
328     msg.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
329     EXPECT_NO_FATAL_FAILURE(BrConnectionMsgHandler(&msg));
330     msg.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE + 1;
331     EXPECT_NO_FATAL_FAILURE(BrConnectionMsgHandler(&msg));
332 }
333 
334 HWTEST_F(ConnectionBrConnectionTest, testBrConnection009, TestSize.Level1)
335 {
336     int ret;
337     SoftBusMessage msg;
338     SoftBusMessage args;
339 
340     msg.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
341     args.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
342     ret = BrCompareConnectionLooperEventFunc(&msg, (void *)(&args));
343     EXPECT_EQ(COMPARE_FAILED, ret);
344 
345     msg.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
346     args.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
347     msg.arg1 = 10;
348     args.arg1 = 10;
349     ret = BrCompareConnectionLooperEventFunc(&msg, (void *)(&args));
350     EXPECT_EQ(COMPARE_SUCCESS, ret);
351 
352     msg.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
353     args.what = MSG_CONNECTION_WAIT_NEGOTIATION_CLOSING_TIMEOUT;
354     msg.arg1 = 9;
355     args.arg1 = 10;
356     ret = BrCompareConnectionLooperEventFunc(&msg, (void *)(&args));
357     EXPECT_EQ(COMPARE_FAILED, ret);
358 
359     msg.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
360     args.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
361     msg.arg1 = 9;
362     args.arg1 = 10;
363     ret = BrCompareConnectionLooperEventFunc(&msg, (void *)(&args));
364     EXPECT_EQ(COMPARE_FAILED, ret);
365 
366     msg.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
367     args.what = MSG_CONNECTION_RETRY_NOTIFY_REFERENCE;
368     args.arg1 = 0;
369     args.arg2 = 0;
370     args.obj = nullptr;
371     ret = BrCompareConnectionLooperEventFunc(&msg, (void *)(&args));
372     EXPECT_EQ(COMPARE_SUCCESS, ret);
373 }
374 
375 HWTEST_F(ConnectionBrConnectionTest, testBrConnection010, TestSize.Level1)
376 {
377     void *ret = nullptr;
378     ServerServeContext *ctx = nullptr;
379 
380     g_sppDriver->GetRemoteDeviceInfo = GetRemoteDeviceInfo;
381     ctx = (ServerServeContext *)SoftBusCalloc(sizeof(*ctx));
382     ctx->socketHandle = 0;
383     ret = StartServerServe((void *)(ctx));
384     EXPECT_EQ(nullptr, ret);
385 }
386 
387 HWTEST_F(ConnectionBrConnectionTest, testBrConnection011, TestSize.Level1)
388 {
389     ConnBrConnection *connection;
390 
391     connection = (ConnBrConnection *)SoftBusCalloc(sizeof(*connection));
392     ASSERT_NE(nullptr, connection);
393     connection->connectProcessStatus = nullptr;
394     ConnBrFreeConnection(connection);
395 }
396 
397 HWTEST_F(ConnectionBrConnectionTest, testBrConnection012, TestSize.Level1)
398 {
399     void *ret;
400     ServerState *serverState;
401 
402     serverState = (ServerState *)SoftBusCalloc(sizeof(*serverState));
403     serverState->available = 0;
404     serverState->traceId = 0;
405     serverState->serverId = 1;
406     SoftBusMutexInit(&serverState->mutex, nullptr);
407     ret = ListenTask((void *)serverState);
408     EXPECT_EQ(nullptr, ret);
409 }
410 
411 HWTEST_F(ConnectionBrConnectionTest, testBrConnection013, TestSize.Level1)
412 {
413     int ret;
414     int val;
415     int mtu;
416 
417     g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len = 0;
418     ret = InitProperty();
419     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
420 
421     val = MAX_BR_READ_BUFFER_CAPACITY + 1;
422     g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len = 4;
423     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].val),
424         g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len, (void *)(&val), sizeof(int));
425     ret = InitProperty();
426     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
427 
428     val = MAX_BR_READ_BUFFER_CAPACITY;
429     g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len = 4;
430     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].val),
431         g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len, (void *)(&val), sizeof(int));
432     g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].len = 0;
433     ret = InitProperty();
434     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
435 
436     val = MAX_BR_READ_BUFFER_CAPACITY;
437     g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len = 4;
438     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].val),
439         g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len, (void *)(&val), sizeof(int));
440     mtu = MAX_BR_MTU_SIZE + 1;
441     g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].len = 4;
442     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].val),
443         g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].len, (void *)(&mtu), sizeof(int));
444     ret = InitProperty();
445     EXPECT_EQ(SOFTBUS_NO_INIT, ret);
446 
447     val = MAX_BR_READ_BUFFER_CAPACITY;
448     g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len = 4;
449     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].val),
450         g_configItems[SOFTBUS_INT_CONN_BR_MAX_DATA_LENGTH].len, (void *)(&val), sizeof(int));
451     mtu = MAX_BR_MTU_SIZE;
452     g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].len = 4;
453     memcpy_s((void *)(g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].val),
454         g_configItems[SOFTBUS_INT_CONN_RFCOM_SEND_MAX_LEN].len, (void *)(&mtu), sizeof(int));
455     ret = InitProperty();
456     EXPECT_EQ(SOFTBUS_OK, ret);
457 }
458 
459 HWTEST_F(ConnectionBrConnectionTest, testBrManager001, TestSize.Level1)
460 {
461     uint32_t reqId = 0;
462     uint32_t pId = 0;
463     ConnBrDevice *device = nullptr;
464     ConnectStatistics statistics;
465     int32_t reason = 0;
466 
467     EXPECT_NO_FATAL_FAILURE(DfxRecordBrConnectFail(reqId, pId, device, nullptr, reason));
468     EXPECT_NO_FATAL_FAILURE(DfxRecordBrConnectFail(reqId, pId, device, &statistics, reason));
469 }
470 
471 HWTEST_F(ConnectionBrConnectionTest, testBrManager002, TestSize.Level1)
472 {
473     uint32_t pId = 0;
474     ConnBrConnection *connection = static_cast<ConnBrConnection *>(SoftBusMalloc(sizeof(ConnBrConnection)));
475     ASSERT_NE(nullptr, connection);
476     connection->connectionId = 1;
477 
478     ConnectStatistics statistics;
479     (void)memset_s(&statistics, sizeof(statistics), 0, sizeof(statistics));
480 
481     DfxRecordBrConnectSuccess(pId, connection, nullptr);
482     DfxRecordBrConnectSuccess(pId, connection, &statistics);
483     SoftBusFree(connection);
484 }
485 
486 HWTEST_F(ConnectionBrConnectionTest, testBrManager003, TestSize.Level1)
487 {
488     ConnBrDevice device;
489     ConnBrConnection connection;
490     bool isReuse = false;
491     int32_t reason = 0;
492     ConnBrRequest request;
493 
494     request.requestId = 0;
495     request.requestId = 0;
496     request.result.OnConnectFailed = OnConnectFailed;
497     (void)strcpy_s(device.addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
498     ListInit(&device.requests);
499     ListAdd(&device.requests, &request.node);
500     EXPECT_NO_FATAL_FAILURE(NotifyDeviceConnectResult(&device, nullptr, isReuse, reason));
501 
502     (void)strcpy_s(device.addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
503     ListInit(&device.requests);
504     EXPECT_NO_FATAL_FAILURE(NotifyDeviceConnectResult(&device, &connection, isReuse, reason));
505 
506     request.requestId = 0;
507     request.requestId = 0;
508     request.result.OnConnectFailed = OnConnectFailed;
509     request.result.OnConnectSuccessed = OnConnectSuccessed;
510     (void)strcpy_s(device.addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
511     ListInit(&device.requests);
512     ListAdd(&device.requests, &request.node);
513     reason = 1;
514     isReuse = true;
515     EXPECT_NO_FATAL_FAILURE(NotifyDeviceConnectResult(&device, &connection, isReuse, reason));
516 }
517 
518 HWTEST_F(ConnectionBrConnectionTest, testBrManager005, TestSize.Level1)
519 {
520     const char *addr = "24:DA:33:6A:06:EC";
521     ConnBrPendInfo info;
522     BrPending pending;
523 
524     ListInit(&(g_brManager.pendings->list));
525     ListAdd(&(g_brManager.pendings->list), &(pending.node));
526     (void)strcpy_s(info.addr, BT_MAC_LEN, addr);
527     pending.pendInfo = &info;
528     int32_t ret = SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
529 
530     g_brManagerAsyncHandler.handler.looper->PostMessageDelay = PostMessageDelay;
531 
532     info.firstStartTimestamp = 0xfffffffffffffff;
533     info.firstDuration = 0x1;
534     EXPECT_EQ(SOFTBUS_OK, ret);
535 }
536 
537 HWTEST_F(ConnectionBrConnectionTest, testBrManager006, TestSize.Level1)
538 {
539     SoftBusBtAddr addr;
540     const char *addrress = "123";
541 
542     (void)strcpy_s((char *)(addr.addr), BT_ADDR_LEN, addrress);
543     ListInit(&(g_brManager.pendings->list));
544     (void)strcpy_s((char *)(addr.addr), BT_ADDR_LEN, addrress);
545 
546     int ret;
547     ConnBrDevice device;
548     const char *anomizeAddress;
549 
550     (void)strcpy_s(device.addr, BT_MAC_LEN, "abc");
551     anomizeAddress = "123";
552     SoftBusMutexDestroy(&g_brManager.connections->lock);
553     ret = ConnectDeviceDirectly(&device, anomizeAddress);
554     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
555 
556     (void)strcpy_s(device.addr, BT_MAC_LEN, "abc");
557     anomizeAddress = "123";
558     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
559     ret = ConnectDeviceDirectly(&device, anomizeAddress);
560     EXPECT_EQ(SOFTBUS_OK, ret);
561 }
562 
563 HWTEST_F(ConnectionBrConnectionTest, testBrManager008, TestSize.Level1)
564 {
565     int ret;
566     ConnBrDevice *device;
567     const char *anomizeAddress;
568     ConnBrDevice conn;
569     ConnBrDevice connBr;
570 
571     device = (ConnBrDevice *)SoftBusCalloc(sizeof(*device));
572     device->state = BR_DEVICE_STATE_INIT;
573     ListInit(&device->requests);
574     (void)strcpy_s(device->addr, BT_MAC_LEN, "abc");
575     (void)strcpy_s(conn.addr, BT_MAC_LEN, "abc");
576     ListInit(&conn.requests);
577     g_brManager.connecting = &conn;
578     anomizeAddress = "abc";
579     ListInit(&g_brManager.waitings);
580     ret = PendingDevice(device, anomizeAddress);
581     EXPECT_EQ(SOFTBUS_OK, ret);
582 
583     device = (ConnBrDevice *)SoftBusCalloc(sizeof(*device));
584     device->state = BR_DEVICE_STATE_INIT;
585     ListInit(&device->requests);
586     (void)strcpy_s(device->addr, BT_MAC_LEN, "abc");
587     (void)strcpy_s(conn.addr, BT_MAC_LEN, "abcd");
588     ListInit(&conn.requests);
589     g_brManager.connecting = &conn;
590     anomizeAddress = "abc";
591     ListInit(&g_brManager.waitings);
592     ret = PendingDevice(device, anomizeAddress);
593     EXPECT_EQ(SOFTBUS_OK, ret);
594 
595     device->state = BR_DEVICE_STATE_INIT;
596     ListInit(&device->requests);
597     (void)strcpy_s(device->addr, BT_MAC_LEN, "abc");
598     (void)strcpy_s(conn.addr, BT_MAC_LEN, "abcd");
599     (void)strcpy_s(connBr.addr, BT_MAC_LEN, "abc");
600     ListInit(&conn.requests);
601     g_brManager.connecting = &conn;
602     anomizeAddress = "abc";
603     ListInit(&g_brManager.waitings);
604     ListTailInsert(&g_brManager.waitings, &connBr.node);
605     ret = PendingDevice(device, anomizeAddress);
606     EXPECT_EQ(SOFTBUS_OK, ret);
607 }
608 
609 HWTEST_F(ConnectionBrConnectionTest, testBrManager009, TestSize.Level1)
610 {
611     bool ret;
612     ConnBrConnection connection;
613     ConnBrDevice device;
614 
615     connection.state = BR_CONNECTION_STATE_EXCEPTION;
616     SoftBusMutexInit(&connection.lock, nullptr);
617     connection.connectionId = 1;
618     ret = BrReuseConnection(&device, &connection);
619     EXPECT_EQ(false, ret);
620 }
621 
622 HWTEST_F(ConnectionBrConnectionTest, testBrManager010, TestSize.Level1)
623 {
624     bool ret;
625     const char *addr = "abc";
626     BrPending pending;
627     ConnBrPendInfo pendInfo;
628 
629     SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
630     ListInit(&g_brManager.pendings->list);
631     (void)strcpy_s(pendInfo.addr, BT_MAC_LEN, "abc");
632     pending.pendInfo = &pendInfo;
633     ListTailInsert(&g_brManager.pendings->list, &pending.node);
634     ret = CheckPending(addr);
635     EXPECT_EQ(false, ret);
636 
637     (void)strcpy_s(pendInfo.addr, BT_MAC_LEN, "abcd");
638     ret = CheckPending(addr);
639     EXPECT_EQ(false, ret);
640 }
641 
642 HWTEST_F(ConnectionBrConnectionTest, testBrManager014, TestSize.Level1)
643 {
644     uint32_t connectionId = 0;
645     ConnBrConnection *target;
646     NiceMock<ConnectionBrInterfaceMock> brMock;
647 
648     SoftBusMutexDestroy(&g_brManager.connections->lock);
649     ClientConnected(connectionId);
650 
651     EXPECT_CALL(brMock, AddNumberToJsonObject).WillRepeatedly(Return(false));
652     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
653     target = (ConnBrConnection *)SoftBusCalloc(sizeof(*target));
654     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
655     (void)strcpy_s(target->addr, BT_MAC_LEN, "abcde");
656     target->connectionId = 0;
657     target->connectionRc = 10;
658     SoftBusMutexInit(&target->lock, nullptr);
659     ListInit(&g_brManager.connections->list);
660     ListTailInsert(&g_brManager.connections->list, &target->node);
661     g_brManager.connecting = nullptr;
662     ClientConnected(connectionId);
663 }
664 
665 HWTEST_F(ConnectionBrConnectionTest, testBrManager015, TestSize.Level1)
666 {
667     uint32_t connectionId = 0;
668     int32_t error = 0;
669     ConnBrConnection *target;
670 
671     SoftBusMutexDestroy(&g_brManager.connections->lock);
672     EXPECT_NO_FATAL_FAILURE(ClientConnectFailed(connectionId, error));
673 
674     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
675     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
676     ASSERT_NE(nullptr, target);
677     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
678     (void)strcpy_s(target->addr, BT_MAC_LEN, "abcde");
679     target->connectionId = 1;
680     target->connectionRc = 10;
681     SoftBusMutexInit(&target->lock, nullptr);
682     ListInit(&g_brManager.connections->list);
683     ListTailInsert(&g_brManager.connections->list, &target->node);
684     g_brManager.connecting = nullptr;
685     EXPECT_NO_FATAL_FAILURE(ClientConnectFailed(connectionId, error));
686 }
687 
688 HWTEST_F(ConnectionBrConnectionTest, testBrManager016, TestSize.Level1)
689 {
690     uint32_t connectionId = 0;
691     int32_t error = 0;
692     ConnBrConnection *target;
693     ConnBrDevice *connectingDevice;
694 
695     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
696     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
697     ASSERT_NE(nullptr, target);
698     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
699     (void)strcpy_s(target->addr, BT_MAC_LEN, "abcde");
700     target->connectionId = 0;
701     target->connectionRc = 10;
702     target->side = CONN_SIDE_SERVER;
703     target->state = BR_CONNECTION_STATE_EXCEPTION;
704     target->objectRc = 1;
705     SoftBusMutexInit(&target->lock, nullptr);
706     ListInit(&g_brManager.connections->list);
707     ListTailInsert(&g_brManager.connections->list, &target->node);
708     connectingDevice = reinterpret_cast<ConnBrDevice *>(SoftBusCalloc(sizeof(*connectingDevice)));
709     ASSERT_NE(nullptr, connectingDevice);
710     (void)strcpy_s(connectingDevice->addr, BT_MAC_LEN, "abcde");
711     ListInit(&connectingDevice->requests);
712     g_brManager.connecting = connectingDevice;
713     SoftBusList *list = CreateSoftBusList();
714     ConnBrConnection *connection = ConnBrGetConnectionById(connectionId);
715     connection->connectProcessStatus = list;
716     ClientConnectFailed(connectionId, error);
717     ConnBrReturnConnection(&connection);
718 }
719 
720 HWTEST_F(ConnectionBrConnectionTest, testBrManager017, TestSize.Level1)
721 {
722     uint32_t connectionId = 0;
723     const char *address = "abc";
724     ConnBrConnection *target;
725 
726     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
727     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
728     ASSERT_NE(nullptr, target);
729     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
730     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
731     target->connectionId = 0;
732     target->objectRc = 1;
733     SoftBusMutexInit(&target->lock, nullptr);
734     ListInit(&g_brManager.connections->list);
735     ListTailInsert(&g_brManager.connections->list, &target->node);
736     g_brManager.connecting = nullptr;
737     ClientConnectTimeoutOnConnectingState(connectionId, address);
738 }
739 
740 HWTEST_F(ConnectionBrConnectionTest, testBrManager018, TestSize.Level1)
741 {
742     uint32_t connectionId = 0;
743     const char *address = "abc";
744     ConnBrDevice *connectingDevice;
745 
746     SoftBusMutexDestroy(&g_brManager.connections->lock);
747     connectingDevice = reinterpret_cast<ConnBrDevice *>(SoftBusCalloc(sizeof(*connectingDevice)));
748     ASSERT_NE(nullptr, connectingDevice);
749     (void)strcpy_s(connectingDevice->addr, BT_MAC_LEN, "abc");
750     ListInit(&connectingDevice->requests);
751     g_brManager.connecting = connectingDevice;
752     ClientConnectTimeoutOnConnectingState(connectionId, address);
753 }
754 
755 HWTEST_F(ConnectionBrConnectionTest, testBrManager019, TestSize.Level1)
756 {
757     ConnBrDataReceivedContext ctx;
758     ConnPktHead *head;
759 
760     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
761     head = reinterpret_cast<ConnPktHead *>(SoftBusCalloc(sizeof(*head)));
762     ASSERT_NE(nullptr, head);
763     head->flag = 0;
764     head->module = 0;
765     head->seq = 0;
766     ctx.data = (uint8_t *)head;
767     ctx.connectionId = 0;
768     DataReceived(&ctx);
769 }
770 
771 HWTEST_F(ConnectionBrConnectionTest, testBrManager020, TestSize.Level1)
772 {
773     ConnBrDataReceivedContext ctx;
774     ConnPktHead *head;
775     ConnBrConnection *target;
776     NiceMock<ConnectionBrInterfaceMock> brMock;
777 
778     EXPECT_CALL(brMock, cJSON_ParseWithLength).WillRepeatedly(Return(nullptr));
779     SoftBusMutexDestroy(&g_brManager.connections->lock);
780     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
781     ASSERT_NE(nullptr, target);
782     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
783     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
784     target->connectionId = 0;
785     target->objectRc = 1;
786     SoftBusMutexInit(&target->lock, nullptr);
787     ListInit(&g_brManager.connections->list);
788     ListTailInsert(&g_brManager.connections->list, &target->node);
789 
790     head = reinterpret_cast<ConnPktHead *>(SoftBusCalloc(sizeof(*head)));
791     ASSERT_NE(nullptr, head);
792     head->flag = 0;
793     head->module = MODULE_CONNECTION;
794     head->seq = 0;
795     ctx.data = (uint8_t *)head;
796     ctx.connectionId = 0;
797     DataReceived(&ctx);
798 }
799 
800 HWTEST_F(ConnectionBrConnectionTest, testBrManager021, TestSize.Level1)
801 {
802     ConnBrDataReceivedContext ctx;
803     ConnPktHead *head;
804     ConnBrConnection *target;
805 
806     SoftBusMutexDestroy(&g_brManager.connections->lock);
807     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
808     ASSERT_NE(nullptr, target);
809     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
810     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
811     target->connectionId = 0;
812     target->objectRc = 1;
813     SoftBusMutexInit(&target->lock, nullptr);
814     ListInit(&g_brManager.connections->list);
815     ListTailInsert(&g_brManager.connections->list, &target->node);
816 
817     head = reinterpret_cast<ConnPktHead *>(SoftBusCalloc(sizeof(*head)));
818     ASSERT_NE(nullptr, head);
819     head->flag = 0;
820     head->module = MODULE_NIP_BR_CHANNEL;
821     head->seq = (int64_t)BR_NIP_SEQ;
822     ctx.data = (uint8_t *)head;
823     ctx.connectionId = 0;
824     DataReceived(&ctx);
825 }
826 
827 HWTEST_F(ConnectionBrConnectionTest, testBrManager022, TestSize.Level1)
828 {
829     ConnBrDataReceivedContext ctx;
830     ConnPktHead *head;
831     ConnBrConnection *target;
832 
833     SoftBusMutexDestroy(&g_brManager.connections->lock);
834     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
835     ASSERT_NE(nullptr, target);
836     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
837     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
838     target->connectionId = 0;
839     target->objectRc = 1;
840     SoftBusMutexInit(&target->lock, nullptr);
841     ListInit(&g_brManager.connections->list);
842     ListTailInsert(&g_brManager.connections->list, &target->node);
843 
844     head = reinterpret_cast<ConnPktHead *>(SoftBusCalloc(sizeof(*head)));
845     ASSERT_NE(nullptr, head);
846     head->flag = 0;
847     head->module = MODULE_OLD_NEARBY;
848     head->seq = (int64_t)BR_NIP_SEQ;
849     ctx.data = (uint8_t *)head;
850     ctx.connectionId = 0;
851     DataReceived(&ctx);
852 }
853 
854 HWTEST_F(ConnectionBrConnectionTest, testBrManager023, TestSize.Level1)
855 {
856     ConnBrConnection *connection = static_cast<ConnBrConnection *>(SoftBusMalloc(sizeof(ConnBrConnection)));
857     ASSERT_NE(nullptr, connection);
858     connection->connectionId = 0;
859     char data[DATASIZE] = { "{\
860             \"ESSION_KEY\": \"sdadad\",\
861             \"ENCRYPT\": 30,\
862             \"MY_HANDLE_ID\": 22,\
863             \"PEER_HANDLE_ID\": 25,\
864         }" };
865     NiceMock<ConnectionBrInterfaceMock> brMock;
866 
867     ReceivedControlData(connection, NULL, 0);
868 
869     EXPECT_CALL(brMock, GetJsonObjectNumberItem).WillRepeatedly(Return(false));
870     ReceivedControlData(connection, (uint8_t *)data, DATASIZE);
871 
872     EXPECT_CALL(brMock, GetJsonObjectNumberItem).WillRepeatedly(Return(true));
873     ReceivedControlData(connection, (uint8_t *)data, DATASIZE);
874     SoftBusFree(connection);
875 }
876 
877 HWTEST_F(ConnectionBrConnectionTest, testBrManager024, TestSize.Level1)
878 {
879     uint32_t connectionId = 0;
880     int32_t error = 0;
881     ConnBrConnection *target;
882     ConnBrDevice it;
883 
884     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
885     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
886     ASSERT_NE(nullptr, target);
887     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
888     target->connectionId = 0;
889     target->objectRc = 10;
890     SoftBusMutexInit(&target->lock, nullptr);
891     ListInit(&g_brManager.connections->list);
892     ListTailInsert(&g_brManager.connections->list, &target->node);
893 
894     ListInit(&g_brManager.waitings);
895     (void)strcpy_s(it.addr, BT_MAC_LEN, "abc");
896     ListTailInsert(&g_brManager.waitings, &it.node);
897     g_connectCallback.OnDisconnected = OnDisconnected;
898     g_brManagerAsyncHandler.handler.looper->PostMessageDelay = MessageDelay;
899     ConnectionException(connectionId, error);
900 }
901 
902 HWTEST_F(ConnectionBrConnectionTest, testBrManager025, TestSize.Level1)
903 {
904     uint32_t connectionId = 0;
905     ConnBrConnection *target;
906     ConnBrDevice *it;
907 
908     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
909     target = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*target)));
910     ASSERT_NE(nullptr, target);
911     (void)strcpy_s(target->addr, BT_MAC_LEN, "abc");
912     target->connectionId = 0;
913     target->objectRc = 10;
914     target->state = BR_CONNECTION_STATE_CONNECTED;
915     SoftBusMutexInit(&target->lock, nullptr);
916     ListInit(&g_brManager.connections->list);
917     ListTailInsert(&g_brManager.connections->list, &target->node);
918 
919     it = reinterpret_cast<ConnBrDevice *>(SoftBusCalloc(sizeof(*it)));
920     ASSERT_NE(nullptr, it);
921     (void)strcpy_s(it->addr, BT_MAC_LEN, "abc");
922     ListInit(&g_brManager.waitings);
923     ListTailInsert(&g_brManager.waitings, &it->node);
924     ListInit(&it->requests);
925     ConnectionResume(connectionId);
926 }
927 
928 HWTEST_F(ConnectionBrConnectionTest, testBrManager026, TestSize.Level1)
929 {
930     ConnBrPendInfo unpendInfo;
931 
932     SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
933     (void)strcpy_s(unpendInfo.addr, BT_MAC_LEN, "abc");
934     ListInit(&g_brManager.pendings->list);
935     g_brManagerAsyncHandler.handler.looper->RemoveMessageCustom = RvMessageCustom;
936     EXPECT_NO_FATAL_FAILURE(UnpendConnection(unpendInfo.addr));
937 }
938 
939 HWTEST_F(ConnectionBrConnectionTest, testBrManager027, TestSize.Level1)
940 {
941     enum BrServerState target = BR_STATE_AVAILABLE;
942 
943     TransitionToState(target);
944     TransitionToState(target);
945     target = BR_STATE_CONNECTING;
946     TransitionToState(target);
947     EXPECT_NE(g_brManager.state, nullptr);
948 }
949 
950 HWTEST_F(ConnectionBrConnectionTest, testBrManager028, TestSize.Level1)
951 {
952     SoftBusMessage msg;
953     ErrorContext obj;
954 
955     g_brManager.state->handlePendingRequest = HandlePendingRequest;
956     g_brManager.state->connectRequest = connectRequest;
957     g_brManager.state->clientConnected = clientConnected;
958     g_brManager.state->clientConnectTimeout = clientConnectTimeout;
959     g_brManager.state->clientConnectFailed = clientConnectFailed;
960     g_brManager.state->serverAccepted = serverAccepted;
961     g_brManager.state->dataReceived = dataReceived;
962     g_brManager.state->connectionException = connectionException;
963     g_brManager.state->connectionResume = connectionResume;
964     g_brManager.state->disconnectRequest = disconnectRequest;
965     g_brManager.state->unpend = Unpend;
966     g_brManager.state->reset = Reset;
967 
968     obj.connectionId = 0;
969     obj.error = 0;
970     msg.obj = &obj;
971 
972     msg.what = MSG_NEXT_CMD;
973     BrManagerMsgHandler(&msg);
974 
975     msg.what = MSG_CONNECT_REQUEST;
976     BrManagerMsgHandler(&msg);
977 
978     msg.what = MSG_CONNECT_SUCCESS;
979     BrManagerMsgHandler(&msg);
980 
981     msg.what = MSG_CONNECT_TIMEOUT;
982     BrManagerMsgHandler(&msg);
983 
984     msg.what = MSG_CONNECT_FAIL;
985     BrManagerMsgHandler(&msg);
986 
987     msg.what = MSG_SERVER_ACCEPTED;
988     BrManagerMsgHandler(&msg);
989 
990     msg.what = MSG_DATA_RECEIVED;
991     BrManagerMsgHandler(&msg);
992 
993     msg.what = MSG_CONNECTION_EXECEPTION;
994     BrManagerMsgHandler(&msg);
995 
996     msg.what = MSG_CONNECTION_RESUME;
997     BrManagerMsgHandler(&msg);
998 
999     msg.what = MGR_DISCONNECT_REQUEST;
1000     BrManagerMsgHandler(&msg);
1001 
1002     msg.what = MSG_UNPEND;
1003     BrManagerMsgHandler(&msg);
1004 
1005     msg.what = MSG_RESET;
1006     BrManagerMsgHandler(&msg);
1007 
1008     msg.what = MSG_RESET + 1;
1009     BrManagerMsgHandler(&msg);
1010 }
1011 
1012 HWTEST_F(ConnectionBrConnectionTest, testBrManager029, TestSize.Level1)
1013 {
1014     int ret;
1015     SoftBusMessage msg;
1016     SoftBusMessage args;
1017     ConnBrPendInfo msgInfo;
1018     ConnBrPendInfo ctxInfo;
1019 
1020     msg.what = MSG_CONNECT_TIMEOUT;
1021     args.what = MSG_UNPEND;
1022     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1023     EXPECT_EQ(COMPARE_FAILED, ret);
1024 
1025     args.what = MSG_CONNECT_TIMEOUT;
1026     msg.arg1 = 1;
1027     args.arg1 = 1;
1028     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1029     EXPECT_EQ(COMPARE_SUCCESS, ret);
1030 
1031     msg.arg1 = 0;
1032     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1033     EXPECT_EQ(COMPARE_FAILED, ret);
1034 
1035     msg.what = MSG_UNPEND;
1036     args.what = MSG_UNPEND;
1037     msg.obj = nullptr;
1038     args.obj = nullptr;
1039     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1040     EXPECT_EQ(COMPARE_FAILED, ret);
1041 
1042     msg.what = MSG_UNPEND;
1043     args.what = MSG_UNPEND;
1044     (void)strcpy_s(msgInfo.addr, BT_MAC_LEN, "abc");
1045     (void)strcpy_s(ctxInfo.addr, BT_MAC_LEN, "abc");
1046     msg.obj = &msgInfo;
1047     args.obj = &ctxInfo;
1048     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1049     EXPECT_EQ(COMPARE_SUCCESS, ret);
1050 
1051     (void)strcpy_s(msgInfo.addr, BT_MAC_LEN, "abcd");
1052     (void)strcpy_s(ctxInfo.addr, BT_MAC_LEN, "abc");
1053     msg.obj = &msgInfo;
1054     args.obj = &ctxInfo;
1055     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1056     EXPECT_EQ(COMPARE_FAILED, ret);
1057 
1058     msg.what = MSG_CONNECT_REQUEST;
1059     args.what = MSG_CONNECT_REQUEST;
1060     args.arg1 = 1;
1061     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1062     EXPECT_EQ(COMPARE_FAILED, ret);
1063 
1064     args.arg1 = 0;
1065     args.arg2 = 0;
1066     args.obj = nullptr;
1067     ret = BrCompareManagerLooperEventFunc(&msg, &args);
1068     EXPECT_EQ(COMPARE_SUCCESS, ret);
1069 }
1070 
1071 HWTEST_F(ConnectionBrConnectionTest, testBrManager030, TestSize.Level1)
1072 {
1073     uint32_t connectionId = 0;
1074     uint32_t len = 0;
1075     int32_t pid = 0;
1076     int32_t flag = 0;
1077     int32_t module = 0;
1078     int64_t seq = 0;
1079     int32_t error = 1;
1080 
1081     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
1082     ListInit(&g_brManager.connections->list);
1083     EXPECT_NO_FATAL_FAILURE(OnPostByteFinshed(connectionId, len, pid, flag, module, seq, error));
1084 }
1085 
1086 HWTEST_F(ConnectionBrConnectionTest, testBrManager031, TestSize.Level1)
1087 {
1088     int ret;
1089     char mac[BT_MAC_LEN] = { 0 };
1090     int32_t socketHandle = 333;
1091     ConnBrConnection *connection = ConnBrCreateConnection(mac, CONN_SIDE_SERVER, socketHandle);
1092     ConnBrSaveConnection(connection);
1093     connection->connectionId = (CONNECT_BR << CONNECT_TYPE_SHIFT) + 6;
1094     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
1095     ListInit(&g_brManager.connections->list);
1096     ListTailInsert(&g_brManager.connections->list, &connection->node);
1097     ret = AllocateConnectionIdUnsafe();
1098     EXPECT_EQ(SOFTBUS_OK, ret);
1099 }
1100 
1101 HWTEST_F(ConnectionBrConnectionTest, testBrManager032, TestSize.Level1)
1102 {
1103     int ret;
1104     ConnBrConnection it;
1105 
1106     ListInit(&g_brManager.connections->list);
1107     it.connectionId = 0;
1108     ListTailInsert(&g_brManager.connections->list, &it.node);
1109     ret = AllocateConnectionIdUnsafe();
1110     EXPECT_NE(SOFTBUS_OK, ret);
1111 }
1112 
1113 HWTEST_F(ConnectionBrConnectionTest, testBrManager033, TestSize.Level1)
1114 {
1115     ConnBrConnection *connection;
1116     ConnBrConnection target;
1117 
1118     connection = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*connection)));
1119     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
1120     ListInit(&g_brManager.connections->list);
1121     connection->connectionId = 0;
1122     target.connectionId = 0;
1123     EXPECT_NO_FATAL_FAILURE(ListTailInsert(&g_brManager.connections->list, &target.node));
1124     ConnBrRemoveConnection(connection);
1125 }
1126 
1127 HWTEST_F(ConnectionBrConnectionTest, testBrManager034, TestSize.Level1)
1128 {
1129     ConnBrConnection *connection;
1130     ConnBrConnection target;
1131 
1132     connection = reinterpret_cast<ConnBrConnection *>(SoftBusCalloc(sizeof(*connection)));
1133     SoftBusMutexInit(&g_brManager.connections->lock, nullptr);
1134     ListInit(&g_brManager.connections->list);
1135     connection->connectionId = 0;
1136     target.connectionId = 1;
1137     EXPECT_NO_FATAL_FAILURE(ListTailInsert(&g_brManager.connections->list, &target.node));
1138     ConnBrRemoveConnection(connection);
1139 }
1140 
1141 HWTEST_F(ConnectionBrConnectionTest, testBrManager035, TestSize.Level1)
1142 {
1143     int ret;
1144     ConnectOption option;
1145     uint32_t time = 10;
1146     BrPending it;
1147     ConnBrPendInfo pendInfo;
1148 
1149     SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
1150     option.type = CONNECT_BR;
1151     (void)strcpy_s(option.brOption.brMac, BT_MAC_LEN, "abc");
1152     ListInit(&g_brManager.pendings->list);
1153     (void)strcpy_s(pendInfo.addr, BT_MAC_LEN, "abc");
1154     pendInfo.startTimestamp = 1;
1155     pendInfo.duration = 1;
1156     pendInfo.firstDuration = 1;
1157     pendInfo.firstStartTimestamp = 1;
1158     it.pendInfo = &pendInfo;
1159     ListTailInsert(&g_brManager.pendings->list, &it.node);
1160     g_brManagerAsyncHandler.handler.looper->RemoveMessageCustom = RvMessageCustom;
1161     g_brManagerAsyncHandler.handler.looper->PostMessageDelay = PostMessageDelay;
1162     ret = BrPendConnection(&option, time);
1163     EXPECT_EQ(SOFTBUS_OK, ret);
1164 }
1165 
1166 HWTEST_F(ConnectionBrConnectionTest, testBrManager036, TestSize.Level1)
1167 {
1168     int ret;
1169     ConnectOption option;
1170     uint32_t time = 10;
1171     BrPending it;
1172     ConnBrPendInfo pendInfo;
1173 
1174     SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
1175     option.type = CONNECT_BR;
1176     (void)strcpy_s(option.brOption.brMac, BT_MAC_LEN, "abc");
1177     ListInit(&g_brManager.pendings->list);
1178     (void)strcpy_s(pendInfo.addr, BT_MAC_LEN, "abc");
1179     pendInfo.startTimestamp = 0xffffffff;
1180     pendInfo.duration = 0xffffffff;
1181     pendInfo.firstDuration = 1;
1182     pendInfo.firstStartTimestamp = 1;
1183     it.pendInfo = &pendInfo;
1184     ListTailInsert(&g_brManager.pendings->list, &it.node);
1185     g_brManagerAsyncHandler.handler.looper->RemoveMessageCustom = RvMessageCustom;
1186     g_brManagerAsyncHandler.handler.looper->PostMessageDelay = PostMessageDelay;
1187     ret = BrPendConnection(&option, time);
1188     EXPECT_EQ(SOFTBUS_OK, ret);
1189 }
1190 
1191 HWTEST_F(ConnectionBrConnectionTest, testBrManager037, TestSize.Level1)
1192 {
1193     int ret;
1194     ConnectOption option;
1195     uint32_t time = 10;
1196     BrPending it;
1197     ConnBrPendInfo pendInfo;
1198 
1199     SoftBusMutexInit(&g_brManager.pendings->lock, nullptr);
1200     option.type = CONNECT_BR;
1201     (void)strcpy_s(option.brOption.brMac, BT_MAC_LEN, "abc");
1202     ListInit(&g_brManager.pendings->list);
1203     (void)strcpy_s(pendInfo.addr, BT_MAC_LEN, "abce");
1204     it.pendInfo = &pendInfo;
1205     ListTailInsert(&g_brManager.pendings->list, &it.node);
1206     g_brManagerAsyncHandler.handler.looper->PostMessageDelay = PostMessageDelay;
1207     ret = BrPendConnection(&option, time);
1208     EXPECT_EQ(SOFTBUS_OK, ret);
1209 }
1210 
1211 HWTEST_F(ConnectionBrConnectionTest, testBrManager038, TestSize.Level1)
1212 {
1213     NiceMock<ConnectionBrInterfaceMock> brMock;
1214 
1215     EXPECT_CALL(brMock, SoftBusGetBtMacAddr).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1216     DumpLocalBtMac();
1217 
1218     EXPECT_CALL(brMock, SoftBusGetBtMacAddr).WillRepeatedly(Return(SOFTBUS_OK));
1219     DumpLocalBtMac();
1220 }
1221 
1222 HWTEST_F(ConnectionBrConnectionTest, testBrManager039, TestSize.Level1)
1223 {
1224     int listenerId = 0;
1225     int state = SOFTBUS_BR_STATE_TURN_ON;
1226     NiceMock<ConnectionBrInterfaceMock> brMock;
1227 
1228     EXPECT_CALL(brMock, SoftBusGetBtMacAddr).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1229     OnBtStateChanged(listenerId, state);
1230 
1231     state = SOFTBUS_BR_STATE_TURN_OFF;
1232     OnBtStateChanged(listenerId, state);
1233 }
1234 
1235 HWTEST_F(ConnectionBrConnectionTest, testBrManager040, TestSize.Level1)
1236 {
1237     const char *addr = "11:22:33:44:55:66";
1238     InitBrManager();
1239     ConnBrConnection *connection = ConnBrCreateConnection(addr, CONN_SIDE_CLIENT, -1);
1240     ASSERT_TRUE(connection != NULL);
1241     int32_t ret = ConnBrSaveConnection(connection);
1242     EXPECT_EQ(SOFTBUS_OK, ret);
1243     int32_t error = SOFTBUS_CONN_BR_UNDERLAY_CONNECT_FAIL;
1244     bool isWait = IsNeedWaitCallbackError(connection->connectionId, &error);
1245     EXPECT_EQ(true, isWait);
1246 
1247     BrUnderlayerStatus *callbackStatus = (BrUnderlayerStatus *)SoftBusCalloc(sizeof(BrUnderlayerStatus));
1248     ASSERT_TRUE(callbackStatus != NULL);
1249     ListInit(&callbackStatus->node);
1250     callbackStatus->status = 0;
1251     callbackStatus->result = 4;
1252     ListAdd(&connection->connectProcessStatus->list, &callbackStatus->node);
1253     isWait = IsNeedWaitCallbackError(connection->connectionId, &error);
1254     EXPECT_EQ(false, isWait);
1255 
1256     BrUnderlayerStatus *it = NULL;
1257     LIST_FOR_EACH_ENTRY(it, &connection->connectProcessStatus->list, BrUnderlayerStatus, node) {
1258         if (it->result == 4) {
1259             it->result = CONN_BR_CONNECT_UNDERLAYER_ERROR_UNDEFINED + 1;
1260         }
1261     }
1262     isWait = IsNeedWaitCallbackError(connection->connectionId, &error);
1263     EXPECT_EQ(true, isWait);
1264 }
1265 } // namespace OHOS
1266