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 "softbus_conn_br_connection_mock.h"
17 #include "softbus_conn_br_connection.h"
18 #include "softbus_conn_br_manager.h"
19 #include "softbus_conn_br_trans.h"
20
21 #include <cstdio>
22 #include <cstdlib>
23 #include <cstring>
24 #include <gtest/gtest.h>
25 #include <securec.h>
26
27 #include "common_list.h"
28 #include "conn_log.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_adapter_thread.h"
31 #include "softbus_error_code.h"
32 #include "wrapper_br_interface.h"
33
34 #include "softbus_conn_br_pending_packet.h"
35 #include "softbus_conn_br_send_queue.h"
36 #include "softbus_conn_interface.h"
37 #include "softbus_conn_manager.h"
38
39 using namespace testing::ext;
40 using namespace testing;
41 using namespace std;
42
43 #define BR_READ_FAILED (-1)
44 #define BR_WRITE_FAILED (-2)
45 namespace OHOS {
46 extern "C" {
OnConnected(uint32_t connectionId,const ConnectionInfo * info)47 void OnConnected(uint32_t connectionId, const ConnectionInfo *info)
48 {
49 (void)connectionId;
50 (void)info;
51 return;
52 }
53
OnReusedConnected(uint32_t connectionId,const ConnectionInfo * info)54 void OnReusedConnected(uint32_t connectionId, const ConnectionInfo *info)
55 {
56 (void)connectionId;
57 (void)info;
58 return;
59 }
60
OnDisconnected(uint32_t connectionId,const ConnectionInfo * info)61 void OnDisconnected(uint32_t connectionId, const ConnectionInfo *info)
62 {
63 (void)connectionId;
64 (void)info;
65 return;
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 return;
76 }
77
Init(const struct tagSppSocketDriver * sppDriver)78 void Init(const struct tagSppSocketDriver *sppDriver)
79 {
80 (void)sppDriver;
81 return;
82 }
83
Read(int32_t clientFd,uint8_t * buf,const int32_t length)84 int32_t Read(int32_t clientFd, uint8_t *buf, const int32_t length)
85 {
86 (void)clientFd;
87 (void)buf;
88 if (length <= 0) {
89 return BR_READ_SOCKET_CLOSED;
90 }
91 return length;
92 }
93
Write(int32_t clientFd,const uint8_t * buf,const int32_t length)94 int32_t Write(int32_t clientFd, const uint8_t *buf, const int32_t length)
95 {
96 (void)clientFd;
97 (void)buf;
98 if (length <= 0) {
99 return BR_WRITE_FAILED;
100 }
101 return SOFTBUS_OK;
102 }
103
OnPostByteFinshed(uint32_t connectionId,uint32_t len,int32_t pid,int32_t flag,int32_t module,int64_t seq,int32_t error)104 void OnPostByteFinshed(
105 uint32_t connectionId, uint32_t len, int32_t pid, int32_t flag, int32_t module, int64_t seq, int32_t error)
106 {
107 (void)connectionId;
108 (void)len;
109 (void)pid;
110 (void)flag;
111 (void)module;
112 (void)seq;
113 (void)error;
114 return;
115 }
116
OnConnectSuccessed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * info)117 void OnConnectSuccessed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *info)
118 {
119 (void)requestId;
120 (void)connectionId;
121 (void)info;
122 return;
123 }
124
OnConnectFailed(uint32_t requestId,int32_t reason)125 void OnConnectFailed(uint32_t requestId, int32_t reason)
126 {
127 (void)requestId;
128 (void)reason;
129 return;
130 }
131 }
132 class ConnectionBrConnectionTest : public testing::Test {
133 public:
ConnectionBrConnectionTest()134 ConnectionBrConnectionTest() { }
~ConnectionBrConnectionTest()135 ~ConnectionBrConnectionTest() { }
136 static void SetUpTestCase(void);
137 static void TearDownTestCase(void);
138 void SetUp();
139 void TearDown();
140 };
141
SetUpTestCase(void)142 void ConnectionBrConnectionTest::SetUpTestCase(void) { }
143
TearDownTestCase(void)144 void ConnectionBrConnectionTest::TearDownTestCase(void) { }
145
SetUp(void)146 void ConnectionBrConnectionTest::SetUp(void) { }
147
TearDown(void)148 void ConnectionBrConnectionTest::TearDown(void) { }
149
150 SppSocketDriver g_sppDriver = {
151 .Init = Init,
152 .Read = Read,
153 .Write = Write,
154 };
155
156 ConnBrTransEventListener g_transEventlistener = {
157 .onPostByteFinshed = OnPostByteFinshed,
158 };
159
160 ConnectFuncInterface *connectFuncInterface = nullptr;
161 ConnectFuncInterface *g_connectFuncInterface = nullptr;
162
ConnInit(void)163 ConnectFuncInterface *ConnInit(void)
164 {
165 LooperInit();
166
167 ConnectCallback callback = {
168 .OnConnected = OnConnected,
169 .OnDisconnected = OnDisconnected,
170 .OnDataReceived = OnDataReceived,
171 };
172 NiceMock<ConnectionBrInterfaceMock> brMock;
173
174 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
175 EXPECT_CALL(brMock, SoftbusGetConfig)
176 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig1)
177 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig2);
178 EXPECT_CALL(brMock, ConnBrInnerQueueInit).WillOnce(Return(SOFTBUS_OK));
179 EXPECT_CALL(brMock, SoftBusAddBtStateListener).WillOnce(Return(SOFTBUS_OK));
180 EXPECT_CALL(brMock, ConnBrInitBrPendingPacket).WillOnce(Return(SOFTBUS_OK));
181
182 connectFuncInterface = ConnInitBr(&callback);
183 return connectFuncInterface;
184 }
185
186 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest001, TestSize.Level1)
187 {
188 CONN_LOGI(CONN_BR, "ConnInitBr1, Start");
189 NiceMock<ConnectionBrInterfaceMock> brMock;
190 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
191
192 LooperInit();
193
194 ConnectCallback callback = {
195 .OnConnected = OnConnected,
196 .OnDisconnected = OnDisconnected,
197 .OnDataReceived = OnDataReceived,
198 };
199
200 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
201 EXPECT_CALL(brMock, SoftbusGetConfig).WillOnce(Return(SOFTBUS_NO_INIT));
202 ConnectFuncInterface *ret = ConnInitBr(&callback);
203 EXPECT_EQ(nullptr, ret);
204
205 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
206 EXPECT_CALL(brMock, SoftbusGetConfig).WillOnce(Return(SOFTBUS_OK));
207 ret = ConnInitBr(&callback);
208 EXPECT_EQ(nullptr, ret);
209
210 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
211 EXPECT_CALL(brMock, SoftbusGetConfig)
212 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig1)
213 .WillOnce(Return(SOFTBUS_NO_INIT));
214 ret = ConnInitBr(&callback);
215 EXPECT_EQ(nullptr, ret);
216 }
217
218 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest002, TestSize.Level1)
219 {
220 CONN_LOGI(CONN_BR, "ConnInitBr2, Start");
221
222 ConnectCallback callback = {
223 .OnConnected = OnConnected,
224 .OnDisconnected = OnDisconnected,
225 .OnDataReceived = OnDataReceived,
226 };
227 NiceMock<ConnectionBrInterfaceMock> brMock;
228
229 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
230 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
231 EXPECT_CALL(brMock, SoftbusGetConfig)
232 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig1)
233 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig2);
234 EXPECT_CALL(brMock, ConnBrInnerQueueInit).WillOnce(Return(SOFTBUS_NO_INIT));
235 ConnectFuncInterface *ret = ConnInitBr(&callback);
236 EXPECT_EQ(nullptr, ret);
237
238 EXPECT_CALL(brMock, InitSppSocketDriver).WillOnce(Return(&g_sppDriver));
239 EXPECT_CALL(brMock, SoftbusGetConfig)
240 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig1)
241 .WillOnce(ConnectionBrInterfaceMock::ActionOfSoftbusGetConfig2);
242 EXPECT_CALL(brMock, ConnBrInnerQueueInit).WillOnce(Return(SOFTBUS_OK));
243 ret = ConnInitBr(&callback);
244 EXPECT_NE(nullptr, ret);
245 }
246
247 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest003, TestSize.Level1)
248 {
249 CONN_LOGI(CONN_BR, "ConnInitBr3, Start");
250
251 NiceMock<ConnectionBrInterfaceMock> brMock;
252 ConnectOption *option = (ConnectOption *)SoftBusCalloc(sizeof(ConnectOption));
253 ASSERT_NE(nullptr, option);
254 option->type = CONNECT_BR;
255 (void)strcpy_s(option->brOption.brMac, BT_MAC_LEN, "24:DA:33:6A:06:EC");
256 uint32_t requestId = 1;
257 ConnectResult result = {
258 .OnConnectSuccessed = OnConnectSuccessed,
259 .OnConnectFailed = OnConnectFailed,
260 };
261
262 g_connectFuncInterface = ConnInit();
263 int32_t ret = g_connectFuncInterface->ConnectDevice(option, requestId, &result);
264 EXPECT_EQ(SOFTBUS_OK, ret);
265 }
266
267 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest004, TestSize.Level1)
268 {
269 CONN_LOGI(CONN_BR, "ConnInitBr4, Start");
270
271 NiceMock<ConnectionBrInterfaceMock> brMock;
272 uint32_t connectionId = 1;
273 uint8_t *data1 = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
274 ASSERT_NE(nullptr, data1);
275 (void)memset_s(data1, sizeof(uint8_t), 0, sizeof(uint8_t));
276 int32_t pid = 1;
277 int32_t flag = 1;
278 int64_t seq = 1;
279 int32_t ret = g_connectFuncInterface->PostBytes(connectionId, data1, 0, pid, flag, MODULE_BLE_CONN, seq);
280 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
281
282 uint8_t *data2 = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
283 ASSERT_NE(nullptr, data2);
284 (void)memset_s(data2, sizeof(uint8_t), 0, sizeof(uint8_t));
285 ConnBrDevice *device = (ConnBrDevice *)SoftBusCalloc(sizeof(ConnBrDevice));
286 ASSERT_NE(nullptr, device);
287 (void)strcpy_s(device->addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
288 ret = g_connectFuncInterface->PostBytes(connectionId, data2, 3, pid, flag, MODULE_BLE_CONN, seq);
289 EXPECT_EQ(SOFTBUS_CONN_BR_CONNECTION_NOT_EXIST_ERR, ret);
290
291 uint8_t *data3 = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
292 ASSERT_NE(nullptr, data3);
293 (void)memset_s(data3, sizeof(uint8_t), 0, sizeof(uint8_t));
294 ConnBrConnection *connection = ConnBrCreateConnection(device->addr, CONN_SIDE_CLIENT, INVALID_SOCKET_HANDLE);
295 ConnBrSaveConnection(connection);
296 ret = g_connectFuncInterface->PostBytes(connection->connectionId, data3, 3, pid, flag, MODULE_BLE_CONN, seq);
297 EXPECT_EQ(SOFTBUS_CONN_BR_CONNECTION_NOT_READY_ERR, ret);
298
299 uint8_t *data4 = (uint8_t *)SoftBusCalloc(sizeof(uint8_t));
300 ASSERT_NE(nullptr, data4);
301 (void)memset_s(data4, sizeof(uint8_t), 0, sizeof(uint8_t));
302 EXPECT_CALL(brMock, ConnBrEnqueueNonBlock).WillOnce(Return(SOFTBUS_OK));
303 ret = g_connectFuncInterface->PostBytes(connection->connectionId, data4, 3, pid, flag, MODULE_CONNECTION, seq);
304 EXPECT_EQ(SOFTBUS_OK, ret);
305 }
306
307 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest005, TestSize.Level1)
308 {
309 CONN_LOGI(CONN_BR, "ConnInitBr5, Start");
310
311 ConnBrDevice *device = (ConnBrDevice *)SoftBusCalloc(sizeof(ConnBrDevice));
312 ASSERT_NE(nullptr, device);
313 (void)strcpy_s(device->addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
314
315 NiceMock<ConnectionBrInterfaceMock> brMock;
316 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
317
318 g_connectFuncInterface = ConnInit();
319 ConnBrConnection *connection = ConnBrCreateConnection(device->addr, CONN_SIDE_CLIENT, INVALID_SOCKET_HANDLE);
320 ConnBrSaveConnection(connection);
321 int32_t ret = g_connectFuncInterface->DisconnectDevice(connection->connectionId);
322 EXPECT_EQ(SOFTBUS_OK, ret);
323 }
324
325 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest006, TestSize.Level1)
326 {
327 CONN_LOGI(CONN_BR, "ConnInitBr6, Start");
328
329 ConnectOption *option = (ConnectOption *)SoftBusCalloc(sizeof(ConnectOption));
330 ASSERT_NE(nullptr, option);
331 option->type = CONNECT_BR;
332 option->brOption.sideType = CONN_SIDE_ANY;
333 (void)strcpy_s(option->brOption.brMac, BT_MAC_LEN, "24:DA:33:6A:06:EC");
334 ConnBrDevice *device = (ConnBrDevice *)SoftBusCalloc(sizeof(ConnBrDevice));
335 ASSERT_NE(nullptr, device);
336 (void)strcpy_s(device->addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
337
338 NiceMock<ConnectionBrInterfaceMock> brMock;
339 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
340
341 g_connectFuncInterface = ConnInit();
342 ConnBrConnection *connection = ConnBrCreateConnection(device->addr, CONN_SIDE_CLIENT, INVALID_SOCKET_HANDLE);
343 ConnBrSaveConnection(connection);
344 int32_t ret = g_connectFuncInterface->DisconnectDeviceNow(option);
345 EXPECT_EQ(SOFTBUS_OK, ret);
346 }
347
348 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest007, TestSize.Level1)
349 {
350 CONN_LOGI(CONN_BR, "ConnInitBr7, Start");
351
352 ConnBrDevice *device = (ConnBrDevice *)SoftBusCalloc(sizeof(ConnBrDevice));
353 ASSERT_NE(nullptr, device);
354 (void)strcpy_s(device->addr, BT_MAC_LEN, "24:DA:33:6A:06:EC");
355 ConnectionInfo *info = (ConnectionInfo *)SoftBusCalloc(sizeof(ConnectionInfo));
356 ASSERT_NE(nullptr, info);
357 (void)strcpy_s(info->brInfo.brMac, BT_MAC_LEN, "24:DA:33:6A:06:EC");
358
359 NiceMock<ConnectionBrInterfaceMock> brMock;
360 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
361
362 g_connectFuncInterface = ConnInit();
363 ConnBrConnection *connection = ConnBrCreateConnection(device->addr, CONN_SIDE_CLIENT, INVALID_SOCKET_HANDLE);
364 ConnBrSaveConnection(connection);
365 int32_t ret = g_connectFuncInterface->GetConnectionInfo(connection->connectionId, info);
366 EXPECT_EQ(SOFTBUS_OK, ret);
367 }
368
369 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest008, TestSize.Level1)
370 {
371 CONN_LOGI(CONN_BR, "ConnInitBr8, Start");
372
373 NiceMock<ConnectionBrInterfaceMock> brMock;
374 LocalListenerInfo *info = (LocalListenerInfo *)SoftBusCalloc(sizeof(LocalListenerInfo));
375 ASSERT_NE(nullptr, info);
376 info->type = CONNECT_BR;
377 EXPECT_CALL(brMock, SoftBusThreadCreate).WillOnce(Return(SOFTBUS_INVALID_PARAM));
378 int32_t ret = g_connectFuncInterface->StartLocalListening(info);
379 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
380
381 EXPECT_CALL(brMock, SoftBusThreadCreate).WillOnce(Return(SOFTBUS_OK));
382 ret = g_connectFuncInterface->StartLocalListening(info);
383 EXPECT_EQ(SOFTBUS_OK, ret);
384
385 ret = g_connectFuncInterface->StopLocalListening(info);
386 EXPECT_EQ(SOFTBUS_OK, ret);
387 }
388
389 HWTEST_F(ConnectionBrConnectionTest, BrManagerTest009, TestSize.Level1)
390 {
391 CONN_LOGI(CONN_BR, "ConnInitBr9, Start");
392
393 ConnectOption *option = (ConnectOption *)SoftBusCalloc(sizeof(ConnectOption));
394 ASSERT_NE(nullptr, option);
395 option->type = CONNECT_BR;
396 option->brOption.sideType = CONN_SIDE_ANY;
397 (void)strcpy_s(option->brOption.brMac, BT_MAC_LEN, "24:DA:33:6A:06:EC");
398 uint32_t time = 1;
399
400 NiceMock<ConnectionBrInterfaceMock> brMock;
401 EXPECT_CALL(brMock, SoftBusThreadCreate).WillRepeatedly(Return(SOFTBUS_OK));
402
403 int32_t ret = g_connectFuncInterface->PreventConnection(option, time);
404 EXPECT_EQ(SOFTBUS_OK, ret);
405 }
406
407 HWTEST_F(ConnectionBrConnectionTest, ConnBrTransReadOneFrame, TestSize.Level1)
408 {
409 LimitedBuffer buffer = {
410 .length = sizeof(ConnPktHead) - 1,
411 .capacity = 0,
412 };
413
414 ConnPktHead head = {0};
415 head.magic = MAGIC_NUMBER + 1;
416 head.len = sizeof(ConnPktHead);
417 buffer.buffer = (uint8_t *)(&head);
418
419 uint8_t *outData = nullptr;
420 uint32_t connectionId = 1;
421 int32_t socketHandle = 1;
422 int32_t ret = ConnBrTransReadOneFrame(connectionId, socketHandle, &buffer, &outData);
423 EXPECT_EQ(SOFTBUS_CONN_BR_UNDERLAY_SOCKET_CLOSED, ret);
424 }
425
426 HWTEST_F(ConnectionBrConnectionTest, BrTransSend, TestSize.Level1)
427 {
428 uint32_t connectionId = 1;
429 int32_t socketHandle = 1;
430 uint8_t data = {0};
431 int32_t ret = BrTransSend(connectionId, socketHandle, 0, &data, 0);
432 EXPECT_EQ(SOFTBUS_OK, ret);
433 }
434
435 HWTEST_F(ConnectionBrConnectionTest, ConnBrTransConfigPostLimit, TestSize.Level1)
436 {
437 LimitConfiguration configuration = {
438 .type = CONNECT_BR,
439 .active = true,
440 .windowInMillis = 1,
441 .quotaInBytes = 0,
442 };
443 int32_t ret = ConnBrTransConfigPostLimit(&configuration);
444 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
445 configuration.active = false;
446 ret = ConnBrTransConfigPostLimit(&configuration);
447 EXPECT_EQ(SOFTBUS_OK, ret);
448 }
449 }