1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdio>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21
22 #include "common_list.h"
23 #include "message_handler.h"
24 #include "conn_log.h"
25 #include "softbus_conn_interface.h"
26 #include "softbus_conn_manager.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30
31 static const uint32_t CONN_HEAD_SIZE = 24;
32 static const char *TEST_BLE_MAC = "11:22:33:44:55:66";
33
34 static unsigned int g_connId = 0;
35 static unsigned int g_secondConnId = 0;
36
37 #define WAIT_CONNECTION_COUNT 8
38 #define WAIT_CONNECTION_SLEEP_TIME 1
39
40 using namespace testing::ext;
41
42 namespace OHOS {
ConnectedCB(unsigned int connectionId,const ConnectionInfo * info)43 void ConnectedCB(unsigned int connectionId, const ConnectionInfo *info)
44 {
45 if (info->type == CONNECT_BLE) {
46 g_connId = connectionId;
47 }
48 return;
49 }
50
DisConnectCB(unsigned int connectionId,const ConnectionInfo * info)51 void DisConnectCB(unsigned int connectionId, const ConnectionInfo *info)
52 {
53 return;
54 }
55
DataReceivedCB(unsigned int connectionId,ConnModule moduleId,int64_t seq,char * data,int len)56 void DataReceivedCB(unsigned int connectionId, ConnModule moduleId, int64_t seq, char *data, int len)
57 {
58 return;
59 }
60
ConnectSuccessedCB(unsigned int requestId,unsigned int connectionId,const ConnectionInfo * info)61 void ConnectSuccessedCB(unsigned int requestId, unsigned int connectionId, const ConnectionInfo *info)
62 {
63 g_connId = connectionId;
64 return;
65 }
66
SecondConnectSuccessedCB(unsigned int requestId,unsigned int connectionId,const ConnectionInfo * info)67 void SecondConnectSuccessedCB(unsigned int requestId, unsigned int connectionId, const ConnectionInfo *info)
68 {
69 g_secondConnId = connectionId;
70 return;
71 }
72
ConnectFailedCB(unsigned int requestId,int reason)73 void ConnectFailedCB(unsigned int requestId, int reason)
74 {
75 return;
76 }
77
78 class ConnectionBleSwitchTest : public testing::Test {
79 public:
ConnectionBleSwitchTest()80 ConnectionBleSwitchTest()
81 {}
~ConnectionBleSwitchTest()82 ~ConnectionBleSwitchTest()
83 {}
84 static void SetUpTestCase(void);
85 static void TearDownTestCase(void);
86 void SetUp();
87 void TearDown();
88 };
89
SetUpTestCase(void)90 void ConnectionBleSwitchTest::SetUpTestCase(void)
91 {
92 LooperInit();
93 SoftbusConfigInit();
94 ConnServerInit();
95 }
96
TearDownTestCase(void)97 void ConnectionBleSwitchTest::TearDownTestCase(void)
98 {
99 LooperDeinit();
100 }
101
SetUp(void)102 void ConnectionBleSwitchTest::SetUp(void)
103 {}
104
TearDown(void)105 void ConnectionBleSwitchTest::TearDown(void)
106 {}
107
108 /*
109 * @tc.name: testConnmanger001
110 * @tc.desc: test set unset callback and connect post disconnect
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(ConnectionBleSwitchTest, testConnmanger001, TestSize.Level1)
115 {
116 int32_t ret;
117 int reqId;
118 ConnectCallback connCb;
119 ConnectResult connRet;
120 ConnPostData data;
121 ConnectOption info;
122 const char *str = "send msg local2\r\n";
123 connCb.OnConnected = ConnectedCB;
124 connCb.OnDisconnected = DisConnectCB;
125 connCb.OnDataReceived = DataReceivedCB;
126 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
127 EXPECT_EQ(SOFTBUS_OK, ret);
128 info.type = CONNECT_BLE;
129 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
130 connRet.OnConnectFailed = ConnectFailedCB;
131 connRet.OnConnectSuccessed = ConnectSuccessedCB;
132 reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
133 ret = ConnConnectDevice(&info, reqId, &connRet);
134 EXPECT_EQ(SOFTBUS_OK, ret);
135 if (g_connId != 0) {
136 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
137 ASSERT_TRUE(data.buf != NULL);
138 (void)strcpy_s(data.buf + 1, strlen(str), str);
139 data.len = CONN_HEAD_SIZE + 20;
140 data.module = MODULE_TRUST_ENGINE;
141 data.pid = 0;
142 data.flag = 1;
143 data.seq = 1;
144 ret = ConnPostBytes(g_connId, &data);
145 EXPECT_EQ(SOFTBUS_OK, ret);
146 if (data.buf != nullptr) {
147 free(data.buf);
148 }
149 ret = ConnDisconnectDevice(g_connId);
150 EXPECT_EQ(SOFTBUS_OK, ret);
151 }
152
153 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
154 g_connId = 0;
155 };
156
157 /*
158 * @tc.name: testConnmanger002
159 * @tc.desc: Test set unset callback and connect post disconnectAll.
160 * @tc.in: Test module, Test number,Test Levels.
161 * @tc.out: Zero
162 * @tc.type: FUNC
163 * @tc.require: The ConnSetConnectCallback and ConnGetConnectionInfo and ConnDisconnectDeviceAllConn operates normally.
164 */
165 HWTEST_F(ConnectionBleSwitchTest, testConnmanger002, TestSize.Level1)
166 {
167 int reqId = 1;
168 int32_t ret;
169 ConnectCallback connCb;
170 ConnectOption optionInfo;
171 ConnectionInfo info;
172 ConnectResult connRet;
173
174 connCb.OnConnected = ConnectedCB;
175 connCb.OnDisconnected = DisConnectCB;
176 connCb.OnDataReceived = DataReceivedCB;
177 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
178 EXPECT_EQ(SOFTBUS_OK, ret);
179
180 optionInfo.type = CONNECT_BLE;
181 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
182 connRet.OnConnectFailed = ConnectFailedCB;
183 connRet.OnConnectSuccessed = ConnectSuccessedCB;
184 reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
185 ret = ConnConnectDevice(&optionInfo, reqId, &connRet);
186 EXPECT_EQ(SOFTBUS_OK, ret);
187 if (g_connId) {
188 ret = ConnGetConnectionInfo(g_connId, &info);
189 EXPECT_EQ(SOFTBUS_OK, ret);
190 ret = ConnDisconnectDeviceAllConn(&optionInfo);
191 g_connId = 0;
192 EXPECT_EQ(SOFTBUS_OK, ret);
193 }
194 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
195 };
196
197 /*
198 * @tc.name: testConnmanger003
199 * @tc.desc: Test set unset callback and connect post disconnect post.
200 * @tc.in: Test module, Test number,Test Levels.
201 * @tc.out: Zero
202 * @tc.type: FUNC
203 * @tc.require: The ConnSetConnectCallback and ConnPostBytes operates normally.
204 */
205 HWTEST_F(ConnectionBleSwitchTest, testConnmanger003, TestSize.Level1)
206 {
207 int32_t ret;
208 int reqId;
209 ConnectCallback connCb;
210 ConnectResult connRet;
211 ConnPostData data;
212 ConnectOption info;
213 const char *str = "send msg local2\r\n";
214
215 connCb.OnConnected = ConnectedCB;
216 connCb.OnDisconnected = DisConnectCB;
217 connCb.OnDataReceived = DataReceivedCB;
218 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
219 EXPECT_EQ(SOFTBUS_OK, ret);
220 info.type = CONNECT_BLE;
221 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
222 connRet.OnConnectFailed = ConnectFailedCB;
223 connRet.OnConnectSuccessed = ConnectSuccessedCB;
224 reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
225 ret = ConnConnectDevice(&info, reqId, &connRet);
226
227 EXPECT_EQ(SOFTBUS_OK, ret);
228 if (g_connId != 0) {
229 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
230 ASSERT_TRUE(data.buf != NULL);
231 (void)strcpy_s(data.buf + 1, strlen(str), str);
232 data.len = CONN_HEAD_SIZE + 20;
233 data.module = MODULE_TRUST_ENGINE;
234 data.pid = 0;
235 data.flag = 1;
236 data.seq = 1;
237 ret = ConnPostBytes(g_connId, &data);
238 EXPECT_EQ(SOFTBUS_OK, ret);
239
240 ret = ConnDisconnectDevice(g_connId);
241 EXPECT_EQ(SOFTBUS_OK, ret);
242
243 ret = ConnPostBytes(g_connId, &data);
244 ASSERT_NE(SOFTBUS_OK, ret);
245 if (data.buf != nullptr) {
246 free(data.buf);
247 }
248 }
249 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
250 g_connId = 0;
251 };
252
253 /*
254 * @tc.name: testConnmanger004
255 * @tc.desc: Test set unset callback and connect twice has same ConnectID.
256 * @tc.in: Test module, Test number, Test Levels.
257 * @tc.out: Zero
258 * @tc.type: FUNC
259 * @tc.require:The ConnSetConnectCallback and ConnConnectDevice operates normally.
260 */
261 HWTEST_F(ConnectionBleSwitchTest, testConnmanger004, TestSize.Level1)
262 {
263 int32_t ret;
264 ConnectCallback connCb;
265 ConnectOption optionInfo;
266 ConnectionInfo info;
267 ConnectResult connRet;
268 ConnectResult connRet2;
269
270 connCb.OnConnected = ConnectedCB;
271 connCb.OnDisconnected = DisConnectCB;
272 connCb.OnDataReceived = DataReceivedCB;
273 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
274 EXPECT_EQ(SOFTBUS_OK, ret);
275
276 optionInfo.type = CONNECT_BLE;
277 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
278 connRet.OnConnectFailed = ConnectFailedCB;
279 connRet.OnConnectSuccessed = ConnectSuccessedCB;
280 int reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
281 ret = ConnConnectDevice(&optionInfo, reqId, &connRet);
282
283 connRet2.OnConnectFailed = ConnectFailedCB;
284 connRet2.OnConnectSuccessed = SecondConnectSuccessedCB;
285 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
286 ret = ConnConnectDevice(&optionInfo, reqId2, &connRet2);
287 EXPECT_EQ(SOFTBUS_OK, ret);
288 sleep(1);
289 if ((g_connId) && (g_secondConnId)) {
290 EXPECT_EQ(g_connId, g_secondConnId);
291 }
292
293 if (g_connId) {
294 ret = ConnGetConnectionInfo(g_connId, &info);
295 EXPECT_EQ(SOFTBUS_OK, ret);
296 ret = ConnDisconnectDeviceAllConn(&optionInfo);
297 g_connId = 0;
298 EXPECT_EQ(SOFTBUS_OK, ret);
299 }
300 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
301 };
302
303 /*
304 * @tc.name: testConnmanger005
305 * @tc.desc: Test set unset callback and connect twice post disconnect post.
306 * @tc.in: Test module, Test number, Test Levels.
307 * @tc.out: Zero
308 * @tc.type: FUNC
309 * @tc.require: The ConnSetConnectCallback and ConnPostBytes operates normally.
310 */
311 HWTEST_F(ConnectionBleSwitchTest, testConnmanger005, TestSize.Level1)
312 {
313 int32_t ret;
314 ConnectCallback connCb;
315 ConnectResult connRet;
316 ConnPostData data;
317 ConnectOption info;
318 const char *str = "send msg local2\r\n";
319
320 connCb.OnConnected = ConnectedCB;
321 connCb.OnDisconnected = DisConnectCB;
322 connCb.OnDataReceived = DataReceivedCB;
323 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
324 EXPECT_EQ(SOFTBUS_OK, ret);
325 info.type = CONNECT_BLE;
326 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
327 connRet.OnConnectFailed = ConnectFailedCB;
328 connRet.OnConnectSuccessed = ConnectSuccessedCB;
329 int reqId1 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
330 ret = ConnConnectDevice(&info, reqId1, &connRet);
331 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
332 ret = ConnConnectDevice(&info, reqId2, &connRet);
333 EXPECT_EQ(SOFTBUS_OK, ret);
334 if (g_connId != 0) {
335 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
336 ASSERT_TRUE(data.buf != NULL);
337 (void)strcpy_s(data.buf + 1, strlen(str), str);
338 data.len = CONN_HEAD_SIZE + 20;
339 data.module = MODULE_TRUST_ENGINE;
340 data.pid = 0;
341 data.flag = 1;
342 data.seq = 1;
343 ret = ConnPostBytes(g_connId, &data);
344 EXPECT_EQ(SOFTBUS_OK, ret);
345
346 ret = ConnDisconnectDevice(g_connId);
347 EXPECT_EQ(SOFTBUS_OK, ret);
348
349 ret = ConnPostBytes(g_connId, &data);
350 ASSERT_EQ(SOFTBUS_OK, ret);
351 if (data.buf != nullptr) {
352 free(data.buf);
353 }
354 }
355 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
356 g_connId = 0;
357 };
358
359 /*
360 * @tc.name: testConnmanger006
361 * @tc.desc: Test set unset callback and connect twice post disconnectAll post.
362 * @tc.in: Test module, Test number, Test Levels.
363 * @tc.out: Zero
364 * @tc.type: FUNC
365 * @tc.require: The ConnSetConnectCallback and ConnPostBytes and ConnDisconnectDeviceAllConn operates normally.
366 */
367 HWTEST_F(ConnectionBleSwitchTest, testConnmanger006, TestSize.Level1)
368 {
369 int32_t ret;
370 ConnectCallback connCb;
371 ConnectResult connRet;
372 ConnPostData data;
373 ConnectOption info;
374 const char *str = "send msg local2\r\n";
375
376 connCb.OnConnected = ConnectedCB;
377 connCb.OnDisconnected = DisConnectCB;
378 connCb.OnDataReceived = DataReceivedCB;
379 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
380 EXPECT_EQ(SOFTBUS_OK, ret);
381 info.type = CONNECT_BLE;
382 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
383 connRet.OnConnectFailed = ConnectFailedCB;
384 connRet.OnConnectSuccessed = ConnectSuccessedCB;
385
386 int reqId1 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
387 ret = ConnConnectDevice(&info, reqId1, &connRet);
388 EXPECT_EQ(SOFTBUS_OK, ret);
389 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
390 ret = ConnConnectDevice(&info, reqId2, &connRet);
391 EXPECT_EQ(SOFTBUS_OK, ret);
392
393 if (g_connId != 0) {
394 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
395 ASSERT_TRUE(data.buf != NULL);
396 (void)strcpy_s(data.buf + 1, strlen(str), str);
397 data.len = CONN_HEAD_SIZE + 20;
398 data.module = MODULE_TRUST_ENGINE;
399 data.pid = 0;
400 data.flag = 1;
401 data.seq = 1;
402
403 ret = ConnPostBytes(g_connId, &data);
404 ASSERT_EQ(SOFTBUS_OK, ret);
405 ret = ConnDisconnectDeviceAllConn(&info);
406 EXPECT_EQ(SOFTBUS_OK, ret);
407 ret = ConnPostBytes(g_connId, &data);
408 ASSERT_NE(SOFTBUS_OK, ret);
409
410 g_connId = 0;
411 if (data.buf != nullptr) {
412 free(data.buf);
413 }
414 }
415 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
416 };
417
418 /*
419 * @tc.name: testConnmanger007
420 * @tc.desc: Test whether the result of obtaining the request id multiple times is the same.
421 * @tc.in: Test module, Test number, Test Levels.
422 * @tc.out: Zero
423 * @tc.type: FUNC
424 * @tc.require: The ConnGetNewRequestId operates normally.
425 */
426 HWTEST_F(ConnectionBleSwitchTest, testConnmanger007, TestSize.Level1)
427 {
428 int req1 = 1, req2 = 1;
429 int32_t ret;
430 ConnectCallback connCb;
431 ConnectOption optionInfo;
432 ConnectionInfo info;
433 ConnectResult connRet;
434
435 connCb.OnConnected = ConnectedCB;
436 connCb.OnDisconnected = DisConnectCB;
437 connCb.OnDataReceived = DataReceivedCB;
438 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
439 EXPECT_EQ(SOFTBUS_OK, ret);
440
441 optionInfo.type = CONNECT_BLE;
442 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
443 connRet.OnConnectFailed = ConnectFailedCB;
444 connRet.OnConnectSuccessed = ConnectSuccessedCB;
445 req1 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
446 req2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
447 ASSERT_LT(req1, req2);
448 ret = ConnConnectDevice(&optionInfo, req1, &connRet);
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 if (g_connId) {
451 ret = ConnGetConnectionInfo(g_connId, &info);
452 EXPECT_EQ(SOFTBUS_OK, ret);
453 ret = ConnDisconnectDeviceAllConn(&optionInfo);
454 g_connId = 0;
455 EXPECT_EQ(SOFTBUS_OK, ret);
456 }
457 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
458 };
459
460 /*
461 * @tc.name: testConnmanger008
462 * @tc.desc: Test connect post disconnect post and multiple tests connsetconnectcallback and conndisconnectdevice.
463 * @tc.in: Test module, Test number, Test Levels.
464 * @tc.out: Zero
465 * @tc.type: FUNC
466 * @tc.require: The ConnSetConnectCallback and ConnPostBytes operates normally.
467 */
468 HWTEST_F(ConnectionBleSwitchTest, testConnmanger008, TestSize.Level1)
469 {
470 int32_t ret;
471 int reqId;
472 ConnectCallback connCb;
473 ConnectResult connRet;
474 ConnPostData data;
475 ConnectOption info;
476 const char *str = "send msg local2\r\n";
477
478 connCb.OnConnected = ConnectedCB;
479 connCb.OnDisconnected = DisConnectCB;
480 connCb.OnDataReceived = DataReceivedCB;
481 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
482 EXPECT_EQ(SOFTBUS_OK, ret);
483 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
484 EXPECT_EQ(SOFTBUS_CONN_INTERNAL_ERR, ret);
485 info.type = CONNECT_BLE;
486 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
487 connRet.OnConnectFailed = ConnectFailedCB;
488 connRet.OnConnectSuccessed = ConnectSuccessedCB;
489 reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
490 ret = ConnConnectDevice(&info, reqId, &connRet);
491
492 EXPECT_EQ(SOFTBUS_OK, ret);
493 if (g_connId != 0) {
494 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
495 ASSERT_TRUE(data.buf != NULL);
496 (void)strcpy_s(data.buf + 1, strlen(str), str);
497 data.len = CONN_HEAD_SIZE + 20;
498 data.module = MODULE_TRUST_ENGINE;
499 data.pid = 0;
500 data.flag = 1;
501 data.seq = 1;
502 ret = ConnPostBytes(g_connId, &data);
503 EXPECT_EQ(SOFTBUS_OK, ret);
504
505 ret = ConnDisconnectDevice(g_connId);
506 EXPECT_EQ(SOFTBUS_OK, ret);
507 ret = ConnDisconnectDevice(g_connId);
508 EXPECT_EQ(SOFTBUS_OK, ret);
509
510 ret = ConnPostBytes(g_connId, &data);
511 ASSERT_NE(SOFTBUS_OK, ret);
512 if (data.buf != nullptr) {
513 free(data.buf);
514 }
515 }
516 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
517 g_connId = 0;
518 };
519
520 /*
521 * @tc.name: testConnmanger009
522 * @tc.desc: Test Set ConnSetConnectCallback and connect twice has same ConnectID multiple times.
523 * @tc.in: Test module, Test number, Test Levels.
524 * @tc.out: Zero
525 * @tc.type: FUNC
526 * @tc.require: The ConnConnectDevice operates normally.
527 */
528 HWTEST_F(ConnectionBleSwitchTest, testConnmanger009, TestSize.Level1)
529 {
530 int32_t ret;
531 ConnectCallback connCb;
532 ConnectOption optionInfo;
533 ConnectionInfo info;
534 ConnectResult connRet;
535 ConnectResult connRet2;
536
537 connCb.OnConnected = ConnectedCB;
538 connCb.OnDisconnected = DisConnectCB;
539 connCb.OnDataReceived = DataReceivedCB;
540 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
541 EXPECT_EQ(SOFTBUS_OK, ret);
542 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
543 EXPECT_EQ(SOFTBUS_CONN_INTERNAL_ERR, ret);
544 optionInfo.type = CONNECT_BLE;
545 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
546 connRet.OnConnectFailed = ConnectFailedCB;
547 connRet.OnConnectSuccessed = ConnectSuccessedCB;
548 int reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
549 ret = ConnConnectDevice(&optionInfo, reqId, &connRet);
550
551 connRet2.OnConnectFailed = ConnectFailedCB;
552 connRet2.OnConnectSuccessed = ConnectSuccessedCB;
553 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
554 ret = ConnConnectDevice(&optionInfo, reqId2, &connRet2);
555 EXPECT_EQ(SOFTBUS_OK, ret);
556 sleep(1);
557 if ((g_connId) && (g_secondConnId)) {
558 EXPECT_EQ(g_connId, g_secondConnId);
559 }
560
561 if (g_connId) {
562 ret = ConnGetConnectionInfo(g_connId, &info);
563 EXPECT_EQ(SOFTBUS_OK, ret);
564 ret = ConnDisconnectDeviceAllConn(&optionInfo);
565 g_connId = 0;
566 EXPECT_EQ(SOFTBUS_OK, ret);
567 }
568 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
569 };
570
571 /*
572 * @tc.name: testConnmanger010
573 * @tc.desc: Test set unset callback and connect many times post disconnect post.
574 * @tc.in: Test module, Test number, Test Levels.
575 * @tc.out: Zero
576 * @tc.type: FUNC
577 * @tc.require: The ConnSetConnectCallback and ConnPostBytes operates normally.
578 */
579 HWTEST_F(ConnectionBleSwitchTest, testConnmanger010, TestSize.Level1)
580 {
581 int32_t ret;
582 ConnectCallback connCb;
583 ConnectResult connRet;
584 ConnPostData data;
585 ConnectOption info;
586 const char *str = "send msg local2\r\n";
587
588 connCb.OnConnected = ConnectedCB;
589 connCb.OnDisconnected = DisConnectCB;
590 connCb.OnDataReceived = DataReceivedCB;
591 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
592 EXPECT_EQ(SOFTBUS_OK, ret);
593 info.type = CONNECT_BLE;
594 (void)memcpy_s(info.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
595 connRet.OnConnectFailed = ConnectFailedCB;
596 connRet.OnConnectSuccessed = ConnectSuccessedCB;
597 int reqId1 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
598 ret = ConnConnectDevice(&info, reqId1, &connRet);
599 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
600 ret = ConnConnectDevice(&info, reqId2, &connRet);
601 EXPECT_EQ(SOFTBUS_OK, ret);
602 if (g_connId != 0) {
603 data.buf = (char *)calloc(1, CONN_HEAD_SIZE + 20);
604 ASSERT_TRUE(data.buf != NULL);
605 (void)strcpy_s(data.buf + 1, strlen(str), str);
606 data.len = CONN_HEAD_SIZE + 20;
607 data.module = MODULE_TRUST_ENGINE;
608 data.pid = 0;
609 data.flag = 1;
610 data.seq = 1;
611 ret = ConnPostBytes(g_connId, &data);
612 EXPECT_EQ(SOFTBUS_OK, ret);
613 ret = ConnPostBytes(g_connId, &data);
614 EXPECT_EQ(SOFTBUS_OK, ret);
615
616 ret = ConnDisconnectDevice(g_connId);
617 EXPECT_EQ(SOFTBUS_OK, ret);
618
619 ret = ConnPostBytes(g_connId, &data);
620 ASSERT_EQ(SOFTBUS_OK, ret);
621 if (data.buf != nullptr) {
622 free(data.buf);
623 }
624 ret = ConnPostBytes(g_connId, &data);
625 ASSERT_EQ(SOFTBUS_OK, ret);
626 if (data.buf != nullptr) {
627 free(data.buf);
628 }
629 }
630 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
631 g_connId = 0;
632 };
633
634 /*
635 * @tc.name: testConnmanger0011
636 * @tc.desc: Test set unset callback and connect twice has same ConnectID and update connection.
637 * @tc.in: Test module, Test number, Test Levels.
638 * @tc.out: Zero
639 * @tc.type: FUNC
640 * @tc.require:The ConnUpdateConnection operates normally.
641 */
642 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0011, TestSize.Level1)
643 {
644 int32_t ret;
645 ConnectCallback connCb;
646 ConnectOption optionInfo;
647 ConnectResult connRet;
648 ConnectResult connRet2;
649 UpdateOption option;
650
651 connCb.OnConnected = ConnectedCB;
652 connCb.OnDisconnected = DisConnectCB;
653 connCb.OnDataReceived = DataReceivedCB;
654 ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
655 EXPECT_EQ(SOFTBUS_OK, ret);
656
657 optionInfo.type = CONNECT_BLE;
658 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
659 connRet.OnConnectFailed = ConnectFailedCB;
660 connRet.OnConnectSuccessed = ConnectSuccessedCB;
661 int reqId = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
662 ret = ConnConnectDevice(&optionInfo, reqId, &connRet);
663
664 connRet2.OnConnectFailed = ConnectFailedCB;
665 connRet2.OnConnectSuccessed = SecondConnectSuccessedCB;
666 int reqId2 = ConnGetNewRequestId(MODULE_TRUST_ENGINE);
667 ret = ConnConnectDevice(&optionInfo, reqId2, &connRet2);
668 EXPECT_EQ(SOFTBUS_OK, ret);
669 sleep(1);
670 if ((g_connId) && (g_secondConnId)) {
671 EXPECT_EQ(g_connId, g_secondConnId);
672 }
673
674 if (g_connId) {
675 option.type = CONNECT_BLE;
676 option.bleOption.priority = CONN_BLE_PRIORITY_BALANCED;
677 ret = ConnUpdateConnection(g_connId, &option);
678 EXPECT_EQ(SOFTBUS_OK, ret);
679 ret = ConnDisconnectDeviceAllConn(&optionInfo);
680 g_connId = 0;
681 EXPECT_EQ(SOFTBUS_OK, ret);
682 }
683 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
684 };
685
686 /*
687 * @tc.name: testConnmanger0012
688 * @tc.desc: check active ble connection.
689 * @tc.in: Test module, Test number, Test Levels.
690 * @tc.out: Zero
691 * @tc.type: FUNC
692 * @tc.require:
693 */
694 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0012, TestSize.Level1)
695 {
696 ConnectOption optionInfo;
697
698 optionInfo.type = CONNECT_BLE;
699 optionInfo.bleOption.protocol = BLE_GATT;
700 (void)memcpy_s(optionInfo.bleOption.bleMac, BT_MAC_LEN, TEST_BLE_MAC, BT_MAC_LEN);
701 bool isActive = CheckActiveConnection(&optionInfo, false);
702 EXPECT_TRUE(isActive == false);
703 };
704
705 /*
706 * @tc.name: ManagerTest001
707 * @tc.desc: test ConnTypeIsSupport
708 * @tc.type: FUNC
709 * @tc.require:
710 */
711 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0013, TestSize.Level1)
712 {
713 int32_t ret = ConnTypeIsSupport(CONNECT_BLE);
714 EXPECT_EQ(ret, SOFTBUS_OK);
715 }
716
717 /*
718 * @tc.name: ManagerTest002
719 * @tc.desc: test invalid param
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0014, TestSize.Level1)
724 {
725 int32_t ret = ConnSetConnectCallback(static_cast<ConnModule>(0), nullptr);
726 ASSERT_TRUE(ret != SOFTBUS_OK);
727 ret = ConnConnectDevice(nullptr, 0, nullptr);
728 ASSERT_TRUE(ret != SOFTBUS_OK);
729 ret = ConnDisconnectDevice(0);
730 ASSERT_TRUE(ret != SOFTBUS_OK);
731 ret = ConnPostBytes(0, nullptr);
732 ASSERT_TRUE(ret != SOFTBUS_OK);
733 ret = ConnStartLocalListening(nullptr);
734 ASSERT_TRUE(ret != SOFTBUS_OK);
735 ret = ConnStopLocalListening(nullptr);
736 ASSERT_TRUE(ret != SOFTBUS_OK);
737 }
738
739 /*
740 * @tc.name: ManagerTest003
741 * @tc.desc: test set unset callback and post disconnect without connect
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0015, TestSize.Level1)
746 {
747 ConnectCallback connCb;
748 connCb.OnConnected = ConnectedCB;
749 connCb.OnDisconnected = DisConnectCB;
750 connCb.OnDataReceived = DataReceivedCB;
751 int32_t ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
752 EXPECT_EQ(SOFTBUS_OK, ret);
753 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
754 g_connId = 0;
755 }
756
757 /*
758 * @tc.name: ManagerTest004
759 * @tc.desc: Test start stop listening.
760 * @tc.in: Test module, Test number,Test Levels.
761 * @tc.out: NonZero
762 * @tc.type: FUNC
763 * @tc.require: The ConnStartLocalListening and ConnStopLocalListening operates normally.
764 */
765 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0016, TestSize.Level1)
766 {
767 ConnectCallback connCb;
768 connCb.OnConnected = ConnectedCB;
769 connCb.OnDisconnected = DisConnectCB;
770 connCb.OnDataReceived = DataReceivedCB;
771 int32_t ret = ConnSetConnectCallback(MODULE_TRUST_ENGINE, &connCb);
772 EXPECT_EQ(ret, SOFTBUS_OK);
773
774 LocalListenerInfo info;
775 info.type = CONNECT_BLE;
776 ret = ConnStartLocalListening(&info);
777 EXPECT_EQ(ret, SOFTBUS_OK);
778 ret = ConnStopLocalListening(&info);
779 EXPECT_EQ(ret, SOFTBUS_OK);
780 ConnUnSetConnectCallback(MODULE_TRUST_ENGINE);
781 g_connId = 0;
782 }
783
784 /*
785 * @tc.name: ManagerTest005
786 * @tc.desc: Test ConnTypeIsSupport.
787 * @tc.in: Test module, Test number, Test Levels.
788 * @tc.out: NonZero
789 * @tc.type: FUNC
790 * @tc.require: The ConnTypeIsSupport operates normally.
791 */
792 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0017, TestSize.Level1)
793 {
794 int32_t ret = ConnTypeIsSupport(CONNECT_P2P);
795 EXPECT_EQ(SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT, ret);
796 }
797
798 /*
799 * @tc.name: ManagerTest006
800 * @tc.desc: Test ConnTypeIsSupport.
801 * @tc.in: Test module, Test number, Test Levels.
802 * @tc.out: Zero
803 * @tc.type: FUNC
804 * @tc.require: The ConnTypeIsSupport operates normally.
805 */
806 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0018, TestSize.Level1)
807 {
808 int32_t ret = ConnTypeIsSupport(CONNECT_BR);
809 EXPECT_EQ(SOFTBUS_OK, ret);
810 }
811
812 /*
813 * @tc.name: ManagerTest007
814 * @tc.desc: Test ConnTypeIsSupport.
815 * @tc.in: Test module, Test number, Test Levels.
816 * @tc.out: Zero
817 * @tc.type: FUNC
818 * @tc.require: The ConnTypeIsSupport operates normally.
819 */
820 HWTEST_F(ConnectionBleSwitchTest, testConnmanger0019, TestSize.Level1)
821 {
822 int32_t ret = ConnTypeIsSupport(CONNECT_TCP);
823 EXPECT_EQ(SOFTBUS_OK, ret);
824 }
825 }
826