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_usb_tcp_socket.h"
32 #include "softbus_watch_event_interface.h"
33
34 using namespace testing::ext;
35 using namespace testing;
36
37 static const int32_t INVALID_FD = -1;
38 static const int32_t TEST_FD = 1;
39 static pthread_mutex_t g_isInitedLock;
40 static int32_t g_count = 0;
41 static int32_t g_port = 6666;
42
43 namespace OHOS {
44 class SoftbusConnCommonTest : public testing::Test {
45 public:
SoftbusConnCommonTest()46 SoftbusConnCommonTest()
47 {}
~SoftbusConnCommonTest()48 ~SoftbusConnCommonTest()
49 {}
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 };
55
ThreadPoolTask(void * arg)56 int32_t ThreadPoolTask(void* arg)
57 {
58 pthread_mutex_lock(&g_isInitedLock);
59 g_count++;
60 pthread_mutex_unlock(&g_isInitedLock);
61 return SOFTBUS_OK;
62 }
63
SetUpTestCase(void)64 void SoftbusConnCommonTest::SetUpTestCase(void)
65 {
66 pthread_mutex_init(&g_isInitedLock, nullptr);
67 GTEST_LOG_(INFO) << "SoftbusConnCommonTestSetUp";
68 ConnServerInit();
69 }
70
TearDownTestCase(void)71 void SoftbusConnCommonTest::TearDownTestCase(void)
72 {
73 g_count = 0;
74 g_port++;
75 GTEST_LOG_(INFO) << "+-------------------------------------------+";
76 }
77
SetUp(void)78 void SoftbusConnCommonTest::SetUp(void)
79 {
80 g_count = 0;
81 }
82
TearDown(void)83 void SoftbusConnCommonTest::TearDown(void)
84 {
85 g_count = 0;
86 }
87
ConnectEvent(ListenerModule module,int32_t cfd,const ConnectOption * clientAddr)88 int32_t ConnectEvent(ListenerModule module, int32_t cfd, const ConnectOption *clientAddr)
89 {
90 return 0;
91 }
92
DataEvent(ListenerModule module,int32_t events,int32_t fd)93 int32_t DataEvent(ListenerModule module, int32_t events, int32_t fd)
94 {
95 return 0;
96 }
97
98 SocketAddr g_socketAddr = {
99 .addr = "127.0.0.1",
100 .port = g_port,
101 };
102
103 SocketAddr g_socketAddr6 = {
104 .addr = "::1",
105 .port = g_port,
106 };
107
108 /*
109 * @tc.name: testBaseListener002
110 * @tc.desc: test GetSoftbusBaseListener and set
111 * @tc.type: FUNC
112 * @tc.require: I5HSOL
113 */
114 HWTEST_F(SoftbusConnCommonTest, testBaseListener002, TestSize.Level1)
115 {
116 int32_t i;
117 int32_t port = 6666;
118 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
119 ASSERT_TRUE(setListener != nullptr);
120 setListener->onConnectEvent = ConnectEvent;
121 setListener->onDataEvent = DataEvent;
122
123 SoftbusAdapterMock mock;
124 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
125 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
126 LocalListenerInfo info = {
127 .type = CONNECT_TCP,
128 .socketOption = {
129 .addr = "127.0.0.1",
130 .port = port,
131 .moduleId = static_cast<ListenerModule>(i),
132 .protocol = LNN_PROTOCOL_IP
133 }
134 };
135 EXPECT_EQ(port, StartBaseListener(&info, setListener));
136 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
137 ++port;
138 }
139 free(setListener);
140 };
141
142 /*
143 * @tc.name: testBaseListener006
144 * @tc.desc: test Invalid trigger param
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(SoftbusConnCommonTest, testBaseListener006, TestSize.Level1)
149 {
150 int32_t module;
151 int32_t triggerType;
152 int32_t fd = 1;
153 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
154 EXPECT_EQ(SOFTBUS_INVALID_PARAM, AddTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
155 EXPECT_EQ(SOFTBUS_INVALID_PARAM, DelTrigger(UNUSE_BUTT, fd, static_cast<TriggerType>(triggerType)));
156 }
157 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
158 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
159 EXPECT_EQ(SOFTBUS_INVALID_PARAM, AddTrigger(static_cast<ListenerModule>(module), INVALID_FD,
160 static_cast<TriggerType>(triggerType)));
161 EXPECT_EQ(SOFTBUS_INVALID_PARAM, DelTrigger(static_cast<ListenerModule>(module), INVALID_FD,
162 static_cast<TriggerType>(triggerType)));
163 }
164 }
165 };
166
167 /*
168 * @tc.name: testBaseListener007
169 * @tc.desc: test Not set baselistener
170 * @tc.type: FUNC
171 * @tc.require:
172 */
173 HWTEST_F(SoftbusConnCommonTest, testBaseListener007, TestSize.Level1)
174 {
175 int32_t module;
176 int32_t triggerType;
177 int32_t fd = 1;
178 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
179 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
180 EXPECT_EQ(SOFTBUS_CONN_FAIL, AddTrigger(static_cast<ListenerModule>(module),
181 fd, static_cast<TriggerType>(triggerType)));
182 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
183 fd, static_cast<TriggerType>(triggerType)));
184 }
185 }
186 };
187
188 /*
189 * @tc.name: testBaseListener008
190 * @tc.desc: test add del trigger
191 * @tc.type: FUNC
192 * @tc.require:
193 */
194 HWTEST_F(SoftbusConnCommonTest, testBaseListener008, TestSize.Level1)
195 {
196 int32_t module;
197 int32_t triggerType;
198 int32_t fd = 1;
199 int32_t port = 6666;
200 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
201 ASSERT_TRUE(listener != nullptr);
202 listener->onConnectEvent = ConnectEvent;
203 listener->onDataEvent = DataEvent;
204
205 SoftbusAdapterMock mock;
206 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
207 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
208 LocalListenerInfo info = {
209 .type = CONNECT_TCP,
210 .socketOption = {.addr = "127.0.0.1",
211 .port = port,
212 .moduleId = static_cast<ListenerModule>(module),
213 .protocol = LNN_PROTOCOL_IP}
214 };
215 EXPECT_EQ(port, StartBaseListener(&info, listener));
216 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
217 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
218 fd, static_cast<TriggerType>(triggerType)));
219 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
220 fd, static_cast<TriggerType>(triggerType)));
221 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
222 fd, static_cast<TriggerType>(triggerType)));
223 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
224 fd, static_cast<TriggerType>(triggerType)));
225 }
226 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
227 ++port;
228 }
229 free(listener);
230 };
231
232 /*
233 * @tc.name: testBaseListener009
234 * @tc.desc: test add del trigger
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(SoftbusConnCommonTest, testBaseListener009, TestSize.Level1)
239 {
240 int32_t module;
241 int32_t triggerType;
242 int32_t port = 6666;
243 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
244 ASSERT_TRUE(listener != nullptr);
245 listener->onConnectEvent = ConnectEvent;
246 listener->onDataEvent = DataEvent;
247
248 SoftbusAdapterMock mock;
249 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
250
251 int32_t fdArray[1024] = {0};
252 for (int32_t index = 0; index < 1024; index++) {
253 fdArray[index] = epoll_create(0);
254 }
255 for (module = PROXY; module < LISTENER_MODULE_DYNAMIC_START; module++) {
256 LocalListenerInfo info = {
257 .type = CONNECT_TCP,
258 .socketOption = {.addr = "127.0.0.1",
259 .port = port,
260 .moduleId = static_cast<ListenerModule>(module),
261 .protocol = LNN_PROTOCOL_IP}
262 };
263 EXPECT_EQ(port, StartBaseListener(&info, listener));
264 for (triggerType = READ_TRIGGER; triggerType <= RW_TRIGGER; triggerType++) {
265 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
266 fdArray[1023], static_cast<TriggerType>(triggerType)));
267 EXPECT_EQ(SOFTBUS_OK, AddTrigger(static_cast<ListenerModule>(module),
268 fdArray[1023], static_cast<TriggerType>(triggerType)));
269 EXPECT_EQ(SOFTBUS_OK, DelTrigger(static_cast<ListenerModule>(module),
270 fdArray[1023], static_cast<TriggerType>(triggerType)));
271 EXPECT_EQ(SOFTBUS_NOT_FIND, DelTrigger(static_cast<ListenerModule>(module),
272 fdArray[1023], static_cast<TriggerType>(triggerType)));
273 }
274 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(module)));
275 ++port;
276 }
277
278 for (int32_t index = 0; index < 1024; index++) {
279 SoftBusSocketClose(fdArray[index]);
280 }
281 free(listener);
282 };
283
284 /*
285 * @tc.name: testBaseListener010
286 * @tc.desc: test GetSoftbusBaseListener and set
287 * @tc.type: FUNC
288 * @tc.require: I5HSOL
289 */
290 HWTEST_F(SoftbusConnCommonTest, testBaseListener010, TestSize.Level1)
291 {
292 int32_t i;
293 int32_t port = 6666;
294 SoftbusBaseListener *setListener = (SoftbusBaseListener *)malloc(sizeof(SoftbusBaseListener));
295 ASSERT_TRUE(setListener != nullptr);
296 setListener->onConnectEvent = ConnectEvent;
297 setListener->onDataEvent = DataEvent;
298
299 SoftbusAdapterMock mock;
300 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
301 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
302 LocalListenerInfo info = {
303 .type = CONNECT_TCP,
304 .socketOption = {
305 .addr = "::1%lo",
306 .port = port,
307 .moduleId = static_cast<ListenerModule>(i),
308 .protocol = LNN_PROTOCOL_IP
309 }
310 };
311 EXPECT_EQ(port, StartBaseListener(&info, setListener));
312 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
313 ++port;
314 }
315 free(setListener);
316 };
317
318 /*
319 * @tc.name: testBaseListener016
320 * @tc.desc: Test StartBaseClient invalid input param ListenerModule module.
321 * @tc.in: Test module, Test number, Test Levels.
322 * @tc.out: NonZero
323 * @tc.type: FUNC
324 * @tc.require: The StartBaseClient operates normally.
325 */
326 HWTEST_F(SoftbusConnCommonTest, testBaseListener016, TestSize.Level1)
327 {
328 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseClient(static_cast<ListenerModule>(PROXY - 1), nullptr));
329 EXPECT_EQ(SOFTBUS_INVALID_PARAM,
330 StartBaseClient(static_cast<ListenerModule>(DIRECT_CHANNEL_SERVER_WIFI + 1), nullptr));
331 };
332
333 /*
334 * @tc.name: testBaseListener021
335 * @tc.desc: Test StartBaseListener invalid input param const char *ip.
336 */
337 HWTEST_F(SoftbusConnCommonTest, testBaseListener021, TestSize.Level1)
338 {
339 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
340 ASSERT_TRUE(listener != nullptr);
341 listener->onConnectEvent = ConnectEvent;
342 listener->onDataEvent = DataEvent;
343
344 int32_t i;
345 int32_t port = 6666;
346 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
347 LocalListenerInfo info = {
348 .type = CONNECT_TCP,
349 .socketOption = {
350 .addr = "::1%lo",
351 .port = port,
352 .moduleId = static_cast<ListenerModule>(i),
353 .protocol = LNN_PROTOCOL_IP
354 }
355 };
356 EXPECT_EQ(SOFTBUS_OK, StartBaseClient(static_cast<ListenerModule>(i), listener));
357 EXPECT_EQ(SOFTBUS_CONN_LISTENER_NOT_IDLE, StartBaseListener(&info, listener));
358 ASSERT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
359 port++;
360 }
361 free(listener);
362 };
363
364
365 /*
366 * @tc.name: testBaseListener022
367 * @tc.desc: Test StartBaseListener invalid input param int32_t port < 0.
368 * @tc.in: Test module, Test number, Test Levels.
369 * @tc.out: NonZero
370 * @tc.type: FUNC
371 * @tc.require: The StartBaseListener operates normally.
372 */
373 HWTEST_F(SoftbusConnCommonTest, testBaseListener022, TestSize.Level1)
374 {
375 SoftbusBaseListener* listener = (SoftbusBaseListener*)malloc(sizeof(SoftbusBaseListener));
376 ASSERT_TRUE(listener != nullptr);
377 listener->onConnectEvent = ConnectEvent;
378 listener->onDataEvent = DataEvent;
379 LocalListenerInfo info = {
380 .type = CONNECT_TCP,
381 .socketOption = {.addr = "127.0.0.1",
382 .port = -1,
383 .moduleId = PROXY,
384 .protocol = LNN_PROTOCOL_IP}
385 };
386 int32_t i;
387 for (i = PROXY; i <= LISTENER_MODULE_DYNAMIC_START; i++) {
388 info.socketOption.moduleId = static_cast<ListenerModule>(i);
389 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StartBaseListener(&info, listener));
390 }
391 free(listener);
392 };
393
394 /*
395 * @tc.name: testBaseListener026
396 * @tc.desc: Test StopBaseListener invalid input param ListenerModule module.
397 * @tc.in: Test module, Test number, Test Levels.
398 * @tc.out: NonZero
399 * @tc.type: FUNC
400 * @tc.require: The StopBaseListener operates normally.
401 */
402 HWTEST_F(SoftbusConnCommonTest, testBaseListener026, TestSize.Level1)
403 {
404 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(static_cast<ListenerModule>(PROXY - 1)));
405 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(static_cast<ListenerModule>(UNUSE_BUTT)));
406 };
407
408 /*
409 * @tc.name: testBaseListener027
410 * @tc.desc: Test StopBaseListener failed g_listenerList[module].info = NULL.
411 * @tc.in: Test module, Test number, Test Levels.
412 * @tc.out: NonZero
413 * @tc.type: FUNC
414 * @tc.require: The StopBaseListener operates normally.
415 */
416 HWTEST_F(SoftbusConnCommonTest, testBaseListener027, TestSize.Level1)
417 {
418 int32_t i;
419 for (i = PROXY; i < LISTENER_MODULE_DYNAMIC_START; i++) {
420 EXPECT_EQ(SOFTBUS_OK, StopBaseListener(static_cast<ListenerModule>(i)));
421 }
422 EXPECT_EQ(SOFTBUS_INVALID_PARAM, StopBaseListener(UNUSE_BUTT));
423 };
424
425 /*
426 * @tc.name: testTcpSocket001
427 * @tc.desc: test OpenTcpServerSocket
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(SoftbusConnCommonTest, testTcpSocket001, TestSize.Level1)
432 {
433 const SocketInterface *tcp = GetTcpProtocol();
434 ASSERT_NE(tcp, nullptr);
435
436 LocalListenerInfo info = {
437 .type = CONNECT_TCP,
438 .socketOption = {
439 .addr = "127.0.0.1",
440 .port = g_port,
441 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
442 .protocol = LNN_PROTOCOL_IP
443 }
444 };
445
446 SoftbusAdapterMock mock;
447 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
448 int32_t fd = tcp->OpenServerSocket(&info);
449 int32_t ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
450 ASSERT_TRUE(ret == SOFTBUS_OK);
451 int32_t port = tcp->GetSockPort(fd);
452 EXPECT_EQ(port, g_port);
453 ConnCloseSocket(fd);
454
455 fd = tcp->OpenServerSocket(nullptr);
456 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
457 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
458 ConnCloseSocket(fd);
459
460 info.socketOption.port = -1;
461 fd = tcp->OpenServerSocket(&info);
462 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
463 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
464 ConnCloseSocket(fd);
465 };
466
467 /*
468 * @tc.name: testTcpSocket002
469 * @tc.desc: test OpenTcpClientSocket
470 * @tc.type: FUNC
471 * @tc.require:
472 */
473 HWTEST_F(SoftbusConnCommonTest, testTcpSocket002, TestSize.Level1)
474 {
475 const SocketInterface *tcp = GetTcpProtocol();
476 ASSERT_NE(tcp, nullptr);
477
478 ConnectOption option = {
479 .type = CONNECT_TCP,
480 .socketOption = {
481 .addr = "127.0.0.1",
482 .port = g_port,
483 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
484 .protocol = LNN_PROTOCOL_IP
485 }
486 };
487
488 SoftbusAdapterMock mock;
489 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
490 int32_t fd = tcp->OpenClientSocket(nullptr, "127.0.0.1", false);
491 int32_t ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
492 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
493 ConnCloseSocket(fd);
494 fd = tcp->OpenClientSocket(nullptr, nullptr, false);
495 ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
496 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
497 ConnCloseSocket(fd);
498
499 option.socketOption.port = -1;
500 fd = tcp->OpenClientSocket(&option, "127.0.0.1", false);
501 ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
502 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
503 ConnCloseSocket(fd);
504 };
505
506 /*
507 * @tc.name: testBaseListener003
508 * @tc.desc: test GetTcpSockPort invalid fd
509 * @tc.type: FUNC
510 * @tc.require:
511 */
512 HWTEST_F(SoftbusConnCommonTest, testTcpSocket003, TestSize.Level1)
513 {
514 const SocketInterface *tcp = GetTcpProtocol();
515 ASSERT_NE(tcp, nullptr);
516 int32_t invalidFd = 1;
517 int32_t port = tcp->GetSockPort(invalidFd);
518 int32_t ret = (port <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
519 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
520 };
521
522 /*
523 * @tc.name: testTcpSocket004
524 * @tc.desc: test ConnSendSocketData invalid fd
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(SoftbusConnCommonTest, testTcpSocket004, TestSize.Level1)
529 {
530 const SocketInterface *tcp = GetTcpProtocol();
531 ASSERT_NE(tcp, nullptr);
532
533 SoftbusAdapterMock mock;
534 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
535 int32_t clientFd = tcp->OpenClientSocket(nullptr, "127.5.0.1", false);
536 int32_t ret = (clientFd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
537 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
538 ssize_t bytes = ConnSendSocketData(clientFd, "Hello world", 11, 0);
539 EXPECT_EQ(bytes, -1);
540 ConnShutdownSocket(clientFd);
541 };
542
543 /*
544 * @tc.name: testTcpSocket005
545 * @tc.desc: test OpenTcpServerSocket
546 * @tc.type: FUNC
547 * @tc.require:
548 */
549 HWTEST_F(SoftbusConnCommonTest, testTcpSocket006, TestSize.Level1)
550 {
551 const SocketInterface *tcp = GetTcpProtocol();
552 ASSERT_NE(tcp, nullptr);
553
554 LocalListenerInfo info = {
555 .type = CONNECT_TCP,
556 .socketOption = {
557 .addr = "::1%lo",
558 .port = g_port,
559 .moduleId = DIRECT_CHANNEL_SERVER_WIFI,
560 .protocol = LNN_PROTOCOL_IP
561 }
562 };
563
564 SoftbusAdapterMock mock;
565 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
566 int32_t fd = tcp->OpenServerSocket(&info);
567 int32_t ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
568 ASSERT_TRUE(ret == SOFTBUS_OK);
569 int32_t port = tcp->GetSockPort(fd);
570 EXPECT_EQ(port, g_port);
571 ConnCloseSocket(fd);
572
573 fd = tcp->OpenServerSocket(nullptr);
574 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
575 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
576 ConnCloseSocket(fd);
577
578 info.socketOption.port = -1;
579 fd = tcp->OpenServerSocket(&info);
580 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
581 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
582 ConnCloseSocket(fd);
583 };
584
585 /*
586 * @tc.name: testSocket001
587 * @tc.desc: test ConnGetLocalSocketPort port
588 * @tc.type: FUNC
589 * @tc.require: I5PC1B
590 */
591 HWTEST_F(SoftbusConnCommonTest, testSocket001, TestSize.Level1)
592 {
593 int32_t ret;
594 ret = ConnGetLocalSocketPort(INVALID_FD);
595 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
596
597 ret = ConnGetLocalSocketPort(TEST_FD);
598 EXPECT_TRUE(ret < 0);
599 };
600
601 /*
602 * @tc.name: testSocket002
603 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
604 * @tc.type: FUNC
605 * @tc.require: I5PC1B
606 */
607 HWTEST_F(SoftbusConnCommonTest, testSocket002, TestSize.Level1)
608 {
609 int32_t ret;
610
611 ret = ConnGetPeerSocketAddr(TEST_FD, nullptr);
612 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
613
614 SoftbusAdapterMock mock;
615 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
616 ret = ConnGetPeerSocketAddr(INVALID_FD, &g_socketAddr);
617 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
618
619 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
620 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
621 };
622
623 /*
624 * @tc.name: testConnSetTcpUserTimeOut001
625 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
626 * @tc.in: test module, test number,test levels.
627 * @tc.out: Zero
628 * @tc.type: FUNC
629 * @tc.require: The ThreadPoolDestroy operates normally.
630 */
631 HWTEST_F(SoftbusConnCommonTest, testConnSetTcpUserTimeOut001, TestSize.Level1)
632 {
633 int32_t fd = -1;
634 uint32_t millSec = 1;
635
636 SoftbusAdapterMock mock;
637 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
638 int32_t ret = ConnSetTcpUserTimeOut(fd, millSec);
639 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
640 }
641
642 /*
643 * @tc.name: testConnSetTcpUserTimeOut002
644 * @tc.desc: Test ConnSetTcpUserTimeOut param is invalid
645 * @tc.in: test module, test number,test levels.
646 * @tc.out: Zero
647 * @tc.type: FUNC
648 * @tc.require: The ThreadPoolDestroy operates normally.
649 */
650 HWTEST_F(SoftbusConnCommonTest, testConnSetTcpUserTimeOut002, TestSize.Level1)
651 {
652 int32_t fd = 1;
653 uint32_t millSec = 321;
654
655 SoftbusAdapterMock mock;
656 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
657 int32_t ret = ConnSetTcpUserTimeOut(fd, millSec);
658 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
659 }
660
661 /*
662 * @tc.name: testSocket003
663 * @tc.desc: test ConnGetPeerSocketAddr param is invalid
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(SoftbusConnCommonTest, testSocket003, TestSize.Level1)
668 {
669 int32_t ret;
670 SocketAddr socketAddr;
671 SoftbusAdapterMock mock;
672 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_ERR));
673 ret = ConnGetPeerSocketAddr(INVALID_FD, &socketAddr);
674 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
675 }
676
677 /*
678 * @tc.name: testSocket004
679 * @tc.desc: test ConnGetLocalSocketPort port
680 * @tc.type: FUNC
681 * @tc.require:
682 */
683 HWTEST_F(SoftbusConnCommonTest, testSocket004, TestSize.Level1)
684 {
685 int32_t ret;
686 ret = ConnGetLocalSocketPort(INVALID_FD);
687 EXPECT_NE(SOFTBUS_OK, ret);
688 }
689
690 /*
691 * @tc.name: testConnPreAssignPort001
692 * @tc.desc: test ConnPreAssignPort SoftBusSocketCreate is failed
693 * @tc.type: FUNC
694 * @tc.require: I5PC1B
695 */
696 HWTEST_F(SoftbusConnCommonTest, testConnPreAssignPort001, TestSize.Level1)
697 {
698 int32_t ret;
699 ret = ConnPreAssignPort(-1);
700 EXPECT_EQ(SOFTBUS_TCPCONNECTION_SOCKET_ERR, ret);
701
702 SoftbusAdapterMock mock;
703
704 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_OK));
705 ret = ConnPreAssignPort(SOFTBUS_AF_INET);
706
707 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_OK));
708 ret = ConnPreAssignPort(SOFTBUS_AF_INET6);
709
710 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillOnce(Return(SOFTBUS_ADAPTER_ERR));
711 ret = ConnPreAssignPort(SOFTBUS_AF_INET);
712 EXPECT_EQ(SOFTBUS_TCPCONNECTION_SOCKET_ERR, ret);
713 };
714
715 /*
716 * @tc.name: ConnGetPeerSocketAddr001
717 * @tc.desc: test ConnGetPeerSocketAddr is SUCC
718 * @tc.type: FUNC
719 * @tc.require: I5PC1B
720 */
721 HWTEST_F(SoftbusConnCommonTest, ConnGetPeerSocketAddr001, TestSize.Level1)
722 {
723 int32_t ret;
724 SoftbusAdapterMock mock;
725 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_OK))
726 .WillRepeatedly(SoftbusAdapterMock::ActionOfSoftBusSocketGetPeerName);
727 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
728 EXPECT_EQ(SOFTBUS_OK, ret);
729
730 ret = ConnGetPeerSocketAddr(TEST_FD, &g_socketAddr);
731 EXPECT_EQ(SOFTBUS_OK, ret);
732 };
733
734 /*
735 * @tc.name: WaitQueueLength001
736 * @tc.desc: test WaitQueueLength001 is failed
737 * @tc.type: FUNC
738 * @tc.require: I5PC1B
739 */
740 HWTEST_F(SoftbusConnCommonTest, WaitQueueLength001, TestSize.Level1)
741 {
742 int32_t ret;
743 uint32_t unitNum = 1;
744 LockFreeQueue *lockFreeQueue = CreateQueue(unitNum);
745 SoftbusAdapterMock mock;
746 SoftBusCond *cond = { 0 };
747 SoftBusMutex *mutex = { 0 };
748
749 EXPECT_CALL(mock, SoftBusGetTime).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
750 EXPECT_CALL(mock, SoftBusCondWait).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
751 ret = WaitQueueLength(lockFreeQueue, 0, 0, cond, mutex);
752 EXPECT_EQ(SOFTBUS_CONN_COND_WAIT_FAIL, ret);
753 };
754
755 /*
756 * @tc.name: SoftbusListenerNodeOp001
757 * @tc.desc: test SoftbusListenerNodeOp001 DestroyBaseListener
758 * @tc.type: FUNC
759 * @tc.require: I5PC1B
760 */
761 HWTEST_F(SoftbusConnCommonTest, SoftbusListenerNodeOp001, TestSize.Level1)
762 {
763 int32_t ret;
764 ListenerModule module = LISTENER_MODULE_DYNAMIC_START;
765 CreateListenerModule();
766 ret = IsListenerNodeExist(module);
767 EXPECT_EQ(true, ret);
768
769 DeinitBaseListener();
770 ret = IsListenerNodeExist(module);
771 EXPECT_EQ(false, ret);
772 };
773
OnGetAllFdEvent(ListNode * list)774 static int32_t OnGetAllFdEvent(ListNode *list)
775 {
776 return SOFTBUS_OK;
777 }
778
779 /*
780 * @tc.name: AddEvent001
781 * @tc.desc: test AddEvent001 param is error
782 * @tc.type: FUNC
783 * @tc.require: I5PC1B
784 */
785 HWTEST_F(SoftbusConnCommonTest, AddEvent001, TestSize.Level1)
786 {
787 int32_t fd = -1;
788 int32_t ret = AddEvent(nullptr, fd, READ_TRIGGER);
789 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
790
791 EventWatcher watcher = {0};
792 watcher.watcherId = -1;
793
794 ret = AddEvent(&watcher, fd, READ_TRIGGER);
795 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
796 };
797
798 /*
799 * @tc.name: AddEvent002
800 * @tc.desc: test AddEvent002 param is error
801 * @tc.type: FUNC
802 * @tc.require: I5PC1B
803 */
804 HWTEST_F(SoftbusConnCommonTest, AddEvent002, TestSize.Level1)
805 {
806 int32_t fd = 1;
807 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
808
809 int32_t ret = AddEvent(watcher, fd, READ_TRIGGER);
810 EXPECT_EQ(SOFTBUS_OK, ret);
811
812 ret = AddEvent(watcher, -1, READ_TRIGGER);
813 EXPECT_TRUE(ret < 0);
814
815 CloseEventWatcher(watcher);
816 };
817
818 /*
819 * @tc.name: ModifyEvent001
820 * @tc.desc: test ModifyEvent001 param is error
821 * @tc.type: FUNC
822 * @tc.require: I5PC1B
823 */
824 HWTEST_F(SoftbusConnCommonTest, ModifyEvent001, TestSize.Level1)
825 {
826 int32_t fd = -1;
827
828 int32_t ret = ModifyEvent(nullptr, fd, READ_TRIGGER);
829 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
830
831 EventWatcher watcher = {0};
832 watcher.watcherId = -1;
833 ret = ModifyEvent(&watcher, fd, EXCEPT_TRIGGER);
834 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
835 };
836
837 /*
838 * @tc.name: ModifyEvent002
839 * @tc.desc: test ModifyEvent002 param is error
840 * @tc.type: FUNC
841 * @tc.require: I5PC1B
842 */
843 HWTEST_F(SoftbusConnCommonTest, ModifyEvent002, TestSize.Level1)
844 {
845 int32_t fd = 1;
846 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
847
848 AddEvent(watcher, fd, READ_TRIGGER);
849 int32_t ret = ModifyEvent(watcher, fd, WRITE_TRIGGER);
850 EXPECT_EQ(SOFTBUS_OK, ret);
851
852 ret = ModifyEvent(watcher, -1, READ_TRIGGER);
853 EXPECT_TRUE(ret < 0);
854
855 CloseEventWatcher(watcher);
856 };
857
858 /*
859 * @tc.name: RemoveEvent001
860 * @tc.desc: test RemoveEvent001 param is error
861 * @tc.type: FUNC
862 * @tc.require: I5PC1B
863 */
864 HWTEST_F(SoftbusConnCommonTest, RemoveEvent001, TestSize.Level1)
865 {
866 int32_t fd = -1;
867
868 int32_t ret = RemoveEvent(nullptr, fd);
869 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
870
871 EventWatcher watcher = {0};
872 watcher.watcherId = -1;
873 ret = RemoveEvent(&watcher, fd);
874 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
875 };
876
877 /*
878 * @tc.name: RemoveEvent002
879 * @tc.desc: test RemoveEvent002 param is error
880 * @tc.type: FUNC
881 * @tc.require: I5PC1B
882 */
883 HWTEST_F(SoftbusConnCommonTest, RemoveEvent002, TestSize.Level1)
884 {
885 int32_t fd = 1;
886 EventWatcher *watcher = RegisterEventWatcher(OnGetAllFdEvent);
887
888 AddEvent(watcher, fd, READ_TRIGGER);
889 int32_t ret = RemoveEvent(watcher, fd);
890 EXPECT_EQ(SOFTBUS_OK, ret);
891
892 ret = RemoveEvent(watcher, -1);
893 EXPECT_TRUE(ret < 0);
894
895 CloseEventWatcher(watcher);
896 };
897
898 /*
899 * @tc.name: WatchEvent001
900 * @tc.desc: test WatchEvent001 param is error
901 * @tc.type: FUNC
902 * @tc.require: I5PC1B
903 */
904 HWTEST_F(SoftbusConnCommonTest, WatchEvent001, TestSize.Level1)
905 {
906 ListNode fdEventNode;
907 ListInit(&fdEventNode);
908
909 int32_t ret = WatchEvent(nullptr, -1, &fdEventNode);
910 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
911
912 EventWatcher watcher = {0};
913 watcher.watcherId = -1;
914 ret = WatchEvent(&watcher, -1, &fdEventNode);
915 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
916
917 watcher.watcherId = 1;
918 ret = WatchEvent(&watcher, -1, &fdEventNode);
919 EXPECT_TRUE(ret < 0);
920 };
921
922 /*
923 * @tc.name: testUsbSocket001
924 * @tc.desc: test OpenUsbServerSocket
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(SoftbusConnCommonTest, testUsbSocket001, TestSize.Level1)
929 {
930 const SocketInterface *usb = GetUsbProtocol();
931 ASSERT_NE(usb, nullptr);
932
933 LocalListenerInfo info = {
934 .type = CONNECT_TCP,
935 .socketOption = {
936 .addr = "::1%lo",
937 .port = g_port,
938 .moduleId = DIRECT_CHANNEL_SERVER_USB,
939 .protocol = LNN_PROTOCOL_USB
940 }
941 };
942
943 SoftbusAdapterMock mock;
944 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
945 int32_t fd = usb->OpenServerSocket(&info);
946 int32_t ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
947 ASSERT_TRUE(ret == SOFTBUS_OK);
948 int32_t port = usb->GetSockPort(fd);
949 EXPECT_EQ(port, g_port);
950 ConnCloseSocket(fd);
951
952 info.socketOption.port = 0;
953 fd = usb->OpenServerSocket(&info);
954 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
955 EXPECT_EQ(ret, SOFTBUS_OK);
956 ConnCloseSocket(fd);
957
958 info.type = CONNECT_BLE;
959 fd = usb->OpenServerSocket(&info);
960 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
961 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
962 ConnCloseSocket(fd);
963
964 info.type = CONNECT_HML;
965 fd = usb->OpenServerSocket(&info);
966 ret = (fd <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
967 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
968 ConnCloseSocket(fd);
969
970 fd = usb->OpenServerSocket(nullptr);
971 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
972 ConnCloseSocket(fd);
973
974 info.socketOption.port = -1;
975 fd = usb->OpenServerSocket(&info);
976 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
977 ConnCloseSocket(fd);
978
979 info.type = CONNECT_P2P;
980 fd = usb->OpenServerSocket(&info);
981 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
982 ConnCloseSocket(fd);
983 };
984
985 /*
986 * @tc.name: testUsbSocket002
987 * @tc.desc: test OpenUsbUsbClientSocket
988 * @tc.type: FUNC
989 * @tc.require:
990 */
991 HWTEST_F(SoftbusConnCommonTest, testUsbSocket002, TestSize.Level1)
992 {
993 const SocketInterface *usb = GetUsbProtocol();
994 ASSERT_NE(usb, nullptr);
995
996 ConnectOption option = {
997 .type = CONNECT_TCP,
998 .socketOption = {
999 .addr = "::1%lo",
1000 .port = g_port,
1001 .moduleId = DIRECT_CHANNEL_SERVER_USB,
1002 .protocol = LNN_PROTOCOL_USB
1003 }
1004 };
1005
1006 SoftbusAdapterMock mock;
1007 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
1008 int32_t fd = usb->OpenClientSocket(nullptr, "::1%lo", false);
1009 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1010 ConnCloseSocket(fd);
1011
1012 fd = usb->OpenClientSocket(nullptr, nullptr, false);
1013 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1014 ConnCloseSocket(fd);
1015
1016 option.socketOption.port = 0;
1017 fd = usb->OpenClientSocket(&option, "::1%lo", false);
1018 int32_t ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1019 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1020 ConnCloseSocket(fd);
1021
1022 fd = usb->OpenClientSocket(&option, "", false);
1023 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1024 ConnCloseSocket(fd);
1025
1026 fd = usb->OpenClientSocket(&option, "::1%lo", true);
1027 ret = (fd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1028 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1029 ConnCloseSocket(fd);
1030
1031 option.socketOption.port = -1;
1032 fd = usb->OpenClientSocket(&option, "::1%lo", false);
1033 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1034 ConnCloseSocket(fd);
1035
1036 option.socketOption.port = -1;
1037 fd = usb->OpenClientSocket(&option, nullptr, false);
1038 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1039 ConnCloseSocket(fd);
1040
1041 option.type = CONNECT_P2P;
1042 fd = usb->OpenClientSocket(&option, nullptr, false);
1043 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1044 ConnCloseSocket(fd);
1045
1046 option.type = CONNECT_P2P;
1047 fd = usb->OpenClientSocket(&option, "::1%lo", false);
1048 EXPECT_EQ(fd, SOFTBUS_INVALID_PARAM);
1049 ConnCloseSocket(fd);
1050 };
1051
1052 /*
1053 * @tc.name: testUsbSocket003
1054 * @tc.desc: test GetUsbSockPort invalid fd
1055 * @tc.type: FUNC
1056 * @tc.require:
1057 */
1058 HWTEST_F(SoftbusConnCommonTest, testUsbSocket003, TestSize.Level1)
1059 {
1060 const SocketInterface *usb = GetUsbProtocol();
1061 ASSERT_NE(usb, nullptr);
1062 int32_t invalidFd = -1;
1063 int32_t port = usb->GetSockPort(invalidFd);
1064 int32_t ret = (port <= 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1065 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1066 };
1067
1068 /*
1069 * @tc.name: testUsbSocket004
1070 * @tc.desc: test AcceptUsbClient
1071 * @tc.type: FUNC
1072 * @tc.require:
1073 */
1074 HWTEST_F(SoftbusConnCommonTest, testUsbSocket004, TestSize.Level1)
1075 {
1076 const SocketInterface *usb = GetUsbProtocol();
1077 ASSERT_NE(usb, nullptr);
1078
1079 ConnectOption clientAddr = {
1080 .type = CONNECT_TCP,
1081 .socketOption = {
1082 .addr = "::1%lo",
1083 .port = g_port,
1084 .moduleId = DIRECT_CHANNEL_SERVER_USB,
1085 .protocol = LNN_PROTOCOL_USB
1086 }
1087 };
1088
1089 int32_t cfd = 11;
1090 SoftbusAdapterMock mock;
1091 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
1092 int32_t ret = usb->AcceptClient(TEST_FD, &clientAddr, &cfd);
1093 int32_t res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1094 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1095
1096 ret = usb->AcceptClient(TEST_FD, nullptr, &cfd);
1097 res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1098 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1099
1100 ret = usb->AcceptClient(TEST_FD, &clientAddr, &cfd);
1101 res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1102 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1103
1104 ret = usb->AcceptClient(INVALID_FD, &clientAddr, &cfd);
1105 res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1106 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1107
1108 ret = usb->AcceptClient(TEST_FD, nullptr, &cfd);
1109 res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1110 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1111
1112 ret = usb->AcceptClient(INVALID_FD, nullptr, &cfd);
1113 res = (ret != SOFTBUS_OK) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1114 EXPECT_EQ(res, SOFTBUS_INVALID_PARAM);
1115 };
1116
1117 /*
1118 * @tc.name: testUsbSocket005
1119 * @tc.desc: test ConnSendSocketData invalid fd
1120 * @tc.type: FUNC
1121 * @tc.require:
1122 */
1123 HWTEST_F(SoftbusConnCommonTest, testUsbSocket005, TestSize.Level1)
1124 {
1125 const SocketInterface *usb = GetUsbProtocol();
1126 ASSERT_NE(usb, nullptr);
1127
1128 SoftbusAdapterMock mock;
1129 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
1130 int32_t clientFd = usb->OpenClientSocket(nullptr, "::1%lo", false);
1131 int32_t ret = (clientFd < 0) ? SOFTBUS_INVALID_PARAM : SOFTBUS_OK;
1132 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1133 ssize_t bytes = ConnSendSocketData(clientFd, "Hello world", 11, 0);
1134 EXPECT_EQ(bytes, -1);
1135 ConnShutdownSocket(clientFd);
1136 };
1137
1138 /*
1139 * @tc.name: ConnGetPeerSocketAddr6001
1140 * @tc.desc: test ConnGetPeerSocketAddr is SUCC
1141 * @tc.type: FUNC
1142 * @tc.require: I5PC1B
1143 */
1144 HWTEST_F(SoftbusConnCommonTest, ConnGetPeerSocketAddr6001, TestSize.Level1)
1145 {
1146 int32_t ret;
1147 SoftbusAdapterMock mock;
1148 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_OK))
1149 .WillRepeatedly(SoftbusAdapterMock::ActionOfSoftBusSocketGetPeerName);
1150 ret = ConnGetPeerSocketAddr6(TEST_FD, &g_socketAddr6);
1151 EXPECT_EQ(SOFTBUS_OK, ret);
1152
1153 ret = ConnGetPeerSocketAddr6(TEST_FD, &g_socketAddr6);
1154 EXPECT_EQ(SOFTBUS_OK, ret);
1155 };
1156
1157 /*
1158 * @tc.name: ConnGetPeerSocketAddr6002
1159 * @tc.desc: test ConnGetPeerSocketAddr6 param is invalid
1160 * @tc.type: FUNC
1161 * @tc.require:
1162 */
1163 HWTEST_F(SoftbusConnCommonTest, ConnGetPeerSocketAddr6002, TestSize.Level1)
1164 {
1165 int32_t ret;
1166 SocketAddr socketAddr;
1167 SoftbusAdapterMock mock;
1168 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillOnce(Return(SOFTBUS_ADAPTER_ERR));
1169 ret = ConnGetPeerSocketAddr6(INVALID_FD, &socketAddr);
1170 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
1171 }
1172
1173 /*
1174 * @tc.name: ConnGetPeerSocketAddr6003
1175 * @tc.desc: test ConnGetPeerSocketAddr6 param is invalid
1176 * @tc.type: FUNC
1177 * @tc.require: I5PC1B
1178 */
1179 HWTEST_F(SoftbusConnCommonTest, ConnGetPeerSocketAddr6003, TestSize.Level1)
1180 {
1181 int32_t ret;
1182
1183 ret = ConnGetPeerSocketAddr6(TEST_FD, nullptr);
1184 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1185
1186 SoftbusAdapterMock mock;
1187 EXPECT_CALL(mock, SoftBusSocketGetPeerName).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
1188 ret = ConnGetPeerSocketAddr6(INVALID_FD, &g_socketAddr6);
1189 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
1190
1191 ret = ConnGetPeerSocketAddr6(TEST_FD, &g_socketAddr6);
1192 EXPECT_EQ(SOFTBUS_TCP_SOCKET_ERR, ret);
1193 };
1194
1195 /*
1196 * @tc.name: ConnSetTcpKeepaliveStateSucc
1197 * @tc.desc: test ConnSetTcpKeepaliveState set succ
1198 * @tc.type: FUNC
1199 * @tc.require: I5PC1B
1200 */
1201 HWTEST_F(SoftbusConnCommonTest, ConnSetTcpKeepaliveStateSucc, TestSize.Level1)
1202 {
1203 SoftbusAdapterMock mock;
1204 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_OK));
1205 auto ret = ConnSetTcpKeepaliveState(TEST_FD, true);
1206 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
1207 };
1208
1209 /*
1210 * @tc.name: ConnSetTcpKeepaliveStateFail
1211 * @tc.desc: test ConnSetTcpKeepaliveState set fail
1212 * @tc.type: FUNC
1213 * @tc.require: I5PC1B
1214 */
1215 HWTEST_F(SoftbusConnCommonTest, ConnSetTcpKeepaliveStateFail, TestSize.Level1)
1216 {
1217 SoftbusAdapterMock mock;
1218 EXPECT_CALL(mock, SoftBusSocketSetOpt).WillRepeatedly(Return(SOFTBUS_ADAPTER_ERR));
1219 auto ret = ConnSetTcpKeepaliveState(TEST_FD, true);
1220 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1221 };
1222 }
1223