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