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 <gtest/gtest.h>
17 #include <sys/epoll.h>
18
19 #include <pthread.h>
20 #include <securec.h>
21
22 #include "common_list.h"
23 #include "softbus_adapter_mock.h"
24 #include "softbus_base_listener.h"
25 #include "softbus_conn_common.h"
26 #include "softbus_conn_manager.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "softbus_socket.h"
30 #include "softbus_tcp_socket.h"
31 #include "softbus_watch_event_interface.h"
32
33 using namespace testing::ext;
34 using namespace testing;
35
36 static const int32_t INVALID_FD = -1;
37 static const int32_t TEST_FD = 1;
38 static pthread_mutex_t g_isInitedLock;
39 static int32_t g_count = 0;
40 static int32_t g_port = 6666;
41
42 namespace OHOS {
43 class SoftbusConnCommonTest : public testing::Test {
44 public:
SoftbusConnCommonTest()45 SoftbusConnCommonTest()
46 {}
~SoftbusConnCommonTest()47 ~SoftbusConnCommonTest()
48 {}
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
ThreadPoolTask(void * arg)55 int32_t ThreadPoolTask(void* arg)
56 {
57 pthread_mutex_lock(&g_isInitedLock);
58 g_count++;
59 pthread_mutex_unlock(&g_isInitedLock);
60 return SOFTBUS_OK;
61 }
62
SetUpTestCase(void)63 void SoftbusConnCommonTest::SetUpTestCase(void)
64 {
65 pthread_mutex_init(&g_isInitedLock, nullptr);
66 GTEST_LOG_(INFO) << "SoftbusConnCommonTestSetUp";
67 ConnServerInit();
68 }
69
TearDownTestCase(void)70 void SoftbusConnCommonTest::TearDownTestCase(void)
71 {
72 g_count = 0;
73 g_port++;
74 GTEST_LOG_(INFO) << "+-------------------------------------------+";
75 }
76
SetUp(void)77 void SoftbusConnCommonTest::SetUp(void)
78 {
79 g_count = 0;
80 }
81
TearDown(void)82 void SoftbusConnCommonTest::TearDown(void)
83 {
84 g_count = 0;
85 }
86
ConnectEvent(ListenerModule module,int32_t cfd,const ConnectOption * clientAddr)87 int32_t ConnectEvent(ListenerModule module, int32_t cfd, const ConnectOption *clientAddr)
88 {
89 return 0;
90 }
91
DataEvent(ListenerModule module,int32_t events,int32_t fd)92 int32_t DataEvent(ListenerModule module, int32_t events, int32_t fd)
93 {
94 return 0;
95 }
96
97 SocketAddr g_socketAddr = {
98 .addr = "127.0.0.1",
99 .port = g_port,
100 };
101
102 /*
103 * @tc.name: testBaseListener002
104 * @tc.desc: test GetSoftbusBaseListener and set
105 * @tc.type: FUNC
106 * @tc.require: I5HSOL
107 */
108 HWTEST_F(SoftbusConnCommonTest, testBaseListener002, TestSize.Level1)
109 {
110 int32_t i;
111 int32_t port = 6666;
112 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
113 ASSERT_TRUE(setListener != nullptr);
114 setListener->onConnectEvent = ConnectEvent;
115 setListener->onDataEvent = DataEvent;
116
117 SoftbusAdapterMock mock;
118 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
119 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
120 LocalListenerInfo info = {
121 .type = CONNECT_TCP,
122 .socketOption = {
123 .addr = "127.0.0.1",
124 .port = port,
125 .moduleId = static_cast<ListenerModule>(i),
126 .protocol = LNN_PROTOCOL_IP
127 }
128 };
129 EXPECT_EQ(port, StartBaseListener(&info, setListener));
130 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
131 ++port;
132 }
133 free(setListener);
134 };
135
136 /*
137 * @tc.name: testBaseListener006
138 * @tc.desc: test Invalid trigger param
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142 HWTEST_F(SoftbusConnCommonTest, testBaseListener006, TestSize.Level1)
143 {
144 int32_t module;
145 int32_t triggerType;
146 int32_t fd = 1;
147 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
148 EXPECT_EQ(SOFTBUS_INVALID_PARAM, AddTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
149 EXPECT_EQ(SOFTBUS_INVALID_PARAM, DelTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
150 }
151 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
152 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
153 EXPECT_EQ(SOFTBUS_INVALID_PARAM, AddTrigger(static_cast<ListenerModule>(module), INVALID_FD,
154 static_cast<TriggerType>(triggerType)));
155 EXPECT_EQ(SOFTBUS_INVALID_PARAM, DelTrigger(static_cast<ListenerModule>(module), INVALID_FD,
156 static_cast<TriggerType>(triggerType)));
157 }
158 }
159 };
160
161 /*
162 * @tc.name: testBaseListener007
163 * @tc.desc: test Not set baselistener
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(SoftbusConnCommonTest, testBaseListener007, TestSize.Level1)
168 {
169 int32_t module;
170 int32_t triggerType;
171 int32_t fd = 1;
172 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
173 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
174 EXPECT_EQ(SOFTBUS_CONN_FAIL, AddTrigger(static_cast<ListenerModule>(module),
175 fd, static_cast<TriggerType>(triggerType)));
176 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
177 fd, static_cast<TriggerType>(triggerType)));
178 }
179 }
180 };
181
182 /*
183 * @tc.name: testBaseListener008
184 * @tc.desc: test add del trigger
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(SoftbusConnCommonTest, testBaseListener008, TestSize.Level1)
189 {
190 int32_t module;
191 int32_t triggerType;
192 int32_t fd = 1;
193 int32_t port = 6666;
194 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
195 ASSERT_TRUE(listener != nullptr);
196 listener->onConnectEvent = ConnectEvent;
197 listener->onDataEvent = DataEvent;
198
199 SoftbusAdapterMock mock;
200 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
201 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
202 LocalListenerInfo info = {
203 .type = CONNECT_TCP,
204 .socketOption = {.addr = "127.0.0.1",
205 .port = port,
206 .moduleId = static_cast<ListenerModule>(module),
207 .protocol = LNN_PROTOCOL_IP}
208 };
209 EXPECT_EQ(port, StartBaseListener(&info, listener));
210 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
211 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
212 fd, static_cast<TriggerType>(triggerType)));
213 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
214 fd, static_cast<TriggerType>(triggerType)));
215 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
216 fd, static_cast<TriggerType>(triggerType)));
217 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
218 fd, static_cast<TriggerType>(triggerType)));
219 }
220 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
221 ++port;
222 }
223 free(listener);
224 };
225
226 /*
227 * @tc.name: testBaseListener009
228 * @tc.desc: test add del trigger
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(SoftbusConnCommonTest, testBaseListener009, TestSize.Level1)
233 {
234 int32_t module;
235 int32_t triggerType;
236 int32_t port = 6666;
237 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
238 ASSERT_TRUE(listener != nullptr);
239 listener->onConnectEvent = ConnectEvent;
240 listener->onDataEvent = DataEvent;
241
242 SoftbusAdapterMock mock;
243 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
244
245 int32_t fdArray[1024] = {0};
246 for (int32_t index = 0; index < 1024; index++) {
247 fdArray[index] = epoll_create(0);
248 }
249 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
250 LocalListenerInfo info = {
251 .type = CONNECT_TCP,
252 .socketOption = {.addr = "127.0.0.1",
253 .port = port,
254 .moduleId = static_cast<ListenerModule>(module),
255 .protocol = LNN_PROTOCOL_IP}
256 };
257 EXPECT_EQ(port, StartBaseListener(&info, listener));
258 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
259 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
260 fdArray[1023], static_cast<TriggerType>(triggerType)));
261 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
262 fdArray[1023], static_cast<TriggerType>(triggerType)));
263 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
264 fdArray[1023], static_cast<TriggerType>(triggerType)));
265 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
266 fdArray[1023], static_cast<TriggerType>(triggerType)));
267 }
268 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
269 ++port;
270 }
271
272 for (int32_t index = 0; index < 1024; index++) {
273 SoftBusSocketClose(fdArray[index]);
274 }
275 free(listener);
276 };
277
278 /*
279 * @tc.name: testBaseListener010
280 * @tc.desc: test GetSoftbusBaseListener and set
281 * @tc.type: FUNC
282 * @tc.require: I5HSOL
283 */
284 HWTEST_F(SoftbusConnCommonTest, testBaseListener010, TestSize.Level1)
285 {
286 int32_t i;
287 int32_t port = 6666;
288 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
289 ASSERT_TRUE(setListener != nullptr);
290 setListener->onConnectEvent = ConnectEvent;
291 setListener->onDataEvent = DataEvent;
292
293 SoftbusAdapterMock mock;
294 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
295 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
296 LocalListenerInfo info = {
297 .type = CONNECT_TCP,
298 .socketOption = {
299 .addr = "::1%lo",
300 .port = port,
301 .moduleId = static_cast<ListenerModule>(i),
302 .protocol = LNN_PROTOCOL_IP
303 }
304 };
305 EXPECT_EQ(port, StartBaseListener(&info, setListener));
306 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
307 ++port;
308 }
309 free(setListener);
310 };
311
312 /*
313 * @tc.name: testBaseListener016
314 * @tc.desc: Test StartBaseClient invalid input param ListenerModule module.
315 * @tc.in: Test module, Test number, Test Levels.
316 * @tc.out: NonZero
317 * @tc.type: FUNC
318 * @tc.require: The StartBaseClient operates normally.
319 */
320 HWTEST_F(SoftbusConnCommonTest, testBaseListener016, TestSize.Level1)
321 {
322 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseClient(static_cast<ListenerModule>(PROXY - 1), nullptr));
323 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
324 StartBaseClient(static_cast<ListenerModule>(DIRECT_CHANNEL_SERVER_WIFI + 1), nullptr));
325 };
326
327 /*
328 * @tc.name: testBaseListener021
329 * @tc.desc: Test StartBaseListener invalid input param const char *ip.
330 */
331 HWTEST_F(SoftbusConnCommonTest, testBaseListener021, TestSize.Level1)
332 {
333 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
334 ASSERT_TRUE(listener != nullptr);
335 listener->onConnectEvent = ConnectEvent;
336 listener->onDataEvent = DataEvent;
337
338 int32_t i;
339 int32_t port = 6666;
340 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
341 LocalListenerInfo info = {
342 .type = CONNECT_TCP,
343 .socketOption = {
344 .addr = "::1%lo",
345 .port = port,
346 .moduleId = static_cast<ListenerModule>(i),
347 .protocol = LNN_PROTOCOL_IP
348 }
349 };
350 EXPECT_EQ(SOFTBUS_OK, StartBaseClient(static_cast<ListenerModule>(i), listener));
351 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, StartBaseListener(&info, listener));
352 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
353 port++;
354 }
355 free(listener);
356 };
357
358
359 /*
360 * @tc.name: testBaseListener022
361 * @tc.desc: Test StartBaseListener invalid input param int32_t port < 0.
362 * @tc.in: Test module, Test number, Test Levels.
363 * @tc.out: NonZero
364 * @tc.type: FUNC
365 * @tc.require: The StartBaseListener operates normally.
366 */
367 HWTEST_F(SoftbusConnCommonTest, testBaseListener022, TestSize.Level1)
368 {
369 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
370 ASSERT_TRUE(listener != nullptr);
371 listener->onConnectEvent = ConnectEvent;
372 listener->onDataEvent = DataEvent;
373 LocalListenerInfo info = {
374 .type = CONNECT_TCP,
375 .socketOption = {.addr = "127.0.0.1",
376 .port = -1,
377 .moduleId = PROXY,
378 .protocol = LNN_PROTOCOL_IP}
379 };
380 int32_t i;
381 for (i = PROXY; i <= LISTENER_MODULE_DYNAMIC_START; i++) {
382 info.socketOption.moduleId = static_cast<ListenerModule>(i);
383 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseListener(&info, listener));
384 }
385 free(listener);
386 };
387
388 /*
389 * @tc.name: testBaseListener026
390 * @tc.desc: Test StopBaseListener invalid input param ListenerModule module.
391 * @tc.in: Test module, Test number, Test Levels.
392 * @tc.out: NonZero
393 * @tc.type: FUNC
394 * @tc.require: The StopBaseListener operates normally.
395 */
396 HWTEST_F(SoftbusConnCommonTest, testBaseListener026, TestSize.Level1)
397 {
398 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(static_cast<ListenerModule>(PROXY - 1)));
399 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(static_cast<ListenerModule>(UNUSE_BUTT)));
400 };
401
402 /*
403 * @tc.name: testBaseListener027
404 * @tc.desc: Test StopBaseListener failed g_listenerList[module].info = NULL.
405 * @tc.in: Test module, Test number, Test Levels.
406 * @tc.out: NonZero
407 * @tc.type: FUNC
408 * @tc.require: The StopBaseListener operates normally.
409 */
410 HWTEST_F(SoftbusConnCommonTest, testBaseListener027, TestSize.Level1)
411 {
412 int32_t i;
413 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
414 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
415 }
416 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(UNUSE_BUTT));
417 };
418
419 /*
420 * @tc.name: testTcpSocket001
421 * @tc.desc: test OpenTcpServerSocket
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(SoftbusConnCommonTest, testTcpSocket001, TestSize.Level1)
426 {
427 const SocketInterface *tcp = GetTcpProtocol();
428 ASSERT_NE(tcp, nullptr);
429
430 LocalListenerInfo info = {
431 .type = CONNECT_TCP,
432 .socketOption = {
433 .addr = "127.0.0.1",
434 .port = g_port,
435 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
436 .protocol = LNN_PROTOCOL_IP
437 }
438 };
439
440 SoftbusAdapterMock mock;
441 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
442 int32_t fd = tcp->OpenServerSocket(&info);
443 int32_t ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
444 ASSERT_TRUE(ret == SOFTBUS_OK);
445 int32_t port = tcp->GetSockPort(fd);
446 EXPECT_EQ(port, g_port);
447 ConnCloseSocket(fd);
448
449 fd = tcp->OpenServerSocket(nullptr);
450 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
451 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
452 ConnCloseSocket(fd);
453
454 info.socketOption.port = -1;
455 fd = tcp->OpenServerSocket(&info);
456 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
457 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
458 ConnCloseSocket(fd);
459 };
460
461 /*
462 * @tc.name: testTcpSocket002
463 * @tc.desc: test OpenTcpClientSocket
464 * @tc.type: FUNC
465 * @tc.require:
466 */
467 HWTEST_F(SoftbusConnCommonTest, testTcpSocket002, TestSize.Level1)
468 {
469 const SocketInterface *tcp = GetTcpProtocol();
470 ASSERT_NE(tcp, nullptr);
471
472 ConnectOption option = {
473 .type = CONNECT_TCP,
474 .socketOption = {
475 .addr = "127.0.0.1",
476 .port = g_port,
477 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
478 .protocol = LNN_PROTOCOL_IP
479 }
480 };
481
482 SoftbusAdapterMock mock;
483 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
484 int32_t fd = tcp->OpenClientSocket(nullptr, "127.0.0.1", false);
485 int32_t ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
486 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
487 ConnCloseSocket(fd);
488 fd = tcp->OpenClientSocket(nullptr, nullptr, false);
489 ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
490 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
491 ConnCloseSocket(fd);
492
493 option.socketOption.port = -1;
494 fd = tcp->OpenClientSocket(&option, "127.0.0.1", false);
495 ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
496 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
497 ConnCloseSocket(fd);
498 };
499
500 /*
501 * @tc.name: testBaseListener003
502 * @tc.desc: test GetTcpSockPort invalid fd
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(SoftbusConnCommonTest, testTcpSocket003, TestSize.Level1)
507 {
508 const SocketInterface *tcp = GetTcpProtocol();
509 ASSERT_NE(tcp, nullptr);
510 int32_t invalidFd = 1;
511 int32_t port = tcp->GetSockPort(invalidFd);
512 int32_t ret = (port <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
513 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
514 };
515
516 /*
517 * @tc.name: testTcpSocket004
518 * @tc.desc: test ConnSendSocketData invalid fd
519 * @tc.type: FUNC
520 * @tc.require:
521 */
522 HWTEST_F(SoftbusConnCommonTest, testTcpSocket004, TestSize.Level1)
523 {
524 const SocketInterface *tcp = GetTcpProtocol();
525 ASSERT_NE(tcp, nullptr);
526
527 SoftbusAdapterMock mock;
528 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
529 int32_t clientFd = tcp->OpenClientSocket(nullptr, "127.5.0.1", false);
530 int32_t ret = (clientFd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
531 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
532 ssize_t bytes = ConnSendSocketData(clientFd, "Hello world", 11, 0);
533 EXPECT_EQ(bytes, -1);
534 ConnShutdownSocket(clientFd);
535 };
536
537 /*
538 * @tc.name: testTcpSocket005
539 * @tc.desc: test OpenTcpServerSocket
540 * @tc.type: FUNC
541 * @tc.require:
542 */
543 HWTEST_F(SoftbusConnCommonTest, testTcpSocket006, TestSize.Level1)
544 {
545 const SocketInterface *tcp = GetTcpProtocol();
546 ASSERT_NE(tcp, nullptr);
547
548 LocalListenerInfo info = {
549 .type = CONNECT_TCP,
550 .socketOption = {
551 .addr = "::1%lo",
552 .port = g_port,
553 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
554 .protocol = LNN_PROTOCOL_IP
555 }
556 };
557
558 SoftbusAdapterMock mock;
559 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
560 int32_t fd = tcp->OpenServerSocket(&info);
561 int32_t ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
562 ASSERT_TRUE(ret == SOFTBUS_OK);
563 int32_t port = tcp->GetSockPort(fd);
564 EXPECT_EQ(port, g_port);
565 ConnCloseSocket(fd);
566
567 fd = tcp->OpenServerSocket(nullptr);
568 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
569 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
570 ConnCloseSocket(fd);
571
572 info.socketOption.port = -1;
573 fd = tcp->OpenServerSocket(&info);
574 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
575 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
576 ConnCloseSocket(fd);
577 };
578
579 /*
580 * @tc.name: testSocket001
581 * @tc.desc: test ConnGetLocalSocketPort port
582 * @tc.type: FUNC
583 * @tc.require: I5PC1B
584 */
585 HWTEST_F(SoftbusConnCommonTest, testSocket001, TestSize.Level1)
586 {
587 int32_t ret;
588 ret = ConnGetLocalSocketPort(INVALID_FD);
589 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
590
591 ret = ConnGetLocalSocketPort(TEST_FD);
592 EXPECT_TRUE(ret < 0);
593 };
594
595 /*
596 * @tc.name: testSocket002
597 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
598 * @tc.type: FUNC
599 * @tc.require: I5PC1B
600 */
601 HWTEST_F(SoftbusConnCommonTest, testSocket002, TestSize.Level1)
602 {
603 int32_t ret;
604
605 ret = ConnGetPeerSocketAddr(TEST_FD, nullptr);
606 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
607
608 SoftbusAdapterMock mock;
609 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
610 ret = ConnGetPeerSocketAddr(INVALID_FD, &g_socketAddr);
611 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
612
613 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
614 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
615 };
616
617 /*
618 * @tc.name: testConnSetTcpUserTimeOut001
619 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
620 * @tc.in: test module, test number,test levels.
621 * @tc.out: Zero
622 * @tc.type: FUNC
623 * @tc.require: The ThreadPoolDestroy operates normally.
624 */
625 HWTEST_F(SoftbusConnCommonTest, testConnSetTcpUserTimeOut001, TestSize.Level1)
626 {
627 int32_t fd = -1;
628 uint32_t millSec = 1;
629
630 SoftbusAdapterMock mock;
631 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
632 int32_t ret = ConnSetTcpUserTimeOut(fd, millSec);
633 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
634 }
635
636 /*
637 * @tc.name: testConnSetTcpUserTimeOut002
638 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
639 * @tc.in: test module, test number,test levels.
640 * @tc.out: Zero
641 * @tc.type: FUNC
642 * @tc.require: The ThreadPoolDestroy operates normally.
643 */
644 HWTEST_F(SoftbusConnCommonTest, testConnSetTcpUserTimeOut002, TestSize.Level1)
645 {
646 int32_t fd = 1;
647 uint32_t millSec = 321;
648
649 SoftbusAdapterMock mock;
650 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
651 int32_t ret = ConnSetTcpUserTimeOut(fd, millSec);
652 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
653 }
654
655 /*
656 * @tc.name: testSocket003
657 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
658 * @tc.type: FUNC
659 * @tc.require:
660 */
661 HWTEST_F(SoftbusConnCommonTest, testSocket003, TestSize.Level1)
662 {
663 int32_t ret;
664 SocketAddr socketAddr;
665 SoftbusAdapterMock mock;
666 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_ERR));
667 ret = ConnGetPeerSocketAddr(INVALID_FD, &socketAddr);
668 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
669 }
670
671 /*
672 * @tc.name: testSocket004
673 * @tc.desc: test ConnGetLocalSocketPort port
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(SoftbusConnCommonTest, testSocket004, TestSize.Level1)
678 {
679 int32_t ret;
680 ret = ConnGetLocalSocketPort(INVALID_FD);
681 EXPECT_NE(SOFTBUS_OK, ret);
682 }
683
684 /*
685 * @tc.name: testConnPreAssignPort001
686 * @tc.desc: test ConnPreAssignPort SoftBusSocketCreate is failed
687 * @tc.type: FUNC
688 * @tc.require: I5PC1B
689 */
690 HWTEST_F(SoftbusConnCommonTest, testConnPreAssignPort001, TestSize.Level1)
691 {
692 int32_t ret;
693 ret = ConnPreAssignPort(-1);
694 EXPECT_EQ(SOFTBUS_TCPCONNECTION_SOCKET_ERR, ret);
695
696 SoftbusAdapterMock mock;
697
698 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_OK));
699 ret = ConnPreAssignPort(SOFTBUS_AF_INET);
700
701 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_OK));
702 ret = ConnPreAssignPort(SOFTBUS_AF_INET6);
703
704 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_ERR));
705 ret = ConnPreAssignPort(SOFTBUS_AF_INET);
706 EXPECT_EQ(SOFTBUS_TCPCONNECTION_SOCKET_ERR, ret);
707 };
708
709 /*
710 * @tc.name: ConnGetPeerSocketAddr001
711 * @tc.desc: test ConnGetPeerSocketAddr is SUCC
712 * @tc.type: FUNC
713 * @tc.require: I5PC1B
714 */
715 HWTEST_F(SoftbusConnCommonTest, ConnGetPeerSocketAddr001, TestSize.Level1)
716 {
717 int32_t ret;
718 SoftbusAdapterMock mock;
719 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_OK))
720 .WillRepeatedly(SoftbusAdapterMock::ActionOfSoftBusSocketGetPeerName);
721 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
722 EXPECT_EQ(SOFTBUS_OK, ret);
723
724 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
725 EXPECT_EQ(SOFTBUS_OK, ret);
726 };
727
728 /*
729 * @tc.name: WaitQueueLength001
730 * @tc.desc: test WaitQueueLength001 is failed
731 * @tc.type: FUNC
732 * @tc.require: I5PC1B
733 */
734 HWTEST_F(SoftbusConnCommonTest, WaitQueueLength001, TestSize.Level1)
735 {
736 int32_t ret;
737 uint32_t unitNum = 1;
738 LockFreeQueue *lockFreeQueue = CreateQueue(unitNum);
739 SoftbusAdapterMock mock;
740 SoftBusCond *cond = { 0 };
741 SoftBusMutex *mutex = { 0 };
742
743 EXPECT_CALL(mock, SoftBusGetTime).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
744 EXPECT_CALL(mock, SoftBusCondWait).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
745 ret = WaitQueueLength(lockFreeQueue, 0, 0, cond, mutex);
746 EXPECT_EQ(SOFTBUS_CONN_COND_WAIT_FAIL, ret);
747 };
748
749 /*
750 * @tc.name: SoftbusListenerNodeOp001
751 * @tc.desc: test SoftbusListenerNodeOp001 DestroyBaseListener
752 * @tc.type: FUNC
753 * @tc.require: I5PC1B
754 */
755 HWTEST_F(SoftbusConnCommonTest, SoftbusListenerNodeOp001, TestSize.Level1)
756 {
757 int32_t ret;
758 ListenerModule module = LISTENER_MODULE_DYNAMIC_START;
759 CreateListenerModule();
760 ret = IsListenerNodeExist(module);
761 EXPECT_EQ(true, ret);
762
763 DeinitBaseListener();
764 ret = IsListenerNodeExist(module);
765 EXPECT_EQ(false, ret);
766 };
767
OnGetAllFdEvent(ListNode * list)768 static int32_t OnGetAllFdEvent(ListNode *list)
769 {
770 return SOFTBUS_OK;
771 }
772
773 /*
774 * @tc.name: AddEvent001
775 * @tc.desc: test AddEvent001 param is error
776 * @tc.type: FUNC
777 * @tc.require: I5PC1B
778 */
779 HWTEST_F(SoftbusConnCommonTest, AddEvent001, TestSize.Level1)
780 {
781 int32_t fd = -1;
782 int32_t ret = AddEvent(nullptr, fd, READ_TRIGGER);
783 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
784
785 EventWatcher watcher = {0};
786 watcher.watcherId = -1;
787
788 ret = AddEvent(&watcher, fd, READ_TRIGGER);
789 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
790 };
791
792 /*
793 * @tc.name: AddEvent002
794 * @tc.desc: test AddEvent002 param is error
795 * @tc.type: FUNC
796 * @tc.require: I5PC1B
797 */
798 HWTEST_F(SoftbusConnCommonTest, AddEvent002, TestSize.Level1)
799 {
800 int32_t fd = 1;
801 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
802
803 int32_t ret = AddEvent(watcher, fd, READ_TRIGGER);
804 EXPECT_EQ(SOFTBUS_OK, ret);
805
806 ret = AddEvent(watcher, -1, READ_TRIGGER);
807 EXPECT_TRUE(ret < 0);
808
809 CloseEventWatcher(watcher);
810 };
811
812 /*
813 * @tc.name: ModifyEvent001
814 * @tc.desc: test ModifyEvent001 param is error
815 * @tc.type: FUNC
816 * @tc.require: I5PC1B
817 */
818 HWTEST_F(SoftbusConnCommonTest, ModifyEvent001, TestSize.Level1)
819 {
820 int32_t fd = -1;
821
822 int32_t ret = ModifyEvent(nullptr, fd, READ_TRIGGER);
823 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
824
825 EventWatcher watcher = {0};
826 watcher.watcherId = -1;
827 ret = ModifyEvent(&watcher, fd, EXCEPT_TRIGGER);
828 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
829 };
830
831 /*
832 * @tc.name: ModifyEvent002
833 * @tc.desc: test ModifyEvent002 param is error
834 * @tc.type: FUNC
835 * @tc.require: I5PC1B
836 */
837 HWTEST_F(SoftbusConnCommonTest, ModifyEvent002, TestSize.Level1)
838 {
839 int32_t fd = 1;
840 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
841
842 AddEvent(watcher, fd, READ_TRIGGER);
843 int32_t ret = ModifyEvent(watcher, fd, WRITE_TRIGGER);
844 EXPECT_EQ(SOFTBUS_OK, ret);
845
846 ret = ModifyEvent(watcher, -1, READ_TRIGGER);
847 EXPECT_TRUE(ret < 0);
848
849 CloseEventWatcher(watcher);
850 };
851
852 /*
853 * @tc.name: RemoveEvent001
854 * @tc.desc: test RemoveEvent001 param is error
855 * @tc.type: FUNC
856 * @tc.require: I5PC1B
857 */
858 HWTEST_F(SoftbusConnCommonTest, RemoveEvent001, TestSize.Level1)
859 {
860 int32_t fd = -1;
861
862 int32_t ret = RemoveEvent(nullptr, fd);
863 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
864
865 EventWatcher watcher = {0};
866 watcher.watcherId = -1;
867 ret = RemoveEvent(&watcher, fd);
868 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
869 };
870
871 /*
872 * @tc.name: RemoveEvent002
873 * @tc.desc: test RemoveEvent002 param is error
874 * @tc.type: FUNC
875 * @tc.require: I5PC1B
876 */
877 HWTEST_F(SoftbusConnCommonTest, RemoveEvent002, TestSize.Level1)
878 {
879 int32_t fd = 1;
880 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
881
882 AddEvent(watcher, fd, READ_TRIGGER);
883 int32_t ret = RemoveEvent(watcher, fd);
884 EXPECT_EQ(SOFTBUS_OK, ret);
885
886 ret = RemoveEvent(watcher, -1);
887 EXPECT_TRUE(ret < 0);
888
889 CloseEventWatcher(watcher);
890 };
891
892 /*
893 * @tc.name: WatchEvent001
894 * @tc.desc: test WatchEvent001 param is error
895 * @tc.type: FUNC
896 * @tc.require: I5PC1B
897 */
898 HWTEST_F(SoftbusConnCommonTest, WatchEvent001, TestSize.Level1)
899 {
900 ListNode fdEventNode;
901 ListInit(&fdEventNode);
902
903 int32_t ret = WatchEvent(nullptr, -1, &fdEventNode);
904 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
905
906 EventWatcher watcher = {0};
907 watcher.watcherId = -1;
908 ret = WatchEvent(&watcher, -1, &fdEventNode);
909 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
910
911 watcher.watcherId = 1;
912 ret = WatchEvent(&watcher, -1, &fdEventNode);
913 EXPECT_TRUE(ret < 0);
914 };
915 }
916