1 /*
2 * Copyright (c) 2021-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 <arpa/inet.h>
17 #include <cerrno>
18 #include <cstdio>
19 #include <cstdlib>
20 #include <cstring>
21 #include <gtest/gtest.h>
22 #include <netinet/in.h>
23 #include <pthread.h>
24 #include <securec.h>
25 #include <sys/socket.h>
26 #include <sys/types.h>
27 #include <unistd.h>
28
29 #include "common_list.h"
30 #include "conn_log.h"
31 #include "softbus_adapter_mem.h"
32 #include "softbus_base_listener.h"
33 #include "softbus_conn_interface.h"
34 #include "softbus_conn_manager.h"
35 #include "softbus_def.h"
36 #include "softbus_errcode.h"
37 #include "softbus_feature_config.h"
38 #include "softbus_tcp_connect_manager.h"
39 #include "softbus_tcp_socket.h"
40 #include "softbus_utils.h"
41
42 #define CLIENTPORT 6666
43 #define SERVERPORT 6667
44 #define INVALID_FD (-100)
45 #define KEEPALIVE_IDLE 100
46 #define KEEPALIVE_IDLE_MAX 65535
47 #define KEEPALIVE_INTERVAL 2
48 #define KEEPALIVE_COUNT 5
49
50 static const int MAXLNE = 50;
51
52 using namespace testing::ext;
53
54 namespace OHOS {
55 const char *Ip = "127.0.0.1";
56 const char *Ipv6 = "::1%lo";
57 const char *g_data = "1234567890";
58
59 static uint32_t g_connectionId = 0;
60 static ConnectFuncInterface *g_interface = nullptr;
61 static ConnectResult g_result;
62 static ConnectCallback g_cb;
63 static int g_receivedDatalength = 0;
64 static int g_connServerInit = 0;
65
TcpOnConnected(uint32_t connectionId,const ConnectionInfo * info)66 void TcpOnConnected(uint32_t connectionId, const ConnectionInfo *info)
67 {
68 printf("TcpOnConnected %08x\n", connectionId);
69 }
70
TcpOnDisConnect(uint32_t connectionId,const ConnectionInfo * info)71 void TcpOnDisConnect(uint32_t connectionId, const ConnectionInfo *info)
72 {
73 printf("TcpOnDisConnect %08x\n", connectionId);
74 }
75
TcpDataReceived(uint32_t connectionId,ConnModule moduleId,int64_t seq,char * data,int length)76 void TcpDataReceived(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int length)
77 {
78 g_receivedDatalength = length;
79 printf("nDataReceived with length:%d\n", length);
80 }
81
TcpOnConnectionSuccessed(uint32_t requestId,uint32_t connectionId,const ConnectionInfo * info)82 void TcpOnConnectionSuccessed(uint32_t requestId, uint32_t connectionId, const ConnectionInfo *info)
83 {
84 g_connectionId = connectionId;
85 printf("OnConnectionEnabled with requestId:%u connectionId:%08x\n", requestId, connectionId);
86 }
87
TcpOnConnectionFailed(uint32_t requestId,int32_t reason)88 void TcpOnConnectionFailed(uint32_t requestId, int32_t reason)
89 {
90 printf("OnConnectionFailed with requestId:%u reason:%d\n", requestId, reason);
91 }
92
93 class TcpManagerTest : public testing::Test {
94 public:
TcpManagerTest()95 TcpManagerTest()
96 {}
~TcpManagerTest()97 ~TcpManagerTest()
98 {}
99 static void SetUpTestCase(void);
100 static void TearDownTestCase(void);
101 void SetUp();
102 void TearDown();
103 };
104
SetUpTestCase(void)105 void TcpManagerTest::SetUpTestCase(void)
106 {}
107
TearDownTestCase(void)108 void TcpManagerTest::TearDownTestCase(void)
109 {}
110
SetUp(void)111 void TcpManagerTest::SetUp(void)
112 {
113 g_cb.OnConnected = TcpOnConnected;
114 g_cb.OnDataReceived = TcpDataReceived;
115 g_cb.OnDisconnected = TcpOnDisConnect;
116 g_interface = ConnInitTcp(&g_cb);
117 g_result.OnConnectSuccessed = TcpOnConnectionSuccessed;
118 g_result.OnConnectFailed = TcpOnConnectionFailed;
119 g_connectionId = 0;
120 g_receivedDatalength = 0;
121 g_connServerInit = ConnServerInit();
122 }
123
TearDown(void)124 void TcpManagerTest::TearDown(void)
125 {
126 g_interface = nullptr;
127 g_connServerInit = 0;
128 }
129
CreateServer(void * arg)130 void CreateServer(void *arg)
131 {
132 int listenfd, connfd, n;
133 struct sockaddr_in servaddr;
134 char buff[MAXLNE];
135 unsigned int port = SERVERPORT;
136 int defaultListen = 5;
137
138 if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
139 printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
140 return;
141 }
142
143 (void)memset_s(&servaddr, sizeof(servaddr), 0, sizeof(servaddr));
144 servaddr.sin_family = AF_INET;
145 inet_pton(AF_INET, Ip, &servaddr.sin_addr);
146 servaddr.sin_port = htons(port);
147
148 if (bind(listenfd, reinterpret_cast<struct sockaddr *>(&servaddr), sizeof(servaddr)) == -1) {
149 close(listenfd);
150 printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
151 return;
152 }
153 if (listen(listenfd, defaultListen) == -1) {
154 close(listenfd);
155 printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
156 return;
157 }
158
159 while (true) {
160 if ((connfd = accept(listenfd, static_cast<struct sockaddr *>(nullptr), nullptr)) == -1) {
161 printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
162 continue;
163 }
164 break;
165 }
166
167 while (true) {
168 n = recv(connfd, buff, MAXLNE, 0);
169 if (n <= 0) {
170 break;
171 }
172 printf("recv msg with length:%d from client\n", n);
173 n = send(connfd, buff, static_cast<unsigned int>(n), 0);
174 printf("send msg with length:%d to client\n", n);
175 }
176 close(connfd);
177 close(listenfd);
178 }
179
180 /*
181 * @tc.name: testTcpManager002
182 * @tc.desc: test TcpConnectDevice with invalid param
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(TcpManagerTest, testTcpManager002, TestSize.Level1)
187 {
188 int port = CLIENTPORT;
189 uint32_t requestId = 1;
190 ConnectOption option;
191 option.type = CONNECT_BR;
192 option.socketOption.port = port;
193 option.socketOption.moduleId = PROXY;
194 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
195 int ret;
196 ret = TcpConnectDevice(nullptr, requestId, &g_result);
197 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
198 ret = TcpConnectDevice(&option, requestId, nullptr);
199 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
200 ret = TcpConnectDevice(&option, requestId, &g_result);
201 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
202 };
203
204 /*
205 * @tc.name: testTcpManager003
206 * @tc.desc: test TcpDisconnectDevice with wrong id
207 * @tc.type: FUNC
208 * @tc.require:
209 */
210 HWTEST_F(TcpManagerTest, testTcpManager003, TestSize.Level1)
211 {
212 EXPECT_EQ(SOFTBUS_CONN_SOCKET_INTERNAL_ERR, TcpDisconnectDevice(g_connectionId));
213 };
214
215 /*
216 * @tc.name: testTcpManager004
217 * @tc.desc: test TcpGetConnectionInfo with invalid param
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(TcpManagerTest, testTcpManager004, TestSize.Level1)
222 {
223 ConnectionInfo info = {};
224 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpGetConnectionInfo(g_connectionId, nullptr));
225 EXPECT_EQ(SOFTBUS_TCPCONNECTION_SOCKET_ERR, TcpGetConnectionInfo(g_connectionId, &info));
226 EXPECT_EQ(false, info.isAvailable);
227 };
228
229 /*
230 * @tc.name: testTcpManager005
231 * @tc.desc: Test the BR and TCP start and stop listeners multiple times.
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(TcpManagerTest, testTcpManager005, TestSize.Level1)
236 {
237 int port = CLIENTPORT;
238 LocalListenerInfo info = {};
239 info.type = CONNECT_BR;
240 info.socketOption.port = port;
241 info.socketOption.moduleId = PROXY;
242 info.socketOption.protocol = LNN_PROTOCOL_IP;
243 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
244 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
245 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
246 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
247
248 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ipv6);
249 info.type = CONNECT_TCP;
250 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
251 EXPECT_EQ(port, TcpStartListening(&info));
252 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
253 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
254 };
255
256 /*
257 * @tc.name: testTcpManager006
258 * @tc.desc: test TcpDisconnectDevice
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(TcpManagerTest, testTcpManager006, TestSize.Level1)
263 {
264 int port = CLIENTPORT;
265 LocalListenerInfo info = {};
266 info.type = CONNECT_TCP;
267 info.socketOption.port = port;
268 info.socketOption.protocol = LNN_PROTOCOL_IP;
269 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
270
271 uint32_t requestId = 1;
272 ConnectOption option;
273 option.type = CONNECT_TCP;
274 option.socketOption.port = port;
275 option.socketOption.moduleId = PROXY;
276 option.socketOption.protocol = LNN_PROTOCOL_IP;
277 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
278
279 EXPECT_EQ(port, TcpStartListening(&info));
280 EXPECT_EQ(SOFTBUS_OK, TcpConnectDevice(&option, requestId, &g_result));
281 sleep(1);
282 EXPECT_EQ(SOFTBUS_OK, TcpDisconnectDevice(g_connectionId));
283 sleep(1);
284 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
285 }
286
287 /*
288 * @tc.name: testTcpManager007
289 * @tc.desc: test post out of max length
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 HWTEST_F(TcpManagerTest, testTcpManager007, TestSize.Level1)
294 {
295 pthread_t pid;
296
297 int clientPort = CLIENTPORT;
298 int serverPort = SERVERPORT;
299 LocalListenerInfo info = {};
300 info.type = CONNECT_TCP;
301 info.socketOption.port = clientPort;
302 info.socketOption.protocol = LNN_PROTOCOL_IP;
303 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
304
305 uint32_t requestId = 1;
306 ConnectOption option = {};
307 option.type = CONNECT_TCP;
308 option.socketOption.port = serverPort;
309 option.socketOption.protocol = LNN_PROTOCOL_IP;
310 option.socketOption.moduleId = PROXY;
311 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
312
313 ConnPktHead head = {0};
314 head.len = strlen(g_data);
315
316 pthread_create(&pid, nullptr, (void *(*)(void *))CreateServer, nullptr);
317 sleep(1);
318 EXPECT_EQ(clientPort, TcpStartListening(&info));
319 EXPECT_EQ(SOFTBUS_OK, TcpConnectDevice(&option, requestId, &g_result));
320 sleep(1);
321 for (int32_t i = 0; i < 3; i++) {
322 char *data = (char *)SoftBusCalloc(sizeof(head) + head.len);
323 if (data == nullptr) {
324 continue;
325 }
326 (void)memcpy_s(data, sizeof(head), (void*)&head, sizeof(head));
327 (void)memcpy_s(data + sizeof(head), (unsigned int)head.len, g_data, (unsigned int)head.len);
328 EXPECT_EQ(SOFTBUS_OK,
329 TcpPostBytes(g_connectionId, (uint8_t *)data, sizeof(ConnPktHead) + head.len, 0, 0, 0, 0));
330 sleep(1);
331 EXPECT_EQ(int(sizeof(ConnPktHead) + head.len), g_receivedDatalength);
332 g_receivedDatalength = 0;
333 }
334 EXPECT_EQ(SOFTBUS_OK, TcpDisconnectDevice(g_connectionId));
335 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
336 pthread_join(pid, nullptr);
337 }
338
339 /*
340 * @tc.name: testTcpManager008
341 * @tc.desc: test connect out of max connect num
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 HWTEST_F(TcpManagerTest, testTcpManager008, TestSize.Level1)
346 {
347 int port = CLIENTPORT;
348 LocalListenerInfo info = {};
349 info.type = CONNECT_TCP;
350 info.socketOption.port = port;
351 info.socketOption.protocol = LNN_PROTOCOL_IP;
352 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
353
354 uint32_t requestId = 1;
355 ConnectOption option;
356 option.type = CONNECT_TCP;
357 option.socketOption.port = port;
358 option.socketOption.moduleId = PROXY;
359 option.socketOption.protocol = LNN_PROTOCOL_IP;
360 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
361
362 int32_t maxConnNum;
363 int32_t i = 0;
364 if (SoftbusGetConfig(SOFTBUS_INT_CONN_TCP_MAX_CONN_NUM,
365 (unsigned char*)&maxConnNum, sizeof(maxConnNum)) != SOFTBUS_OK) {
366 CONN_LOGE(CONN_TEST, "get maxConnNum fail");
367 }
368 printf("maxConnNum: %d\n", maxConnNum);
369 EXPECT_EQ(port, TcpStartListening(&info));
370 while (i < maxConnNum) {
371 EXPECT_EQ(SOFTBUS_OK, TcpConnectDevice(&option, requestId, &g_result));
372 sleep(1);
373 i += 2;
374 }
375 EXPECT_TRUE(SOFTBUS_OK != TcpConnectDevice(&option, requestId, &g_result));
376 TcpDisconnectDeviceNow(&option);
377 sleep(1);
378 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
379 }
380
381 /*
382 * @tc.name: testTcpManager009
383 * @tc.desc: test connect and post to self
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(TcpManagerTest, testTcpManager009, TestSize.Level1)
388 {
389 int port = CLIENTPORT;
390 LocalListenerInfo info = {};
391 info.type = CONNECT_TCP;
392 info.socketOption.port = port;
393 info.socketOption.protocol = LNN_PROTOCOL_IP;
394 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
395
396 uint32_t requestId = 1;
397 ConnectOption option;
398 option.type = CONNECT_TCP;
399 option.socketOption.port = port;
400 option.socketOption.protocol = LNN_PROTOCOL_IP;
401 option.socketOption.moduleId = PROXY;
402 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
403
404 int maxDataLen;
405 if (SoftbusGetConfig(SOFTBUS_INT_CONN_TCP_MAX_LENGTH,
406 (unsigned char*)&maxDataLen, sizeof(maxDataLen)) != SOFTBUS_OK) {
407 CONN_LOGE(CONN_TEST, "get maxDataLen fail");
408 }
409 printf("maxDataLen: %d\n", maxDataLen);
410 ConnPktHead head = {0};
411 head.len = maxDataLen + 1;
412
413 char *data = (char *)SoftBusCalloc(sizeof(head) + head.len);
414 if (data == nullptr) {
415 printf("Failed to assign memory to data.");
416 return;
417 }
418 (void)memcpy_s(data, sizeof(head), (void*)&head, sizeof(head));
419 (void)memset_s(data + sizeof(head), (unsigned int)head.len, 0x1, (unsigned int)head.len);
420
421 EXPECT_EQ(port, TcpStartListening(&info));
422 EXPECT_EQ(SOFTBUS_OK, TcpConnectDevice(&option, requestId, &g_result));
423 sleep(1);
424 EXPECT_EQ(SOFTBUS_OK, TcpPostBytes(g_connectionId, (uint8_t *)data, sizeof(ConnPktHead) + head.len, 0, 0, 0, 0));
425 sleep(1);
426 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
427 }
428
429 /*
430 * @tc.name: testTcpManager010
431 * @tc.desc: Test TcpConnectDevice with invalid -- option.type = connnet ble , moduleId = PROXY/AUTH/AUTH_P2P.
432 * @tc.in: Test module, Test number, Test Levels.
433 * @tc.out: NonZero
434 * @tc.type: FUNC
435 * @tc.require: The TcpConnectDevice operates normally.
436 */
437 HWTEST_F(TcpManagerTest, testTcpManager010, TestSize.Level1)
438 {
439 int port = CLIENTPORT;
440 uint32_t requestId = 1;
441 ConnectOption option;
442 option.type = CONNECT_BLE;
443 option.socketOption.port = port;
444 option.socketOption.moduleId = PROXY;
445 option.socketOption.protocol = LNN_PROTOCOL_IP;
446 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
447 int ret;
448 ret = TcpConnectDevice(nullptr, requestId, &g_result);
449 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
450 ret = TcpConnectDevice(&option, requestId, nullptr);
451 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
452 ret = TcpConnectDevice(&option, requestId, &g_result);
453 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
454
455 option.socketOption.moduleId = AUTH;
456 ret = TcpConnectDevice(nullptr, requestId, &g_result);
457 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
458 ret = TcpConnectDevice(&option, requestId, nullptr);
459 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
460 ret = TcpConnectDevice(&option, requestId, &g_result);
461 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
462
463 option.socketOption.moduleId = AUTH_P2P;
464 ret = TcpConnectDevice(nullptr, requestId, &g_result);
465 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
466 ret = TcpConnectDevice(&option, requestId, nullptr);
467 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
468 ret = TcpConnectDevice(&option, requestId, &g_result);
469 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
470 };
471
472 /*
473 * @tc.name: testTcpManager011
474 * @tc.desc: Test TcpConnectDevice with invalid -- option.type = connnet ble, \
475 \ moduleId = DIRECT_CHANNEL_SERVER_P2P/DIRECT_CHANNEL_CLIENT/DIRECT_CHANNEL_SERVER_WIFI.\
476 * @tc.in: Test module, Test number, Test Levels.
477 * @tc.out: NonZero
478 * @tc.type: FUNC
479 * @tc.require: The TcpConnectDevice operates normally.
480 */
481 HWTEST_F(TcpManagerTest, testTcpManager011, TestSize.Level1)
482 {
483 int port = CLIENTPORT;
484 uint32_t requestId = 1;
485 ConnectOption option;
486 option.type = CONNECT_BLE;
487 option.socketOption.port = port;
488 option.socketOption.moduleId = DIRECT_CHANNEL_SERVER_P2P;
489 option.socketOption.protocol = LNN_PROTOCOL_IP;
490 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
491 int ret;
492 ret = TcpConnectDevice(nullptr, requestId, &g_result);
493 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
494 ret = TcpConnectDevice(&option, requestId, nullptr);
495 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
496 ret = TcpConnectDevice(&option, requestId, &g_result);
497 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
498
499 option.socketOption.moduleId = DIRECT_CHANNEL_CLIENT;
500 ret = TcpConnectDevice(nullptr, requestId, &g_result);
501 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
502 ret = TcpConnectDevice(&option, requestId, nullptr);
503 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
504 ret = TcpConnectDevice(&option, requestId, &g_result);
505 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
506
507 option.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
508 ret = TcpConnectDevice(nullptr, requestId, &g_result);
509 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
510 ret = TcpConnectDevice(&option, requestId, nullptr);
511 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
512 ret = TcpConnectDevice(&option, requestId, &g_result);
513 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
514 };
515
516 /*
517 * @tc.name: testTcpManager012
518 * @tc.desc: Test TcpConnectDevice with invalid -- option.type = connnet p2p , moduleId = PROXY/AUTH/AUTH_P2P.
519 * @tc.in: Test module, Test number, Test Levels.
520 * @tc.out: NonZero
521 * @tc.type: FUNC
522 * @tc.require: The TcpConnectDevice operates normally.
523 */
524 HWTEST_F(TcpManagerTest, testTcpManager012, TestSize.Level1)
525 {
526 int port = CLIENTPORT;
527 uint32_t requestId = 1;
528 ConnectOption option;
529 option.type = CONNECT_P2P;
530 option.socketOption.port = port;
531 option.socketOption.moduleId = PROXY;
532 option.socketOption.protocol = LNN_PROTOCOL_IP;
533 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
534 int ret;
535 ret = TcpConnectDevice(nullptr, requestId, &g_result);
536 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
537 ret = TcpConnectDevice(&option, requestId, nullptr);
538 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
539 ret = TcpConnectDevice(&option, requestId, &g_result);
540 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
541
542 option.socketOption.moduleId = AUTH;
543 ret = TcpConnectDevice(nullptr, requestId, &g_result);
544 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
545 ret = TcpConnectDevice(&option, requestId, nullptr);
546 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
547 ret = TcpConnectDevice(&option, requestId, &g_result);
548 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
549
550 option.socketOption.moduleId = AUTH_P2P;
551 ret = TcpConnectDevice(nullptr, requestId, &g_result);
552 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
553 ret = TcpConnectDevice(&option, requestId, nullptr);
554 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
555 ret = TcpConnectDevice(&option, requestId, &g_result);
556 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
557 };
558
559 /*
560 * @tc.name: testTcpManager013
561 * @tc.desc: test TcpConnectDevice with invalid -- option.type = connnet p2p, \
562 \ moduleId = DIRECT_CHANNEL_SERVER_P2P/DIRECT_CHANNEL_CLIENT/DIRECT_CHANNEL_SERVER_WIFI.\
563 * @tc.in: Test module, Test number, Test Levels.
564 * @tc.out: NonZero
565 * @tc.type: FUNC
566 * @tc.require: The TcpConnectDevice operates normally.
567 */
568 HWTEST_F(TcpManagerTest, testTcpManager013, TestSize.Level1)
569 {
570 int port = CLIENTPORT;
571 uint32_t requestId = 1;
572 ConnectOption option;
573 option.type = CONNECT_P2P;
574 option.socketOption.port = port;
575 option.socketOption.moduleId = DIRECT_CHANNEL_SERVER_P2P;
576 option.socketOption.protocol = LNN_PROTOCOL_IP;
577 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
578 int ret;
579 ret = TcpConnectDevice(nullptr, requestId, &g_result);
580 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
581 ret = TcpConnectDevice(&option, requestId, nullptr);
582 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
583 ret = TcpConnectDevice(&option, requestId, &g_result);
584 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
585
586 option.socketOption.moduleId = DIRECT_CHANNEL_CLIENT;
587 ret = TcpConnectDevice(nullptr, requestId, &g_result);
588 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
589 ret = TcpConnectDevice(&option, requestId, nullptr);
590 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
591 ret = TcpConnectDevice(&option, requestId, &g_result);
592 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
593
594 option.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
595 ret = TcpConnectDevice(nullptr, requestId, &g_result);
596 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
597 ret = TcpConnectDevice(&option, requestId, nullptr);
598 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
599 ret = TcpConnectDevice(&option, requestId, &g_result);
600 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
601 };
602
603 /*
604 * @tc.name: testTcpManager014
605 * @tc.desc: Test start and stop listener multi times info.type = connect_br moduleId AUTH.
606 * @tc.in: Test module, Test number, Test Levels.
607 * @tc.out: NonZero
608 * @tc.type: FUNC
609 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
610 */
611 HWTEST_F(TcpManagerTest, testTcpManager014, TestSize.Level1)
612 {
613 int port = CLIENTPORT;
614 LocalListenerInfo info = {};
615 info.type = CONNECT_BR;
616 info.socketOption.port = port;
617 info.socketOption.moduleId = AUTH;
618 info.socketOption.protocol = LNN_PROTOCOL_IP;
619 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
620 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
621 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
622 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
623
624 info.type = CONNECT_TCP;
625 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
626 EXPECT_EQ(port, TcpStartListening(&info));
627 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
628 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
629 };
630
631 /*
632 * @tc.name: testTcpManager015
633 * @tc.desc: Test start and stop listener multi times info.type = connect_br moduleId AUTH_P2P.
634 * @tc.in: Test module, Test number, Test Levels.
635 * @tc.out: NonZero
636 * @tc.type: FUNC
637 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
638 */
639 HWTEST_F(TcpManagerTest, testTcpManager015, TestSize.Level1)
640 {
641 int port = CLIENTPORT;
642 LocalListenerInfo info = {};
643 info.type = CONNECT_BR;
644 info.socketOption.port = port;
645 info.socketOption.moduleId = AUTH_P2P;
646 info.socketOption.protocol = LNN_PROTOCOL_IP;
647 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
648 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
649 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
650 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
651
652 info.type = CONNECT_TCP;
653 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
654 EXPECT_EQ(port, TcpStartListening(&info));
655 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, TcpStartListening(&info));
656 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
657 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
658 };
659
660 /*
661 * @tc.name: testTcpManager016
662 * @tc.desc: Test start and stop listener multi times info.type = connect_br moduleId DIRECT_CHANNEL_SERVER_P2P.
663 * @tc.in: Test module, Test number, Test Levels.
664 * @tc.out: NonZero
665 * @tc.type: FUNC
666 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
667 */
668 HWTEST_F(TcpManagerTest, testTcpManager016, TestSize.Level1)
669 {
670 int port = CLIENTPORT;
671 LocalListenerInfo info = {};
672 info.type = CONNECT_BR;
673 info.socketOption.port = port;
674 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_P2P;
675 info.socketOption.protocol = LNN_PROTOCOL_IP;
676 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
677 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
678 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
679 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
680
681 info.type = CONNECT_TCP;
682 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
683 EXPECT_EQ(port, TcpStartListening(&info));
684 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
685 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
686 };
687
688 /*
689 * @tc.name: testTcpManager017
690 * @tc.desc: Test start and stop listener multi times info.type = connect_br moduleId DIRECT_CHANNEL_CLIENT.
691 * @tc.in: Test module, Test number, Test Levels.
692 * @tc.out: NonZero
693 * @tc.type: FUNC
694 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
695 */
696 HWTEST_F(TcpManagerTest, testTcpManager017, TestSize.Level1)
697 {
698 int port = CLIENTPORT;
699 LocalListenerInfo info = {};
700 info.type = CONNECT_BR;
701 info.socketOption.port = port;
702 info.socketOption.moduleId = DIRECT_CHANNEL_CLIENT;
703 info.socketOption.protocol = LNN_PROTOCOL_IP;
704 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
705 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
706 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
707 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
708
709 info.type = CONNECT_TCP;
710 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
711 EXPECT_EQ(port, TcpStartListening(&info));
712 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
713 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
714 };
715
716 /*
717 * @tc.name: testTcpManager018
718 * @tc.desc: Test start and stop listener multi times info.type = connect_br moduleId DIRECT_CHANNEL_SERVER_WIFI.
719 * @tc.in: Test module, Test number, Test Levels.
720 * @tc.out: NonZero
721 * @tc.type: FUNC
722 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
723 */
724 HWTEST_F(TcpManagerTest, testTcpManager018, TestSize.Level1)
725 {
726 int port = CLIENTPORT;
727 LocalListenerInfo info = {};
728 info.type = CONNECT_BR;
729 info.socketOption.port = port;
730 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
731 info.socketOption.protocol = LNN_PROTOCOL_IP;
732 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
733 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
734 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
735 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
736
737 info.type = CONNECT_TCP;
738 EXPECT_EQ(SOFTBUS_NOT_FIND, TcpStopListening(&info));
739 EXPECT_EQ(port, TcpStartListening(&info));
740 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
741 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
742 };
743
744 /*
745 * @tc.name: testTcpManager019
746 * @tc.desc: Test start and stop listener multi times info.type = connect_ble moduleId PROXY.
747 * @tc.in: Test module, Test number, Test Levels.
748 * @tc.out: NonZero
749 * @tc.type: FUNC
750 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
751 */
752 HWTEST_F(TcpManagerTest, testTcpManager019, TestSize.Level1)
753 {
754 int port = CLIENTPORT;
755 LocalListenerInfo info = {};
756 info.type = CONNECT_BLE;
757 info.socketOption.port = port;
758 info.socketOption.moduleId = PROXY;
759 info.socketOption.protocol = LNN_PROTOCOL_IP;
760 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
761 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
762 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
763 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
764
765 info.type = CONNECT_TCP;
766 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
767 EXPECT_EQ(port, TcpStartListening(&info));
768 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, TcpStartListening(&info));
769 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
770 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
771 };
772
773 /*
774 * @tc.name: testTcpManager020
775 * @tc.desc: Test start and stop listener multi times info.type = connect_ble moduleId AUTH.
776 * @tc.in: Test module, Test number, Test Levels.
777 * @tc.out: NonZero
778 * @tc.type: FUNC
779 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
780 */
781 HWTEST_F(TcpManagerTest, testTcpManager020, TestSize.Level1)
782 {
783 int port = CLIENTPORT;
784 LocalListenerInfo info = {};
785 info.type = CONNECT_BLE;
786 info.socketOption.port = port;
787 info.socketOption.moduleId = AUTH;
788 info.socketOption.protocol = LNN_PROTOCOL_IP;
789 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
790 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
791 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
792 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
793
794 info.type = CONNECT_TCP;
795 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
796 EXPECT_EQ(port, TcpStartListening(&info));
797 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
798 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
799 };
800
801 /*
802 * @tc.name: testTcpManager021
803 * @tc.desc: Test start and stop listener multi times info.type = connect_ble moduleId AUTH_P2P.
804 * @tc.in: Test module, Test number, Test Levels.
805 * @tc.out: NonZero
806 * @tc.type: FUNC
807 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
808 */
809 HWTEST_F(TcpManagerTest, testTcpManager021, TestSize.Level1)
810 {
811 int port = CLIENTPORT;
812 LocalListenerInfo info = {};
813 info.type = CONNECT_BLE;
814 info.socketOption.port = port;
815 info.socketOption.moduleId = AUTH_P2P;
816 info.socketOption.protocol = LNN_PROTOCOL_IP;
817 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
818 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
819 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
820 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
821
822 info.type = CONNECT_TCP;
823 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
824 EXPECT_EQ(port, TcpStartListening(&info));
825 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, TcpStartListening(&info));
826 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
827 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
828 };
829
830 /*
831 * @tc.name: testTcpManager022
832 * @tc.desc: Test GetTcpSockPort invalid fd.
833 * @tc.in: Test module, Test number, Test Levels.
834 * @tc.out: NonZero
835 * @tc.type: FUNC
836 * @tc.require: The GetTcpSockPort operates normally.
837 */
838 HWTEST_F(TcpManagerTest, testTcpManager022, TestSize.Level1)
839 {
840 const SocketInterface *tcp = GetTcpProtocol();
841 ASSERT_NE(tcp, nullptr);
842 int fd = -1;
843 int port = tcp->GetSockPort(fd);
844 int ret = (port <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
845 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
846
847 LocalListenerInfo option = {
848 .type = CONNECT_TCP,
849 .socketOption = {
850 .addr = "127.0.0.1",
851 .port = CLIENTPORT,
852 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
853 .protocol = LNN_PROTOCOL_IP
854 }
855 };
856
857 fd = tcp->OpenServerSocket(&option);
858 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
859 ASSERT_TRUE(ret == SOFTBUS_OK);
860 port = tcp->GetSockPort(fd);
861 EXPECT_EQ(port, CLIENTPORT);
862 ConnCloseSocket(fd);
863 };
864
865 /*
866 * @tc.name: testTcpManager023
867 * @tc.desc: Test SetIpTos invalid fd.
868 * @tc.in: Test module, Test number, Test Levels.
869 * @tc.out: NonZero
870 * @tc.type: FUNC
871 * @tc.require: The SetIpTos operates normally.
872 */
873 HWTEST_F(TcpManagerTest, testTcpManager023, TestSize.Level1)
874 {
875 const SocketInterface *tcp = GetTcpProtocol();
876 ASSERT_NE(tcp, nullptr);
877
878 ConnectOption option = {
879 .type = CONNECT_TCP,
880 .socketOption = {
881 .addr = "127.0.0.1",
882 .port = CLIENTPORT,
883 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
884 .protocol = LNN_PROTOCOL_IP
885 }
886 };
887
888 int fd = tcp->OpenClientSocket(&option, "127.0.0.1", true);
889 int tos = 1;
890 int ret = SetIpTos(fd, tos);
891 EXPECT_EQ(SOFTBUS_OK, ret);
892
893 fd = -1;
894 ret = SetIpTos(fd, tos);
895 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
896 ConnCloseSocket(fd);
897 };
898
899 /*
900 * @tc.name: testTcpManager024
901 * @tc.desc: Test ConnToggleNonBlockMode invalid fd.
902 * @tc.in: Test module, Test number, Test Levels.
903 * @tc.out: Zero
904 * @tc.type: FUNC
905 * @tc.require: The ConnToggleNonBlockMode operates normally.
906 */
907 HWTEST_F(TcpManagerTest, testTcpManager024, TestSize.Level1)
908 {
909 const SocketInterface *tcp = GetTcpProtocol();
910 ASSERT_NE(tcp, nullptr);
911
912 ConnectOption option = {
913 .type = CONNECT_TCP,
914 .socketOption = {
915 .addr = "127.0.0.1",
916 .port = CLIENTPORT,
917 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
918 .protocol = LNN_PROTOCOL_IP
919 }
920 };
921 int fd = -1;
922 bool isNonBlock = true;
923 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ConnToggleNonBlockMode(fd, isNonBlock));
924
925 fd = tcp->OpenClientSocket(&option, "127.0.0.1", true);
926 EXPECT_EQ(SOFTBUS_OK, ConnToggleNonBlockMode(fd, isNonBlock));
927 ConnCloseSocket(fd);
928 };
929
930 /*
931 * @tc.name: testTcpManager025
932 * @tc.desc: Test ConnSendSocketData invalid fd.
933 * @tc.in: Test module, Test number, Test Levels.
934 * @tc.out: NonZero
935 * @tc.type: FUNC
936 * @tc.require: The ConnSendSocketData operates normally.
937 */
938 HWTEST_F(TcpManagerTest, testTcpManager025, TestSize.Level1)
939 {
940 const SocketInterface *tcp = GetTcpProtocol();
941 ASSERT_NE(tcp, nullptr);
942
943 ConnectOption option = {
944 .type = CONNECT_TCP,
945 .socketOption = {
946 .addr = "127.0.0.1",
947 .port = CLIENTPORT,
948 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
949 .protocol = LNN_PROTOCOL_IP
950 }
951 };
952
953 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
954
955 int clientfd = tcp->OpenClientSocket(&option, "127.0.0.1", false);
956 ssize_t bytes = ConnSendSocketData(clientfd, "Hello world", 11, 0);
957 EXPECT_EQ(bytes, -1);
958 ConnShutdownSocket(clientfd);
959
960 clientfd = tcp->OpenClientSocket(&option, "127.0.0.1", true);
961 bytes = ConnSendSocketData(clientfd, "Hello world", 11, 0);
962 EXPECT_EQ(bytes, -1);
963 ConnShutdownSocket(clientfd);
964 };
965
966 /*
967 * @tc.name: testTcpManager026
968 * @tc.desc: Test ConnSendSocketData invalid buf len.
969 * @tc.in: Test module, Test number, Test Levels.
970 * @tc.out: NonZero
971 * @tc.type: FUNC
972 * @tc.require: The OpenTcpClientSocket and ConnSendSocketData operates normally.
973 */
974 HWTEST_F(TcpManagerTest, testTcpManager026, TestSize.Level1)
975 {
976 const SocketInterface *tcp = GetTcpProtocol();
977 ASSERT_NE(tcp, nullptr);
978
979 ConnectOption option = {
980 .type = CONNECT_TCP,
981 .socketOption = {
982 .addr = "127.0.0.1",
983 .port = CLIENTPORT,
984 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
985 .protocol = LNN_PROTOCOL_IP
986 }
987 };
988
989 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
990
991 int clientfd = tcp->OpenClientSocket(&option, "127.0.0.1", true);
992 int ret = (clientfd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
993 EXPECT_EQ(ret, SOFTBUS_OK);
994
995 int bytes = ConnSendSocketData(clientfd, nullptr, 10, 0);
996 EXPECT_EQ(bytes, -1);
997
998 bytes = ConnSendSocketData(clientfd, "hello world!", 0, 0);
999 EXPECT_EQ(bytes, -1);
1000
1001 bytes = ConnSendSocketData(clientfd, "hello world!", 12, 0);
1002 EXPECT_EQ(bytes, -1);
1003 ConnShutdownSocket(clientfd);
1004 };
1005
1006 /*
1007 * @tc.name: testTcpManager027
1008 * @tc.desc: Test ConnGetSocketError invalid param.
1009 * @tc.in: Test module, Test number, Test Levels.
1010 * @tc.out: NonZero
1011 * @tc.type: FUNC
1012 * @tc.require: The ConnGetSocketError and operates normally.
1013 */
1014 HWTEST_F(TcpManagerTest, testTcpManager027, TestSize.Level1)
1015 {
1016 const SocketInterface *tcp = GetTcpProtocol();
1017 ASSERT_NE(tcp, nullptr);
1018
1019 ConnectOption option = {
1020 .type = CONNECT_TCP,
1021 .socketOption = {
1022 .addr = "127.0.0.1",
1023 .port = CLIENTPORT,
1024 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1025 .protocol = LNN_PROTOCOL_IP
1026 }
1027 };
1028
1029 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
1030
1031 int clientfd = tcp->OpenClientSocket(&option, "127.0.0.1", true);
1032 int ret = (clientfd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1033 EXPECT_EQ(ret, SOFTBUS_OK);
1034 EXPECT_TRUE(ConnGetSocketError(clientfd) != 0);
1035 ConnCloseSocket(clientfd);
1036 };
1037
1038 /*
1039 * @tc.name: testTcpManager028
1040 * @tc.desc: Test the BLE and TCP start and stop listeners multiple times.
1041 * @tc.in: Test module, Test number, Test Levels.
1042 * @tc.out: Zero
1043 * @tc.type: FUNC
1044 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1045 */
1046 HWTEST_F(TcpManagerTest, testTcpManager028, TestSize.Level1)
1047 {
1048 int port = CLIENTPORT;
1049 LocalListenerInfo info = {};
1050 info.type = CONNECT_BLE;
1051 info.socketOption.port = port;
1052 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_P2P;
1053 info.socketOption.protocol = LNN_PROTOCOL_IP;
1054 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1055 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1056 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
1057 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1058
1059 info.type = CONNECT_TCP;
1060 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1061 EXPECT_EQ(port, TcpStartListening(&info));
1062 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1063 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1064 };
1065
1066 /*
1067 * @tc.name: testTcpManager029
1068 * @tc.desc: Test BLE and TCP start and stop listeners under DIRECT_CHANNEL_CLIENT multiple times.
1069 * @tc.in: Test module, Test number, Test Levels.
1070 * @tc.out: Zero
1071 * @tc.type: FUNC
1072 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1073 */
1074 HWTEST_F(TcpManagerTest, testTcpManager029, TestSize.Level1)
1075 {
1076 int port = CLIENTPORT;
1077 LocalListenerInfo info = {};
1078 info.type = CONNECT_BLE;
1079 info.socketOption.port = port;
1080 info.socketOption.moduleId = DIRECT_CHANNEL_CLIENT;
1081 info.socketOption.protocol = LNN_PROTOCOL_IP;
1082 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1083 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1084 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
1085 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1086
1087 info.type = CONNECT_TCP;
1088 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1089 EXPECT_EQ(port, TcpStartListening(&info));
1090 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1091 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1092 };
1093
1094 /*
1095 * @tc.name: testTcpManager030
1096 * @tc.desc: Test BLE and TCP start and stop listeners under DIRECT_CHANNEL_SERVER_WIFI multiple times.
1097 * @tc.in: Test module, Test number, Test Levels.
1098 * @tc.out: Zero
1099 * @tc.type: FUNC
1100 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1101 */
1102 HWTEST_F(TcpManagerTest, testTcpManager030, TestSize.Level1)
1103 {
1104 int port = CLIENTPORT;
1105 LocalListenerInfo info = {};
1106 info.type = CONNECT_BLE;
1107 info.socketOption.port = port;
1108 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1109 info.socketOption.protocol = LNN_PROTOCOL_IP;
1110 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1111 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1112 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
1113 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1114
1115 info.type = CONNECT_TCP;
1116 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1117 EXPECT_EQ(port, TcpStartListening(&info));
1118 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1119 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1120 };
1121
1122 /*
1123 * @tc.name: testTcpManager031
1124 * @tc.desc: Test P2P and TCP start and stop listeners under PROXY multiple times.
1125 * @tc.in: Test module, Test number, Test Levels.
1126 * @tc.out: NonZero
1127 * @tc.type: FUNC
1128 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1129 */
1130 HWTEST_F(TcpManagerTest, testTcpManager031, TestSize.Level1)
1131 {
1132 int port = CLIENTPORT;
1133 LocalListenerInfo info = {};
1134 info.type = CONNECT_P2P;
1135 info.socketOption.port = port;
1136 info.socketOption.moduleId = PROXY;
1137 info.socketOption.protocol = LNN_PROTOCOL_IP;
1138 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1139 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1140 EXPECT_EQ(port, TcpStartListening(&info));
1141 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1142
1143 info.type = CONNECT_TCP;
1144 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1145 EXPECT_EQ(port, TcpStartListening(&info));
1146 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, TcpStartListening(&info));
1147 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1148 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1149 };
1150
1151 /*
1152 * @tc.name: testTcpManager032
1153 * @tc.desc: Test P2P and TCP start and stop listeners under AUTH multiple times.
1154 * @tc.in: Test module, Test number, Test Levels.
1155 * @tc.out: NonZero
1156 * @tc.type: FUNC
1157 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1158 */
1159 HWTEST_F(TcpManagerTest, testTcpManager032, TestSize.Level1)
1160 {
1161 int port = CLIENTPORT;
1162 LocalListenerInfo info = {};
1163 info.type = CONNECT_P2P;
1164 info.socketOption.port = port;
1165 info.socketOption.moduleId = AUTH;
1166 info.socketOption.protocol = LNN_PROTOCOL_IP;
1167 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1168 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1169 EXPECT_EQ(port, TcpStartListening(&info));
1170 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1171
1172 info.type = CONNECT_TCP;
1173 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1174 EXPECT_EQ(port, TcpStartListening(&info));
1175 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1176 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1177 };
1178
1179 /*
1180 * @tc.name: testTcpManager033
1181 * @tc.desc: Test P2P and TCP start and stop listeners under AUTH_P2P multiple times.
1182 * @tc.in: Test module, Test number, Test Levels.
1183 * @tc.out: Zero
1184 * @tc.type: FUNC
1185 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1186 */
1187 HWTEST_F(TcpManagerTest, testTcpManager033, TestSize.Level1)
1188 {
1189 int port = CLIENTPORT;
1190 LocalListenerInfo info = {};
1191 info.type = CONNECT_P2P;
1192 info.socketOption.port = port;
1193 info.socketOption.moduleId = AUTH_P2P;
1194 info.socketOption.protocol = LNN_PROTOCOL_IP;
1195 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1196 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1197 EXPECT_EQ(port, TcpStartListening(&info));
1198 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1199
1200 info.type = CONNECT_TCP;
1201 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1202 EXPECT_EQ(port, TcpStartListening(&info));
1203 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, TcpStartListening(&info));
1204 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1205 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1206 };
1207
1208 /*
1209 * @tc.name: testTcpManager034
1210 * @tc.desc: Test P2P and TCP start and stop listeners under DIRECT_CHANNEL_SERVER_P2P multiple times.
1211 * @tc.in: Test module, Test number, Test Levels.
1212 * @tc.out: NonZero
1213 * @tc.type: FUNC
1214 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1215 */
1216 HWTEST_F(TcpManagerTest, testTcpManager034, TestSize.Level1)
1217 {
1218 int port = CLIENTPORT;
1219 LocalListenerInfo info = {};
1220 info.type = CONNECT_P2P;
1221 info.socketOption.port = port;
1222 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_P2P;
1223 info.socketOption.protocol = LNN_PROTOCOL_IP;
1224 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1225 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1226 EXPECT_EQ(port, TcpStartListening(&info));
1227 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1228
1229 info.type = CONNECT_TCP;
1230 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1231 EXPECT_EQ(port, TcpStartListening(&info));
1232 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1233 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1234 };
1235
1236 /*
1237 * @tc.name: testTcpManager035
1238 * @tc.desc: Test P2P and TCP start and stop listeners under DIRECT_CHANNEL_CLIENT multiple times.
1239 * @tc.in: Test module, Test number, Test Levels.
1240 * @tc.out: NonZero
1241 * @tc.type: FUNC
1242 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1243 */
1244 HWTEST_F(TcpManagerTest, testTcpManager035, TestSize.Level1)
1245 {
1246 int port = CLIENTPORT;
1247 LocalListenerInfo info = {};
1248 info.type = CONNECT_P2P;
1249 info.socketOption.port = port;
1250 info.socketOption.moduleId = DIRECT_CHANNEL_CLIENT;
1251 info.socketOption.protocol = LNN_PROTOCOL_IP;
1252 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1253 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1254 EXPECT_EQ(port, TcpStartListening(&info));
1255 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1256
1257 info.type = CONNECT_TCP;
1258 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1259 EXPECT_EQ(port, TcpStartListening(&info));
1260 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1261 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1262 };
1263
1264 /*
1265 * @tc.name: testTcpManager036
1266 * @tc.desc: Test P2P and TCP start and stop listeners under DIRECT_CHANNEL_SERVER_WIFI multiple times.
1267 * @tc.in: Test module, Test number, Test Levels.
1268 * @tc.out: NonZero
1269 * @tc.type: FUNC
1270 * @tc.require: The TcpStartListening and TcpStopListening operates normally.
1271 */
1272 HWTEST_F(TcpManagerTest, testTcpManager036, TestSize.Level1)
1273 {
1274 int port = CLIENTPORT;
1275 LocalListenerInfo info = {};
1276 info.type = CONNECT_P2P;
1277 info.socketOption.port = port;
1278 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1279 info.socketOption.protocol = LNN_PROTOCOL_IP;
1280 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1281 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1282 EXPECT_EQ(port, TcpStartListening(&info));
1283 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1284
1285 info.type = CONNECT_TCP;
1286 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1287 EXPECT_EQ(port, TcpStartListening(&info));
1288 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1289 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1290 };
1291
1292 /*
1293 * @tc.name: testTcpManager037
1294 * @tc.desc: Test SetIpTos return yes or no.
1295 * @tc.in: Test module, Test number, Test Levels.
1296 * @tc.out: Zero
1297 * @tc.type: FUNC
1298 * @tc.require: The SetIpTos operates normally.
1299 */
1300 HWTEST_F(TcpManagerTest, testTcpManager037, TestSize.Level1)
1301 {
1302 const SocketInterface *tcp = GetTcpProtocol();
1303 ASSERT_NE(tcp, nullptr);
1304
1305 int port = CLIENTPORT;
1306 LocalListenerInfo info = {};
1307 info.type = CONNECT_TCP;
1308 info.socketOption.port = port;
1309 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1310 info.socketOption.protocol = LNN_PROTOCOL_IP;
1311 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1312 int fd = tcp->OpenServerSocket(&info);
1313 uint32_t tos = 65535;
1314 int rc = SetIpTos(fd, tos);
1315 EXPECT_EQ(rc, SOFTBUS_OK);
1316 };
1317
1318 /*
1319 * @tc.name: testTcpManager038
1320 * @tc.desc: Test OpenTcpServerSocket Open succeed yes or no.
1321 * @tc.in: Test module, Test number, Test Levels.
1322 * @tc.out: Zero
1323 * @tc.type: FUNC
1324 * @tc.require: The OpenTcpServerSocket operates normally.
1325 */
1326 HWTEST_F(TcpManagerTest, testTcpManager038, TestSize.Level1)
1327 {
1328 const SocketInterface *tcp = GetTcpProtocol();
1329 ASSERT_NE(tcp, nullptr);
1330
1331 int port = SERVERPORT;
1332 LocalListenerInfo info = {};
1333 info.type = CONNECT_TCP;
1334 info.socketOption.port = port;
1335 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1336 info.socketOption.protocol = LNN_PROTOCOL_IP;
1337 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1338 EXPECT_TRUE(tcp->OpenServerSocket(&info) > 0);
1339 }
1340
1341 /*
1342 * @tc.name: testTcpManager039
1343 * @tc.desc: Test OpenTcpClientSocket Open succeed yes or no.
1344 * @tc.in: Test module, Test number, Test Levels.
1345 * @tc.out: Zero
1346 * @tc.type: FUNC
1347 * @tc.require: The SetIpTos and OpenTcpClientSocket operates normally.
1348 */
1349 HWTEST_F(TcpManagerTest, testTcpManager039, TestSize.Level1)
1350 {
1351 const SocketInterface *tcp = GetTcpProtocol();
1352 ASSERT_NE(tcp, nullptr);
1353
1354 LocalListenerInfo info = {
1355 .type = CONNECT_TCP,
1356 .socketOption = {
1357 .addr = {0},
1358 .port = CLIENTPORT,
1359 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1360 .protocol = LNN_PROTOCOL_IP
1361 }
1362 };
1363 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1364
1365 int fd = tcp->OpenServerSocket(&info);
1366 EXPECT_EQ(SetIpTos(fd, 65535), SOFTBUS_OK);
1367
1368 ConnectOption option = {
1369 .type = CONNECT_TCP,
1370 .socketOption = {
1371 .addr = "127.0.0.1",
1372 .port = CLIENTPORT,
1373 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1374 .protocol = LNN_PROTOCOL_IP
1375 }
1376 };
1377 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
1378 EXPECT_TRUE(tcp->OpenClientSocket(&option, Ip, true) > 0);
1379 };
1380
1381 /*
1382 * @tc.name: testTcpManager040
1383 * @tc.desc: Test ConnToggleNonBlockMode param is invalid yes or no.
1384 * @tc.in: Test module, Test number, Test Levels.
1385 * @tc.out: Zero
1386 * @tc.type: FUNC
1387 * @tc.require: The SetIpTos and ConnToggleNonBlockMode operates normally.
1388 */
1389 HWTEST_F(TcpManagerTest, testTcpManager040, TestSize.Level1)
1390 {
1391 const SocketInterface *tcp = GetTcpProtocol();
1392 ASSERT_NE(tcp, nullptr);
1393
1394 int port = CLIENTPORT;
1395 LocalListenerInfo info = {};
1396 info.type = CONNECT_TCP;
1397 info.socketOption.port = port;
1398 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1399 info.socketOption.protocol = LNN_PROTOCOL_IP;
1400 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1401 int fd = tcp->OpenServerSocket(&info);
1402 EXPECT_TRUE(fd > 0);
1403 EXPECT_EQ(SetIpTos(fd, 65535), SOFTBUS_OK);
1404 EXPECT_TRUE(ConnToggleNonBlockMode(fd, true) == 0);
1405 };
1406
1407 /*
1408 * @tc.name: testTcpManager041
1409 * @tc.desc: Test GetTcpSockPort param is invalid yes or no.
1410 * @tc.in: Test module, Test number, Test Levels.
1411 * @tc.out: Zero
1412 * @tc.type: FUNC
1413 * @tc.require: The GetTcpSockPort operates normally.
1414 */
1415 HWTEST_F(TcpManagerTest, testTcpManager041, TestSize.Level1)
1416 {
1417 const SocketInterface *tcp = GetTcpProtocol();
1418 ASSERT_NE(tcp, nullptr);
1419
1420 int port = CLIENTPORT;
1421 LocalListenerInfo info = {};
1422 info.type = CONNECT_TCP;
1423 info.socketOption.port = port;
1424 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1425 info.socketOption.protocol = LNN_PROTOCOL_IP;
1426 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1427 int fd = tcp->OpenServerSocket(&info);
1428 EXPECT_TRUE(tcp->GetSockPort(fd) > 0);
1429 };
1430
1431 /*
1432 * @tc.name: testTcpManager042
1433 * @tc.desc: test ConnSendSocketData SendData successful yes or no.
1434 * @tc.in: Test module, Test number, Test Levels.
1435 * @tc.out: NonZero
1436 * @tc.type: FUNC
1437 * @tc.require: The ConnSendSocketData operates normally.
1438 */
1439 HWTEST_F(TcpManagerTest, testTcpManager042, TestSize.Level1)
1440 {
1441 const SocketInterface *tcp = GetTcpProtocol();
1442 ASSERT_NE(tcp, nullptr);
1443
1444 ConnectOption option = {
1445 .type = CONNECT_TCP,
1446 .socketOption = {
1447 .addr = "127.0.0.1",
1448 .port = CLIENTPORT,
1449 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1450 .protocol = LNN_PROTOCOL_IP
1451 }
1452 };
1453
1454 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
1455 int fd = tcp->OpenClientSocket(&option, option.socketOption.addr, false);
1456 const char * buf = "SendDataTest";
1457 EXPECT_EQ(ConnSendSocketData(fd, buf, 13, 0), -1);
1458 };
1459
1460 /*
1461 * @tc.name: testTcpManager043
1462 * @tc.desc: Test whether the CloseTcpFd function runs successfully.
1463 * @tc.in: Test module, Test number, Test Levels.
1464 * @tc.out: Zero
1465 * @tc.type: FUNC
1466 * @tc.require: The OpenTcpClientSocket operates normally.
1467 */
1468 HWTEST_F(TcpManagerTest, testTcpManager043, TestSize.Level1)
1469 {
1470 const SocketInterface *tcp = GetTcpProtocol();
1471 ASSERT_NE(tcp, nullptr);
1472
1473 int port = CLIENTPORT;
1474 LocalListenerInfo info = {};
1475 info.type = CONNECT_TCP;
1476 info.socketOption.port = port;
1477 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1478 info.socketOption.protocol = LNN_PROTOCOL_IP;
1479 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1480 int fd = tcp->OpenServerSocket(&info);
1481 ConnCloseSocket(fd);
1482 EXPECT_TRUE(fd >= 0);
1483 };
1484
1485 /*
1486 * @tc.name: testTcpManager044
1487 * @tc.desc: Test ConnSendSocketData param is invalid yes or no.
1488 * @tc.in: Test module, Test number, Test Levels.
1489 * @tc.out: Nonzero
1490 * @tc.type: FUNC
1491 * @tc.require: The ConnSendSocketData operates normally.
1492 */
1493 HWTEST_F(TcpManagerTest, testTcpManager044, TestSize.Level1)
1494 {
1495 const SocketInterface *tcp = GetTcpProtocol();
1496 ASSERT_NE(tcp, nullptr);
1497
1498 ConnectOption option = {
1499 .type = CONNECT_TCP,
1500 .socketOption = {
1501 .addr = "127.0.0.1",
1502 .port = CLIENTPORT,
1503 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1504 .protocol = LNN_PROTOCOL_IP
1505 }
1506 };
1507
1508 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ip);
1509 int fd = tcp->OpenClientSocket(&option, option.socketOption.addr, false);
1510 const char * buf = "SendDataTest";
1511 EXPECT_EQ(ConnSendSocketData(fd, buf, 13, 0xffff), -1);
1512 };
1513
1514 /*
1515 * @tc.name: testTcpManager045
1516 * @tc.desc: Test ConnCloseSocket function successful yes or no.
1517 * @tc.in: Test module, Test number, Test Levels.
1518 * @tc.out: Zero
1519 * @tc.type: FUNC
1520 * @tc.require: The ConnShutdownSocket and OpenTcpClientSocket operates normally.
1521 */
1522 HWTEST_F(TcpManagerTest, testTcpManager045, TestSize.Level1)
1523 {
1524 const SocketInterface *tcp = GetTcpProtocol();
1525 ASSERT_NE(tcp, nullptr);
1526
1527 int port = CLIENTPORT;
1528 LocalListenerInfo info = {};
1529 info.type = CONNECT_TCP;
1530 info.socketOption.port = port;
1531 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1532 info.socketOption.protocol = LNN_PROTOCOL_IP;
1533 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1534 int fd = tcp->OpenServerSocket(&info);
1535 ConnShutdownSocket(fd);
1536 EXPECT_TRUE(fd >= 0);
1537 };
1538
1539 /*
1540 * @tc.name: testTcpManager046
1541 * @tc.desc: Test ConnSetTcpKeepalive fd param invalid.
1542 * @tc.in: Test module, Test number, Test Levels.
1543 * @tc.out: Nonzero
1544 * @tc.type: FUNC
1545 * @tc.require: The ConnSetTcpKeepalive operates normally.
1546 */
1547 HWTEST_F(TcpManagerTest, testTcpManager046, TestSize.Level1)
1548 {
1549 int port = CLIENTPORT;
1550 LocalListenerInfo info = {};
1551 info.type = CONNECT_TCP;
1552 info.socketOption.port = port;
1553 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1554 info.socketOption.protocol = LNN_PROTOCOL_IP;
1555 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1556 EXPECT_EQ(ConnSetTcpKeepalive(INVALID_FD, KEEPALIVE_IDLE_MAX, KEEPALIVE_INTERVAL, KEEPALIVE_COUNT),
1557 SOFTBUS_INVALID_PARAM);
1558 };
1559
1560 /*
1561 * @tc.name: testTcpManager047
1562 * @tc.desc: Test ConnSetTcpKeepalive second param invalid.
1563 * @tc.in: Test module, Test number, Test Levels.
1564 * @tc.out: Zero
1565 * @tc.type: FUNC
1566 * @tc.require: The ConnSetTcpKeepalive operates normally.
1567 */
1568 HWTEST_F(TcpManagerTest, testTcpManager047, TestSize.Level1)
1569 {
1570 const SocketInterface *tcp = GetTcpProtocol();
1571 ASSERT_NE(tcp, nullptr);
1572
1573 int port = CLIENTPORT;
1574 LocalListenerInfo info = {};
1575 info.type = CONNECT_TCP;
1576 info.socketOption.port = port;
1577 info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
1578 info.socketOption.protocol = LNN_PROTOCOL_IP;
1579 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ip);
1580 int fd = tcp->OpenServerSocket(&info);
1581 EXPECT_EQ(ConnSetTcpKeepalive(fd, KEEPALIVE_IDLE, KEEPALIVE_INTERVAL, KEEPALIVE_COUNT), SOFTBUS_OK);
1582 };
1583
1584 /*
1585 * @tc.name: testTcpManager048
1586 * @tc.desc: Test ipv6 OpenServerSocket and OpenTcpClientSocket Open succeed yes or no.
1587 * @tc.in: Test module, Test number, Test Levels.
1588 * @tc.out: Zero
1589 * @tc.type: FUNC
1590 * @tc.require: The OpenServerSocket and OpenTcpClientSocket operates normally.
1591 */
1592 HWTEST_F(TcpManagerTest, testTcpManager048, TestSize.Level1)
1593 {
1594 const SocketInterface *tcp = GetTcpProtocol();
1595 ASSERT_NE(tcp, nullptr);
1596
1597 LocalListenerInfo info = {
1598 .type = CONNECT_TCP,
1599 .socketOption = {
1600 .addr = {0},
1601 .port = CLIENTPORT,
1602 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1603 .protocol = LNN_PROTOCOL_IP
1604 }
1605 };
1606 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ipv6);
1607
1608 int fd = tcp->OpenServerSocket(&info);
1609 EXPECT_EQ(SetIpTos(fd, 65535), SOFTBUS_OK);
1610
1611 ConnectOption option = {
1612 .type = CONNECT_TCP,
1613 .socketOption = {
1614 .addr = "::1%lo",
1615 .port = CLIENTPORT,
1616 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1617 .protocol = LNN_PROTOCOL_IP
1618 }
1619 };
1620 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ipv6);
1621 EXPECT_TRUE(tcp->OpenClientSocket(&option, Ipv6, true) > 0);
1622 };
1623
1624 /*
1625 * @tc.name: testTcpManager049
1626 * @tc.desc: Test the BR and TCP start and stop listeners multiple times.
1627 * @tc.type: FUNC
1628 * @tc.require:
1629 */
1630 HWTEST_F(TcpManagerTest, testTcpManager049, TestSize.Level1)
1631 {
1632 int port = CLIENTPORT;
1633 LocalListenerInfo info = {};
1634 info.type = CONNECT_BR;
1635 info.socketOption.port = port;
1636 info.socketOption.moduleId = PROXY;
1637 info.socketOption.protocol = LNN_PROTOCOL_IP;
1638 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ipv6);
1639 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(nullptr));
1640 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStartListening(&info));
1641 EXPECT_EQ(SOFTBUS_INVALID_PARAM, TcpStopListening(nullptr));
1642
1643 info.type = CONNECT_TCP;
1644 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1645 EXPECT_EQ(port, TcpStartListening(&info));
1646 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1647 EXPECT_TRUE(SOFTBUS_OK == TcpStopListening(&info));
1648 };
1649
1650 /*
1651 * @tc.name: testTcpManager050
1652 * @tc.desc: test TcpDisconnectDevice
1653 * @tc.type: FUNC
1654 * @tc.require:
1655 */
1656 HWTEST_F(TcpManagerTest, testTcpManager050, TestSize.Level1)
1657 {
1658 int port = CLIENTPORT;
1659 LocalListenerInfo info = {};
1660 info.type = CONNECT_TCP;
1661 info.socketOption.port = port;
1662 info.socketOption.protocol = LNN_PROTOCOL_IP;
1663 (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), Ipv6);
1664
1665 uint32_t requestId = 1;
1666 ConnectOption option;
1667 option.type = CONNECT_TCP;
1668 option.socketOption.port = port;
1669 option.socketOption.moduleId = PROXY;
1670 option.socketOption.protocol = LNN_PROTOCOL_IP;
1671 (void)strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), Ipv6);
1672
1673 EXPECT_EQ(port, TcpStartListening(&info));
1674 EXPECT_EQ(SOFTBUS_OK, TcpConnectDevice(&option, requestId, &g_result));
1675 sleep(1);
1676 EXPECT_EQ(SOFTBUS_OK, TcpDisconnectDevice(g_connectionId));
1677 sleep(1);
1678 EXPECT_EQ(SOFTBUS_OK, TcpStopListening(&info));
1679 }
1680
1681
1682 /*
1683 * @tc.name: testTcpManager051
1684 * @tc.desc: Test GetTcpSockPort invalid fd.
1685 * @tc.in: Test module, Test number, Test Levels.
1686 * @tc.out: NonZero
1687 * @tc.type: FUNC
1688 * @tc.require: The GetTcpSockPort operates normally.
1689 */
1690 HWTEST_F(TcpManagerTest, testTcpManager051, TestSize.Level1)
1691 {
1692 const SocketInterface *tcp = GetTcpProtocol();
1693 ASSERT_NE(tcp, nullptr);
1694 int fd = -1;
1695 int port = tcp->GetSockPort(fd);
1696 int ret = (port <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1697 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1698
1699 LocalListenerInfo option = {
1700 .type = CONNECT_TCP,
1701 .socketOption = {
1702 .addr = "::1%lo",
1703 .port = CLIENTPORT,
1704 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1705 .protocol = LNN_PROTOCOL_IP
1706 }
1707 };
1708
1709 fd = tcp->OpenServerSocket(&option);
1710 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1711 ASSERT_TRUE(ret == SOFTBUS_OK);
1712 port = tcp->GetSockPort(fd);
1713 EXPECT_EQ(port, CLIENTPORT);
1714 ConnCloseSocket(fd);
1715 };
1716
1717 /*
1718 * @tc.name: testTcpManager052
1719 * @tc.desc: Test SetIpTos invalid fd.
1720 * @tc.in: Test module, Test number, Test Levels.
1721 * @tc.out: NonZero
1722 * @tc.type: FUNC
1723 * @tc.require: The SetIpTos operates normally.
1724 */
1725 HWTEST_F(TcpManagerTest, testTcpManager052, TestSize.Level1)
1726 {
1727 const SocketInterface *tcp = GetTcpProtocol();
1728 ASSERT_NE(tcp, nullptr);
1729
1730 ConnectOption option = {
1731 .type = CONNECT_TCP,
1732 .socketOption = {
1733 .addr = "::1%lo",
1734 .port = CLIENTPORT,
1735 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
1736 .protocol = LNN_PROTOCOL_IP
1737 }
1738 };
1739
1740 int fd = tcp->OpenClientSocket(&option, "::1%lo", true);
1741 EXPECT_EQ(SetIpTos(fd, 2), SOFTBUS_OK);
1742 ConnCloseSocket(fd);
1743 };
1744
1745 /*
1746 * @tc.name: testTcpDisconnectDeviceNow001
1747 * @tc.desc: test TcpDisconnectDeviceNow invaild parma
1748 * @tc.type: FUNC
1749 * @tc.require:
1750 */
1751 HWTEST_F(TcpManagerTest, testTcpDisconnectDeviceNow001, TestSize.Level1)
1752 {
1753 int ret = TcpDisconnectDeviceNow(nullptr);
1754 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1755 }
1756 }