1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <fcntl.h>
17 #include <securec.h>
18 #include <unistd.h>
19
20 #include "softbus_adapter_errcode.h"
21 #include "softbus_adapter_socket.h"
22 #include "softbus_error_code.h"
23 #include "gtest/gtest.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 const int32_t PROTOCOL_MAXLEN = 100;
30 const int32_t TEST_BUF_SIZE = 10;
31 const int32_t TEST_PORT = 8888;
32 const int32_t TEST_IPV6_PORT = 8089;
33 const int32_t LOCAL_HOST_VALUE = 16777343;
34 const int32_t CMD_EXIT = 0x11001100;
35 const int32_t CMD_RECV = 0x22002200;
36 const int32_t CMD_REPLY = 0x33003300;
37 const int32_t SET_SIZE = 100;
38 const int32_t WLAN_INDEX = 4;
39
40 SoftBusSockAddrIn g_serAddr = { .sinFamily = SOFTBUS_AF_INET,
41 .sinPort = SoftBusHtoNs(TEST_PORT),
42 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
43
44 struct SocketProtocol {
45 unsigned int cmd;
46 char data[PROTOCOL_MAXLEN];
47 };
48
49 class AdapterDsoftbusSocketTest : public testing::Test {
50 protected:
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp();
54 void TearDown();
55 };
56
SetUpTestCase(void)57 void AdapterDsoftbusSocketTest::SetUpTestCase(void) { }
58
TearDownTestCase(void)59 void AdapterDsoftbusSocketTest::TearDownTestCase(void) { }
60
SetUp()61 void AdapterDsoftbusSocketTest::SetUp() { }
62
TearDown()63 void AdapterDsoftbusSocketTest::TearDown() { }
64
SocketServiceStart(int32_t localFlag)65 static void SocketServiceStart(int32_t localFlag)
66 {
67 int32_t socketFd = -1;
68 int32_t optVal = 1;
69 int32_t backLog = 2;
70 SoftBusSockAddrIn cliAddr = { 0 };
71 int32_t acceptFd = -1;
72 struct SocketProtocol buf = { 0 };
73 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
74 EXPECT_EQ(0, ret);
75
76 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
77 EXPECT_EQ(0, ret);
78
79 ret = SoftBusSocketBind(socketFd, (SoftBusSockAddr *)&g_serAddr, sizeof(SoftBusSockAddrIn));
80 EXPECT_EQ(0, ret);
81
82 ret = SoftBusSocketListen(socketFd, backLog);
83 EXPECT_EQ(0, ret);
84 ret = SoftBusSocketAccept(socketFd, (SoftBusSockAddr *)&cliAddr, &acceptFd);
85 EXPECT_EQ(0, ret);
86
87 if (localFlag) {
88 char serviceIP[20];
89 SoftBusSockAddrIn serviceAddr;
90 SoftBusSocketGetLocalName(acceptFd, (SoftBusSockAddr *)&serviceAddr);
91 SoftBusInetNtoP(SOFTBUS_AF_INET, &serviceAddr.sinAddr, serviceIP, sizeof(serviceIP));
92 uint16_t port = SoftBusNtoHs(serviceAddr.sinPort);
93 EXPECT_EQ(port, TEST_PORT);
94 }
95
96 while (1) {
97 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
98 ret = SoftBusSocketRecv(acceptFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
99 EXPECT_TRUE(ret != -1);
100 if (buf.cmd == CMD_EXIT) {
101 break;
102 } else if (buf.cmd == CMD_RECV) {
103 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
104 buf.cmd = CMD_REPLY;
105 (void)strcpy_s(buf.data, sizeof(buf.data), "Beautiful World!");
106 ret = SoftBusSocketSend(acceptFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
107 EXPECT_TRUE(ret != -1);
108 } else {
109 printf("unknown cmd\n");
110 }
111 }
112
113 ret = SoftBusSocketClose(acceptFd);
114 EXPECT_EQ(0, ret);
115 ret = SoftBusSocketClose(socketFd);
116 EXPECT_EQ(0, ret);
117 printf("socket service will exit\n");
118 _exit(0);
119 }
120
SocketIpv6ServiceStart(int localFlag)121 static void SocketIpv6ServiceStart(int localFlag)
122 {
123 int32_t socketFd = -1;
124 int32_t optVal = 1;
125 int32_t backLog = 2;
126 SoftBusSockAddrIn cliAddr = { 0 };
127 int32_t acceptFd = -1;
128 struct SocketProtocol buf = { 0 };
129 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, &socketFd);
130 EXPECT_EQ(0, ret);
131
132 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
133 EXPECT_EQ(0, ret);
134 SoftBusSockAddrIn6 addrIn6 = { 0 };
135 addrIn6.sin6Family = SOFTBUS_AF_INET6;
136 addrIn6.sin6Port = SoftBusHtoNs(TEST_IPV6_PORT);
137 const char *srcAddr = "::1";
138 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
139 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
140 ret = SoftBusSocketBind(socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
141 EXPECT_EQ(0, ret);
142
143 ret = SoftBusSocketListen(socketFd, backLog);
144 EXPECT_EQ(0, ret);
145 ret = SoftBusSocketAccept(socketFd, (SoftBusSockAddr *)&cliAddr, &acceptFd);
146 EXPECT_EQ(0, ret);
147
148 if (localFlag) {
149 char serviceIP[46];
150 SoftBusSockAddrIn6 serviceAddr6 = { 0 };
151 SoftBusSocketGetLocalName(acceptFd, (SoftBusSockAddr *)&serviceAddr6);
152 SoftBusInetNtoP(SOFTBUS_AF_INET6, &serviceAddr6.sin6Addr, serviceIP, sizeof(serviceIP));
153 uint16_t port = SoftBusNtoHs(serviceAddr6.sin6Port);
154 EXPECT_EQ(port, TEST_IPV6_PORT);
155 }
156
157 while (1) {
158 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
159 ret = SoftBusSocketRecv(acceptFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
160 EXPECT_TRUE(ret != -1);
161 if (buf.cmd == CMD_EXIT) {
162 break;
163 } else if (buf.cmd == CMD_RECV) {
164 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
165 buf.cmd = CMD_REPLY;
166 (void)strcpy_s(buf.data, sizeof(buf.data), "Beautiful World!");
167 ret = SoftBusSocketSend(acceptFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
168 EXPECT_TRUE(ret != -1);
169 } else {
170 printf("unknown cmd\n");
171 }
172 }
173
174 ret = SoftBusSocketClose(acceptFd);
175 EXPECT_EQ(0, ret);
176 ret = SoftBusSocketClose(socketFd);
177 EXPECT_EQ(0, ret);
178 printf("socket ipv6 service will exit\n");
179 _exit(0);
180 }
181
ClientConnect(int32_t * socketFd)182 static void ClientConnect(int32_t *socketFd)
183 {
184 EXPECT_TRUE(socketFd != nullptr);
185 SoftBusSockAddrIn serAddr = { .sinFamily = SOFTBUS_AF_INET,
186 .sinPort = SoftBusHtoNs(8888),
187 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
188 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, socketFd);
189 EXPECT_EQ(0, ret);
190 ret = SoftBusSocketConnect(*socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
191 EXPECT_EQ(0, ret);
192 }
193
ClientIpv6Connect(int32_t * socketFd)194 static void ClientIpv6Connect(int32_t *socketFd)
195 {
196 EXPECT_TRUE(socketFd != nullptr);
197 SoftBusSockAddrIn6 addrIn6 = { 0 };
198 addrIn6.sin6Family = SOFTBUS_AF_INET6;
199 addrIn6.sin6Port = SoftBusHtoNs(TEST_IPV6_PORT);
200 const char *srcAddr = "::1";
201 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
202 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
203 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, socketFd);
204 EXPECT_EQ(0, ret);
205 ret = SoftBusSocketConnect(*socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
206 EXPECT_EQ(0, ret);
207 }
208
ClientExit(int32_t socketFd)209 static void ClientExit(int32_t socketFd)
210 {
211 struct SocketProtocol buf = {
212 .cmd = CMD_EXIT,
213 };
214 int32_t ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
215 EXPECT_TRUE(ret != -1);
216 ret = SoftBusSocketClose(socketFd);
217 EXPECT_EQ(0, ret);
218 sleep(1);
219 }
220
221 /*
222 * @tc.name: SoftBusSocketCreate001
223 * @tc.desc: Create Socket Success
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCreate001, TestSize.Level0)
228 {
229 int32_t socketFd = -1;
230 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
231 EXPECT_EQ(0, ret);
232 ret = SoftBusSocketClose(socketFd);
233 EXPECT_EQ(0, ret);
234
235 ret = SoftBusSocketCreate(
236 SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM | SOFTBUS_SOCK_NONBLOCK | SOFTBUS_SOCK_CLOEXEC, 0, &socketFd);
237 EXPECT_EQ(0, ret);
238 ret = SoftBusSocketClose(socketFd);
239 EXPECT_EQ(0, ret);
240 }
241
242 /*
243 * @tc.name: SoftBusSocketCreate002
244 * @tc.desc: Error Domain
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCreate002, TestSize.Level0)
249 {
250 int32_t socketFd = -1;
251 int32_t ret = SoftBusSocketCreate(-1, SOFTBUS_SOCK_STREAM, 0, &socketFd);
252 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
253 }
254
255 /*
256 * @tc.name: SoftBusSocketCreate003
257 * @tc.desc: Error type
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCreate003, TestSize.Level0)
262 {
263 int32_t socketFd = -1;
264 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, 0, 0, &socketFd);
265 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
266 ret = SoftBusSocketCreate(SOFTBUS_AF_INET, 0xFFFFFFFF, 0, &socketFd);
267 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
268 }
269
270 /*
271 * @tc.name: SoftBusSocketCreate004
272 * @tc.desc: Error protocol
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCreate004, TestSize.Level0)
277 {
278 int32_t socketFd = -1;
279 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, 0, -1, &socketFd);
280 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
281 }
282
283 /*
284 * @tc.name: SoftBusSocketCreate005
285 * @tc.desc: Error socketFd
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCreate005, TestSize.Level0)
290 {
291 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, nullptr);
292 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
293 }
294
295 /*
296 * @tc.name: SoftBusSocketSetOptTest001
297 * @tc.desc: opt set success
298 * @tc.type: FUNC
299 * @tc.require: 1
300 */
301 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest001, TestSize.Level0)
302 {
303 int32_t socketFd = -1;
304 int32_t optVal = 1;
305 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
306 EXPECT_EQ(0, ret);
307
308 SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
309 EXPECT_EQ(0, ret);
310
311 ret = SoftBusSocketClose(socketFd);
312 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
313 }
314
315 /*
316 * @tc.name: SoftBusSocketSetOptTest002
317 * @tc.desc: select SOFTBUS_IPPROTO_IP Protocol
318 * @tc.type: FUNC
319 * @tc.require: 1
320 */
321 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest002, TestSize.Level0)
322 {
323 int32_t socketFd;
324 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
325 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
326 int32_t optVal = 1;
327 int32_t optValLen = sizeof(int);
328 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_IPPROTO_IP, SOFTBUS_IP_TOS, &optVal, optValLen);
329 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
330
331 ret = SoftBusSocketClose(socketFd);
332 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
333 }
334
335 /*
336 * @tc.name: SoftBusSocketSetOptTest003
337 * @tc.desc: select SOFTBUS_SO_KEEPALIVE Protocol
338 * @tc.type: FUNC
339 * @tc.require: 1
340 */
341 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest003, TestSize.Level0)
342 {
343 int32_t socketFd;
344 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
345 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
346
347 int32_t optVal = 1;
348 int32_t optValLen = sizeof(int);
349 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_KEEPALIVE, &optVal, optValLen);
350 EXPECT_EQ(0, ret);
351
352 ret = SoftBusSocketClose(socketFd);
353 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
354 }
355
356 /*
357 * @tc.name: SoftBusSocketSetOptTest004
358 * @tc.desc: socketFd illegal
359 * @tc.type: FUNC
360 * @tc.require: 1
361 */
362 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest004, TestSize.Level0)
363 {
364 int32_t optVal = 1;
365 int32_t optValLen = sizeof(int);
366 int32_t ret = SoftBusSocketSetOpt(-1, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, optValLen);
367 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
368 }
369
370 /*
371 * @tc.name: SoftBusSocketSetOptTest005
372 * @tc.desc: Protocol is illegal
373 * @tc.type: FUNC
374 * @tc.require: 1
375 */
376 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest005, TestSize.Level0)
377 {
378 int32_t socketFd;
379 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
380 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
381 int32_t optVal = 10;
382 int32_t optValLen = sizeof(int);
383 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_IPPROTO_IP, -1, &optVal, optValLen);
384 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
385
386 ret = SoftBusSocketClose(socketFd);
387 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
388 }
389
390 /*
391 * @tc.name: SoftBusSocketSetOptTest006
392 * @tc.desc: optVal is illegal
393 * @tc.type: FUNC
394 * @tc.require: 1
395 */
396 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest006, TestSize.Level0)
397 {
398 int32_t socketFd;
399 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
400 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
401 int32_t optValLen = sizeof(int);
402 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_IPPROTO_IP, SOFTBUS_IP_TOS, nullptr, optValLen);
403 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
404
405 ret = SoftBusSocketClose(socketFd);
406 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
407 }
408
409 #if HAVE_PRO
410 /*
411 * @tc.name: SoftBusSocketSetOptTest007
412 * @tc.desc: optValLen is illegal
413 * @tc.type: FUNC
414 * @tc.require: 1
415 */
416 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSetOptTest007, TestSize.Level0)
417 {
418 int32_t socketFd;
419 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
420 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
421 int32_t optVal = 1;
422 ret = SoftBusSocketSetOpt(socketFd, SOFTBUS_IPPROTO_IP, SOFTBUS_IP_TOS, &optVal, -1);
423 EXPECT_EQ(-1, ret);
424
425 ret = SoftBusSocketClose(socketFd);
426 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
427 }
428 #endif
429
430 /*
431 * @tc.name: SoftBusSocketGetOptTest001
432 * @tc.desc: positive
433 * @tc.type: FUNC
434 * @tc.require: 1
435 */
436 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetOptTest001, TestSize.Level0)
437 {
438 int32_t socketFd;
439 int32_t on = 1;
440 int32_t onLen = sizeof(on);
441 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
442 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
443 ret = SoftBusSocketGetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &on, &onLen);
444 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
445 ret = SoftBusSocketClose(socketFd);
446 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
447 }
448
449 /*
450 * @tc.name: SoftBusSocketGetOptTest002
451 * @tc.desc: socketFd illegal
452 * @tc.type: FUNC
453 * @tc.require: 1
454 */
455 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetOptTest002, TestSize.Level0)
456 {
457 int32_t on = 1;
458 int32_t onLen = sizeof(on);
459 int32_t rc = SoftBusSocketGetOpt(-1, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &on, &onLen);
460 EXPECT_TRUE(rc == -1);
461 }
462
463 /*
464 * @tc.name: SoftBusSocketGetLocalNameTest001
465 * @tc.desc: test in service get port
466 * @tc.type: FUNC
467 * @tc.require: 1
468 */
469 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest001, TestSize.Level0)
470 {
471 sleep(1);
472 int32_t pid = -1;
473 if ((pid = fork()) == 0) {
474 SocketServiceStart(1);
475 return;
476 }
477 sleep(1);
478 int32_t socketFd = -1;
479
480 ClientConnect(&socketFd);
481
482 ClientExit(socketFd);
483 return;
484 }
485
486 /*
487 * @tc.name: SoftBusSocketGetLocalNameTest002
488 * @tc.desc: socketFd illegal
489 * @tc.type: FUNC
490 * @tc.require: 1
491 */
492 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest002, TestSize.Level0)
493 {
494 int32_t socketFd = -1;
495 SoftBusSockAddrIn clientAddr;
496 int32_t ret = SoftBusSocketGetLocalName(socketFd, (SoftBusSockAddr *)&clientAddr);
497 EXPECT_EQ(-1, ret);
498 }
499
500 /*
501 * @tc.name: SoftBusSocketGetLocalNameTest003
502 * @tc.desc: addr is null
503 * @tc.type: FUNC
504 * @tc.require: 1
505 */
506 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest003, TestSize.Level0)
507 {
508 sleep(1);
509 int32_t pid = -1;
510 if ((pid = fork()) == 0) {
511 SocketServiceStart(0);
512 return;
513 }
514 sleep(1);
515 int32_t ret;
516 int32_t socketFd = -1;
517
518 ClientConnect(&socketFd);
519
520 ret = SoftBusSocketGetLocalName(socketFd, nullptr);
521 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
522
523 ClientExit(socketFd);
524 }
525
526 /*
527 * @tc.name: SoftBusSocketGetLocalNameTest004
528 * @tc.desc: addrLen is null
529 * @tc.type: FUNC
530 * @tc.require: 1
531 */
532 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest004, TestSize.Level0)
533 {
534 sleep(1);
535 int32_t pid = -1;
536 if ((pid = fork()) == 0) {
537 SocketServiceStart(0);
538 return;
539 }
540 sleep(1);
541 int32_t ret;
542 int32_t socketFd = -1;
543
544 ClientConnect(&socketFd);
545
546 SoftBusSockAddrIn clientAddr;
547 ret = SoftBusSocketGetLocalName(socketFd, (SoftBusSockAddr *)&clientAddr);
548 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
549
550 ClientExit(socketFd);
551 }
552
553 /*
554 * @tc.name: SoftBusSocketGetLocalNameTest005
555 * @tc.desc: socketFd is service fd
556 * @tc.type: FUNC
557 * @tc.require: 1
558 */
559 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest005, TestSize.Level0)
560 {
561 int32_t socketFd;
562 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
563 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
564 SoftBusSockAddrIn clientAddr;
565 ret = SoftBusSocketGetLocalName(socketFd, (SoftBusSockAddr *)&clientAddr);
566 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
567
568 ret = SoftBusSocketClose(socketFd);
569 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
570 }
571
572 /*
573 * @tc.name: SoftBusSocketGetLocalNameTest006
574 * @tc.desc: socketFd illegal
575 * @tc.type: FUNC
576 * @tc.require: 1
577 */
578 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest006, TestSize.Level0)
579 {
580 int32_t socketFd = -1;
581 SoftBusSockAddrIn6 clientAddr6 = { 0 };
582 int32_t ret = SoftBusSocketGetLocalName(socketFd, (SoftBusSockAddr *)&clientAddr6);
583 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
584 }
585
586 /*
587 * @tc.name: SoftBusSocketGetLocalNameTest007
588 * @tc.desc: addrLen is null
589 * @tc.type: FUNC
590 * @tc.require: 1
591 */
592 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetLocalNameTest007, TestSize.Level0)
593 {
594 sleep(1);
595 int32_t pid = -1;
596 if ((pid = fork()) == 0) {
597 SocketIpv6ServiceStart(0);
598 return;
599 }
600 sleep(1);
601 int32_t ret;
602 int32_t socketFd = -1;
603
604 ClientIpv6Connect(&socketFd);
605
606 SoftBusSockAddrIn6 clientAddr6 = { 0 };
607 ret = SoftBusSocketGetLocalName(socketFd, (SoftBusSockAddr *)&clientAddr6);
608 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
609
610 ClientExit(socketFd);
611 }
612
613 /*
614 * @tc.name: SoftBusSocketGetPeerNameTest001
615 * @tc.desc: get service port success
616 * @tc.type: FUNC
617 * @tc.require: 1
618 */
619 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest001, TestSize.Level0)
620 {
621 sleep(1);
622 int32_t pid = -1;
623 if ((pid = fork()) == 0) {
624 SocketServiceStart(0);
625 return;
626 }
627 sleep(1);
628 int32_t ret;
629 int32_t socketFd = -1;
630
631 ClientConnect(&socketFd);
632
633 char serviceIP[20];
634 SoftBusSockAddrIn serviceAddr;
635
636 ret = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&serviceAddr);
637 EXPECT_EQ(0, ret);
638 SoftBusInetNtoP(SOFTBUS_AF_INET, &serviceAddr.sinAddr, serviceIP, sizeof(serviceIP));
639 uint16_t port = SoftBusNtoHs(serviceAddr.sinPort);
640 EXPECT_EQ(TEST_PORT, port);
641
642 ClientExit(socketFd);
643 }
644
645 /*
646 * @tc.name: SoftBusSocketGetPeerNameTest002
647 * @tc.desc: socketFd illegal
648 * @tc.type: FUNC
649 * @tc.require: 1
650 */
651 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest002, TestSize.Level0)
652 {
653 SoftBusSockAddr addr;
654 int32_t rc = SoftBusSocketGetPeerName(-1, &addr);
655 EXPECT_TRUE(rc == -1);
656 }
657
658 /*
659 * @tc.name: SoftBusSocketGetPeerNameTest003
660 * @tc.desc: get service port success
661 * @tc.type: FUNC
662 * @tc.require: 1
663 */
664 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest003, TestSize.Level0)
665 {
666 sleep(1);
667 int32_t pid = -1;
668 if ((pid = fork()) == 0) {
669 SocketServiceStart(0);
670 return;
671 }
672 sleep(1);
673 int32_t ret;
674 int32_t socketFd = -1;
675
676 ClientConnect(&socketFd);
677
678 ret = SoftBusSocketGetPeerName(socketFd, nullptr);
679 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
680
681 ClientExit(socketFd);
682 }
683
684 /*
685 * @tc.name: SoftBusSocketGetPeerNameTest004
686 * @tc.desc: get service port success
687 * @tc.type: FUNC
688 * @tc.require: 1
689 */
690 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest004, TestSize.Level0)
691 {
692 sleep(1);
693 int32_t pid = -1;
694 if ((pid = fork()) == 0) {
695 SocketServiceStart(0);
696 return;
697 }
698 sleep(1);
699 int32_t ret;
700 int32_t socketFd = -1;
701
702 ClientConnect(&socketFd);
703
704 SoftBusSockAddrIn serviceAddr;
705
706 ret = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&serviceAddr);
707 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
708
709 ClientExit(socketFd);
710 }
711
712 /*
713 * @tc.name: SoftBusSocketGetPeerNameTest005
714 * @tc.desc: socketFd is illegal
715 * @tc.type: FUNC
716 * @tc.require: 1
717 */
718 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest005, TestSize.Level0)
719 {
720 int32_t socketFd;
721 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
722 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
723 SoftBusSockAddrIn serviceAddr;
724 ret = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&serviceAddr);
725 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
726
727 ret = SoftBusSocketClose(socketFd);
728 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
729 }
730
731 /*
732 * @tc.name: SoftBusSocketGetPeerNameTest006
733 * @tc.desc: get service port success
734 * @tc.type: FUNC
735 * @tc.require: 1
736 */
737 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketGetPeerNameTest006, TestSize.Level0)
738 {
739 sleep(1);
740 int32_t pid = -1;
741 if ((pid = fork()) == 0) {
742 SocketIpv6ServiceStart(0);
743 return;
744 }
745 sleep(1);
746 int32_t ret;
747 int32_t socketFd = -1;
748
749 ClientIpv6Connect(&socketFd);
750
751 char serviceIP[46];
752 SoftBusSockAddrIn6 serviceAddr6 { 0 };
753
754 ret = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&serviceAddr6);
755 EXPECT_EQ(0, ret);
756 SoftBusInetNtoP(SOFTBUS_AF_INET6, &serviceAddr6.sin6Addr, serviceIP, sizeof(serviceIP));
757 uint16_t port = SoftBusNtoHs(serviceAddr6.sin6Port);
758 EXPECT_EQ(TEST_IPV6_PORT, port);
759
760 ClientExit(socketFd);
761 }
762
763 /*
764 * @tc.name: SoftBusSocketBind001
765 * @tc.desc: Bind Socket Success
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketBind001, TestSize.Level0)
770 {
771 int32_t socketFd = -1;
772 SoftBusSockAddr addr = {
773 .saFamily = SOFTBUS_AF_INET,
774 };
775 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
776 EXPECT_EQ(0, ret);
777 ret = SoftBusSocketBind(socketFd, &addr, sizeof(SoftBusSockAddrIn));
778 EXPECT_EQ(0, ret);
779 ret = SoftBusSocketClose(socketFd);
780 EXPECT_EQ(0, ret);
781 }
782
783 /*
784 * @tc.name: SoftBusSocketBind002
785 * @tc.desc: addrLen is illegal
786 * @tc.type: FUNC
787 * @tc.require:
788 */
789 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketBind002, TestSize.Level0)
790 {
791 int32_t socketFd = -1;
792 SoftBusSockAddr addr = {
793 .saFamily = SOFTBUS_AF_INET,
794 };
795 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
796 EXPECT_EQ(0, ret);
797 ret = SoftBusSocketBind(socketFd, &addr, sizeof(SoftBusSockAddrIn) - 1);
798 EXPECT_NE(0, ret);
799 ret = SoftBusSocketClose(socketFd);
800 EXPECT_EQ(0, ret);
801 }
802
803 /*
804 * @tc.name: SoftBusSocketBind003
805 * @tc.desc: socketFd is illegal
806 * @tc.type: FUNC
807 * @tc.require:
808 */
809 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketBind003, TestSize.Level0)
810 {
811 int32_t socketFd = -1;
812 SoftBusSockAddr addr = {
813 .saFamily = SOFTBUS_AF_INET,
814 };
815 int32_t ret = SoftBusSocketBind(socketFd, &addr, sizeof(SoftBusSockAddrIn));
816 EXPECT_NE(0, ret);
817 }
818
819 /*
820 * @tc.name: SoftBusSocketBind004
821 * @tc.desc: addr is illegal
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketBind004, TestSize.Level0)
826 {
827 int32_t socketFd = -1;
828 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
829 EXPECT_EQ(0, ret);
830 ret = SoftBusSocketBind(socketFd, nullptr, sizeof(SoftBusSockAddrIn));
831 EXPECT_EQ(-1, ret);
832 ret = SoftBusSocketClose(socketFd);
833 EXPECT_EQ(0, ret);
834 }
835
836 /*
837 * @tc.name: SoftBusSocketBind005
838 * @tc.desc: Bind Socket Success
839 * @tc.type: FUNC
840 * @tc.require:
841 */
842 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketBind005, TestSize.Level0)
843 {
844 int32_t socketFd = -1;
845 SoftBusSockAddrIn6 addrIn6 = { 0 };
846 addrIn6.sin6Family = SOFTBUS_AF_INET6;
847 addrIn6.sin6Port = SoftBusHtoNs(TEST_IPV6_PORT);
848 const char *srcAddr = "::1";
849 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
850 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
851 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, &socketFd);
852 EXPECT_EQ(0, ret);
853 ret = SoftBusSocketBind(socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
854 EXPECT_NE(SOFTBUS_ADAPTER_OK, ret);
855 ret = SoftBusSocketClose(socketFd);
856 EXPECT_EQ(0, ret);
857 }
858
859 /*
860 * @tc.name: SoftBusSocketListen001
861 * @tc.desc: Listen Socket Success
862 * @tc.type: FUNC
863 * @tc.require:
864 */
865 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketListen001, TestSize.Level0)
866 {
867 int32_t socketFd = -1;
868 int32_t backLog = 2;
869 SoftBusSockAddr addr = {
870 .saFamily = SOFTBUS_AF_INET,
871 };
872 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
873 EXPECT_EQ(0, ret);
874
875 ret = SoftBusSocketBind(socketFd, &addr, sizeof(SoftBusSockAddrIn));
876 EXPECT_EQ(0, ret);
877
878 ret = SoftBusSocketListen(socketFd, backLog);
879 EXPECT_EQ(0, ret);
880
881 ret = SoftBusSocketClose(socketFd);
882 EXPECT_EQ(0, ret);
883 }
884
885 /*
886 * @tc.name: SoftBusSocketListen002
887 * @tc.desc: backlog is illegal
888 * @tc.type: FUNC
889 * @tc.require:
890 */
891 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketListen002, TestSize.Level0)
892 {
893 int32_t socketFd = -1;
894 int32_t backLog = -1;
895 SoftBusSockAddr addr = {
896 .saFamily = SOFTBUS_AF_INET,
897 };
898 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
899 EXPECT_EQ(0, ret);
900
901 ret = SoftBusSocketBind(socketFd, &addr, sizeof(SoftBusSockAddrIn));
902 EXPECT_EQ(0, ret);
903
904 ret = SoftBusSocketListen(socketFd, backLog);
905 EXPECT_EQ(0, ret);
906
907 ret = SoftBusSocketClose(socketFd);
908 EXPECT_EQ(0, ret);
909 }
910
911 /*
912 * @tc.name: SoftBusSocketListen003
913 * @tc.desc: socketFd is illegal
914 * @tc.type: FUNC
915 * @tc.require:
916 */
917 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketListen003, TestSize.Level0)
918 {
919 int32_t socketFd = -1;
920 int32_t backLog = 2;
921
922 int32_t ret = SoftBusSocketListen(socketFd, backLog);
923 EXPECT_EQ(-1, ret);
924 }
925
926 /*
927 * @tc.name: SoftBusSocketListen004
928 * @tc.desc: Listen Socket Success
929 * @tc.type: FUNC
930 * @tc.require:
931 */
932 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketListen004, TestSize.Level0)
933 {
934 int32_t socketFd = -1;
935 int32_t backLog = 2;
936 SoftBusSockAddrIn6 addrIn6 = { 0 };
937 addrIn6.sin6Family = SOFTBUS_AF_INET6;
938 addrIn6.sin6Port = SoftBusHtoNs(TEST_IPV6_PORT);
939 const char *srcAddr = "::1";
940 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
941 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
942 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, &socketFd);
943 EXPECT_EQ(0, ret);
944
945 ret = SoftBusSocketBind(socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
946 EXPECT_NE(SOFTBUS_ADAPTER_OK, ret);
947
948 ret = SoftBusSocketListen(socketFd, backLog);
949 EXPECT_EQ(0, ret);
950
951 ret = SoftBusSocketClose(socketFd);
952 EXPECT_EQ(0, ret);
953 }
954
955 /*
956 * @tc.name: SoftBusSocketAccept001
957 * @tc.desc: Accept Socket Success
958 * @tc.type: FUNC
959 * @tc.require:
960 */
961 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketAccept001, TestSize.Level0)
962 {
963 sleep(1);
964 int32_t pid = -1;
965 if ((pid = fork()) == 0) {
966 SocketServiceStart(0);
967 return;
968 }
969 sleep(1);
970 int32_t socketFd = -1;
971
972 ClientConnect(&socketFd);
973 EXPECT_TRUE(socketFd != -1);
974
975 ClientExit(socketFd);
976 }
977
978 /*
979 * @tc.name: SoftBusSocketAccept002
980 * @tc.desc: socketFd is illegal
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketAccept002, TestSize.Level0)
985 {
986 int32_t socketFd = -1;
987 int32_t acceptFd = -1;
988 SoftBusSockAddr addr = {
989 .saFamily = SOFTBUS_AF_INET,
990 };
991 int32_t ret = SoftBusSocketAccept(socketFd, &addr, &acceptFd);
992 EXPECT_NE(0, ret);
993 }
994
995 /*
996 * @tc.name: SoftBusSocketAccept003
997 * @tc.desc: acceptFd is illegal
998 * @tc.type: FUNC
999 * @tc.require:
1000 */
1001 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketAccept003, TestSize.Level0)
1002 {
1003 int32_t socketFd = -1;
1004 int32_t optVal = 1;
1005 int32_t backLog = 2;
1006 SoftBusSockAddrIn serAddr = { .sinFamily = SOFTBUS_AF_INET,
1007 .sinPort = SoftBusHtoNs(TEST_PORT),
1008 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
1009 SoftBusSockAddrIn cliAddr = { 0 };
1010 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1011 EXPECT_EQ(0, ret);
1012
1013 SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
1014 EXPECT_EQ(0, ret);
1015 ret = SoftBusSocketBind(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1016 EXPECT_EQ(0, ret);
1017
1018 ret = SoftBusSocketListen(socketFd, backLog);
1019 EXPECT_EQ(0, ret);
1020 ret = SoftBusSocketAccept(socketFd, (SoftBusSockAddr *)&cliAddr, nullptr);
1021 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1022
1023 ret = SoftBusSocketClose(socketFd);
1024 EXPECT_EQ(0, ret);
1025 }
1026
1027 /*
1028 * @tc.name: SoftBusSocketConnect001
1029 * @tc.desc: connect success
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketConnect001, TestSize.Level0)
1034 {
1035 sleep(1);
1036 int32_t pid = -1;
1037 if ((pid = fork()) == 0) {
1038 SocketServiceStart(1);
1039 return;
1040 }
1041 sleep(1);
1042 int32_t socketFd = -1;
1043
1044 ClientConnect(&socketFd);
1045 EXPECT_TRUE(socketFd != -1);
1046
1047 ClientExit(socketFd);
1048 }
1049
1050 /*
1051 * @tc.name: SoftBusSocketConnect002
1052 * @tc.desc: socketFd is illegal
1053 * @tc.type: FUNC
1054 * @tc.require:
1055 */
1056 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketConnect002, TestSize.Level0)
1057 {
1058 int32_t socketFd = -1;
1059 SoftBusSockAddr addr = {
1060 .saFamily = SOFTBUS_AF_INET,
1061 };
1062 int32_t ret = SoftBusSocketConnect(socketFd, &addr, sizeof(SoftBusSockAddrIn));
1063 EXPECT_NE(0, ret);
1064 }
1065
1066 /*
1067 * @tc.name: SoftBusSocketConnect003
1068 * @tc.desc: addr is illegal
1069 * @tc.type: FUNC
1070 * @tc.require:
1071 */
1072 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketConnect003, TestSize.Level0)
1073 {
1074 int32_t socketFd = -1;
1075 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1076 EXPECT_EQ(0, ret);
1077 ret = SoftBusSocketConnect(socketFd, nullptr, -1);
1078 EXPECT_TRUE(ret < 0);
1079 ret = SoftBusSocketClose(socketFd);
1080 EXPECT_EQ(0, ret);
1081 }
1082
1083 /*
1084 * @tc.name: SoftBusSocketConnect004
1085 * @tc.desc: addrLen is illegal
1086 * @tc.type: FUNC
1087 * @tc.require:
1088 */
1089 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketConnect004, TestSize.Level0)
1090 {
1091 int32_t socketFd = -1;
1092 SoftBusSockAddrIn serAddr = { .sinFamily = SOFTBUS_AF_INET,
1093 .sinPort = SoftBusHtoNs(8888),
1094 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
1095 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1096 EXPECT_EQ(0, ret);
1097 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1098 EXPECT_NE(0, ret);
1099 ret = SoftBusSocketClose(socketFd);
1100 EXPECT_EQ(0, ret);
1101 }
1102
1103 /*
1104 * @tc.name: SoftBusSocketConnect005
1105 * @tc.desc: addrLen is illegal
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketConnect005, TestSize.Level0)
1110 {
1111 int32_t socketFd = -1;
1112 SoftBusSockAddrIn6 addrIn6 = { 0 };
1113 addrIn6.sin6Family = SOFTBUS_AF_INET6;
1114 addrIn6.sin6Port = SoftBusHtoNs(TEST_PORT);
1115 const char *srcAddr = "::1";
1116 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
1117 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
1118 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1119 EXPECT_EQ(0, ret);
1120 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
1121 EXPECT_NE(0, ret);
1122 ret = SoftBusSocketClose(socketFd);
1123 EXPECT_EQ(0, ret);
1124 }
1125
1126 /*
1127 * @tc.name: SoftBusSocketFdZeroTest001
1128 * @tc.desc: set fdsBits zero success
1129 * @tc.type: FUNC
1130 * @tc.require: 1
1131 */
1132 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdZeroTest001, TestSize.Level0)
1133 {
1134 SoftBusFdSet set = { 0 };
1135 set.fdsBits[0] = 1;
1136 SoftBusSocketFdZero(&set);
1137 EXPECT_TRUE(set.fdsBits[0] == 0);
1138 }
1139
1140 /*
1141 * @tc.name: SoftBusSocketFdSetTest001
1142 * @tc.desc: socketFd set success
1143 * @tc.type: FUNC
1144 * @tc.require: 1
1145 */
1146 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdSetTest001, TestSize.Level0)
1147 {
1148 int32_t socketFd;
1149 SoftBusFdSet set = { 0 };
1150 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1151 EXPECT_EQ(0, ret);
1152 SoftBusSocketFdSet(socketFd, &set);
1153 ret = SoftBusSocketClose(socketFd);
1154 EXPECT_EQ(0, ret);
1155 }
1156
1157 /*
1158 * @tc.name: SoftBusSocketFdSetTest003
1159 * @tc.desc: set is NULL
1160 * @tc.type: FUNC
1161 * @tc.require: 1
1162 */
1163 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdSetTest003, TestSize.Level0)
1164 {
1165 int32_t socketFd;
1166 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1167 EXPECT_EQ(0, ret);
1168 SoftBusSocketFdSet(socketFd, nullptr);
1169
1170 ret = SoftBusSocketClose(socketFd);
1171 EXPECT_EQ(0, ret);
1172 }
1173
1174 /*
1175 * @tc.name: SoftBusSocketFdClrTest001
1176 * @tc.desc: fd clr success
1177 * @tc.type: FUNC
1178 * @tc.require: 1
1179 */
1180 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdClrTest001, TestSize.Level0)
1181 {
1182 SoftBusFdSet set;
1183 SoftBusSocketFdZero(&set);
1184 SoftBusSocketFdSet(1, &set);
1185 SoftBusSocketFdClr(1, &set);
1186 EXPECT_TRUE(set.fdsBits[0] == 0);
1187 }
1188
1189 /*
1190 * @tc.name: SoftBusSocketFdIssetTest001
1191 * @tc.desc: FdIsset success
1192 * @tc.type: FUNC
1193 * @tc.require: 1
1194 */
1195 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest001, TestSize.Level0)
1196 {
1197 SoftBusFdSet set;
1198 SoftBusSocketFdSet(1, &set);
1199 int32_t ret = SoftBusSocketFdIsset(1, &set);
1200 EXPECT_TRUE(ret == 1);
1201 }
1202
1203 /*
1204 * @tc.name: SoftBusSocketFdIssetTest002
1205 * @tc.desc: fd not in set
1206 * @tc.type: FUNC
1207 * @tc.require: 1
1208 */
1209 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest002, TestSize.Level0)
1210 {
1211 SoftBusFdSet set = { 0 };
1212 SoftBusSocketFdClr(1, &set);
1213 int32_t ret = SoftBusSocketFdIsset(1, &set);
1214 EXPECT_TRUE(ret == 0);
1215 }
1216
1217 /*
1218 * @tc.name: SoftBusSocketFdIssetTest003
1219 * @tc.desc: set is null
1220 * @tc.type: FUNC
1221 * @tc.require: 1
1222 */
1223 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest003, TestSize.Level0)
1224 {
1225 int32_t ret = SoftBusSocketFdIsset(1, nullptr);
1226 EXPECT_TRUE(ret == 0);
1227 }
1228
1229 /*
1230 * @tc.name: SoftBusSocketSelectTest001
1231 * @tc.desc: select read fds
1232 * @tc.type: FUNC
1233 * @tc.require: 1
1234 */
1235 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest001, TestSize.Level0)
1236 {
1237 int32_t socketFd;
1238 SoftBusFdSet readFds;
1239 SoftBusSockTimeOut tv = { .sec = 5, .usec = 1 };
1240 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1241 EXPECT_EQ(0, ret);
1242
1243 SoftBusSocketFdZero(&readFds);
1244 SoftBusSocketFdSet(socketFd, &readFds);
1245 ret = SoftBusSocketSelect(SET_SIZE, &readFds, nullptr, nullptr, &tv);
1246 EXPECT_TRUE(ret >= 0);
1247
1248 ret = SoftBusSocketClose(socketFd);
1249 EXPECT_EQ(0, ret);
1250 }
1251
1252 /*
1253 * @tc.name: SoftBusSocketSelectTest002
1254 * @tc.desc: select write fds
1255 * @tc.type: FUNC
1256 * @tc.require: 1
1257 */
1258 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest002, TestSize.Level0)
1259 {
1260 int32_t socketFd;
1261 SoftBusFdSet writeFds;
1262 SoftBusFdSet fdSelect;
1263 SoftBusSockTimeOut tv = { .sec = 5, .usec = 1 };
1264 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1265 EXPECT_EQ(0, ret);
1266
1267 SoftBusSocketFdZero(&writeFds);
1268 SoftBusSocketFdSet(socketFd, &writeFds);
1269 fdSelect = writeFds;
1270 ret = SoftBusSocketSelect(SET_SIZE, nullptr, &fdSelect, nullptr, &tv);
1271 EXPECT_TRUE(ret >= 0);
1272
1273 ret = SoftBusSocketClose(socketFd);
1274 EXPECT_EQ(0, ret);
1275 }
1276
1277 /*
1278 * @tc.name: SoftBusSocketSelectTest003
1279 * @tc.desc: select expcept fds
1280 * @tc.type: FUNC
1281 * @tc.require: 1
1282 */
1283 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest003, TestSize.Level0)
1284 {
1285 int32_t socketFd;
1286 SoftBusFdSet exceptFds;
1287 SoftBusFdSet fdSelect;
1288 SoftBusSockTimeOut tv = { .sec = 5, .usec = 1 };
1289 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1290 EXPECT_EQ(0, ret);
1291
1292 SoftBusSocketFdZero(&exceptFds);
1293 SoftBusSocketFdSet(socketFd, &exceptFds);
1294 fdSelect = exceptFds;
1295 ret = SoftBusSocketSelect(SET_SIZE, nullptr, nullptr, &fdSelect, &tv);
1296 EXPECT_TRUE(ret >= 0);
1297
1298 ret = SoftBusSocketClose(socketFd);
1299 EXPECT_EQ(0, ret);
1300 }
1301
1302 /*
1303 * @tc.name: SoftBusSocketSelectTest004
1304 * @tc.desc: select all fds
1305 * @tc.type: FUNC
1306 * @tc.require: 1
1307 */
1308 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest004, TestSize.Level0)
1309 {
1310 SoftBusFdSet readFds, writeFds, exceptFds;
1311 SoftBusSockTimeOut tv = { .sec = 5, .usec = 1 };
1312 SoftBusSocketFdZero(&readFds);
1313 SoftBusSocketFdZero(&writeFds);
1314 SoftBusSocketFdZero(&exceptFds);
1315 int32_t ret = SoftBusSocketSelect(SET_SIZE, &readFds, &writeFds, &exceptFds, &tv);
1316 EXPECT_TRUE(ret >= 0);
1317 }
1318
1319 /*
1320 * @tc.name: SoftBusSocketSelectTest005
1321 * @tc.desc: nfds is illegal
1322 * @tc.type: FUNC
1323 * @tc.require: 1
1324 */
1325 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest005, TestSize.Level0)
1326 {
1327 SoftBusSockTimeOut tv = { .sec = 5, .usec = 1 };
1328 int32_t ret = SoftBusSocketSelect(SET_SIZE, nullptr, nullptr, nullptr, &tv);
1329 EXPECT_TRUE(ret >= 0);
1330 }
1331
1332 /*
1333 * @tc.name: SoftBusSocketSelectTest006
1334 * @tc.desc: The value of timeOut is 0
1335 * @tc.type: FUNC
1336 * @tc.require: 1
1337 */
1338 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest006, TestSize.Level0)
1339 {
1340 SoftBusSockTimeOut tv = { .sec = 0, .usec = 0 };
1341 SoftBusFdSet readFds, writeFds, exceptFds;
1342 int32_t ret = SoftBusSocketSelect(SET_SIZE, &readFds, &writeFds, &exceptFds, &tv);
1343 EXPECT_TRUE(ret >= 0);
1344 }
1345
1346 /*
1347 * @tc.name: SoftBusSocketIoctlTest001
1348 * @tc.desc:fd is illegal
1349 * @tc.type: FUNC
1350 * @tc.require: 1
1351 */
1352 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketIoctlTest001, TestSize.Level0)
1353 {
1354 int32_t nread = 0;
1355 long cmd = 1;
1356 int32_t socketFd = -1;
1357 int32_t ret = SoftBusSocketIoctl(socketFd, cmd, &nread);
1358 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1359 }
1360
1361 /*
1362 * @tc.name: SoftBusSocketIoctlTest002
1363 * @tc.desc: cmd is illegal
1364 * @tc.type: FUNC
1365 * @tc.require: 1
1366 */
1367 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketIoctlTest002, TestSize.Level0)
1368 {
1369 int32_t nread;
1370 long cmd = -1;
1371 int32_t socketFd;
1372 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1373 EXPECT_EQ(0, ret);
1374
1375 ret = SoftBusSocketIoctl(socketFd, cmd, &nread);
1376 EXPECT_EQ(-1, ret);
1377
1378 ret = SoftBusSocketClose(socketFd);
1379 EXPECT_EQ(0, ret);
1380 }
1381
1382 /*
1383 * @tc.name: SoftBusSocketFcntlTest001
1384 * @tc.desc: Fcntl is success
1385 * @tc.type: FUNC
1386 * @tc.require: 1
1387 */
1388 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFcntlTest001, TestSize.Level0)
1389 {
1390 int32_t socketFd;
1391 long cmd = 1;
1392 long flag = 0;
1393 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1394 EXPECT_EQ(0, ret);
1395
1396 ret = SoftBusSocketFcntl(socketFd, cmd, flag);
1397 EXPECT_EQ(0, ret);
1398
1399 ret = SoftBusSocketClose(socketFd);
1400 EXPECT_EQ(0, ret);
1401 }
1402
1403 /*
1404 * @tc.name: SoftBusSocketFcntlTest002
1405 * @tc.desc: socketFd is illegal
1406 * @tc.type: FUNC
1407 * @tc.require: 1
1408 */
1409 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFcntlTest002, TestSize.Level0)
1410 {
1411 int32_t socketFd = -1;
1412 long cmd = F_DUPFD;
1413 long flag = 0;
1414 int32_t ret = SoftBusSocketFcntl(socketFd, cmd, flag);
1415 EXPECT_EQ(-1, ret);
1416 }
1417
1418 #if HAVE_PRO
1419 /*
1420 * @tc.name: SoftBusSocketSendTest001
1421 * @tc.desc: socketFd is invalid
1422 * @tc.type: FUNC
1423 * @tc.require: 1
1424 */
1425 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest001, TestSize.Level0)
1426 {
1427 int32_t socketFd = -1;
1428 char buf[TEST_BUF_SIZE] = { 0 };
1429
1430 int32_t ret = SoftBusSocketSend(socketFd, buf, TEST_BUF_SIZE, 0);
1431 EXPECT_EQ(-1, ret);
1432 }
1433 #endif
1434
1435 /*
1436 * @tc.name: SoftBusSocketSendTest002
1437 * @tc.desc: buf is invalid
1438 * @tc.type: FUNC
1439 * @tc.require: 1
1440 */
1441 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest002, TestSize.Level0)
1442 {
1443 sleep(1);
1444 int32_t pid = -1;
1445 if ((pid = fork()) == 0) {
1446 SocketServiceStart(0);
1447 return;
1448 }
1449 sleep(1);
1450 int32_t socketFd = -1;
1451 SoftBusSockAddrIn serAddr = { .sinFamily = SOFTBUS_AF_INET,
1452 .sinPort = SoftBusHtoNs(8888),
1453 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
1454 struct SocketProtocol buf = { 0 };
1455 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1456 EXPECT_EQ(0, ret);
1457 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1458 EXPECT_EQ(0, ret);
1459 ret = SoftBusSocketSend(socketFd, nullptr, 0, 0);
1460 EXPECT_TRUE(ret <= 0);
1461 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1462 buf.cmd = CMD_EXIT;
1463 ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1464 EXPECT_TRUE(ret != -1);
1465 ret = SoftBusSocketClose(socketFd);
1466 EXPECT_EQ(0, ret);
1467 }
1468
1469 /*
1470 * @tc.name: SoftBusSocketSendTest003
1471 * @tc.desc: bufLen is invalid
1472 * @tc.type: FUNC
1473 * @tc.require: 1
1474 */
1475 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest003, TestSize.Level0)
1476 {
1477 sleep(1);
1478 int32_t pid = -1;
1479 if ((pid = fork()) == 0) {
1480 SocketServiceStart(0);
1481 return;
1482 }
1483 sleep(1);
1484 int32_t socketFd = -1;
1485 SoftBusSockAddrIn serAddr = { .sinFamily = SOFTBUS_AF_INET,
1486 .sinPort = SoftBusHtoNs(8888),
1487 .sinAddr = { .sAddr = SoftBusInetAddr("127.0.0.1") } };
1488 struct SocketProtocol buf = { 0 };
1489 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1490 EXPECT_EQ(0, ret);
1491 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1492 EXPECT_EQ(0, ret);
1493 buf.cmd = CMD_RECV;
1494 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1495 ret = SoftBusSocketSend(socketFd, (void *)&buf, 0, 0);
1496 EXPECT_TRUE(ret <= 0);
1497 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1498 buf.cmd = CMD_EXIT;
1499 ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1500 EXPECT_TRUE(ret != -1);
1501 ret = SoftBusSocketClose(socketFd);
1502 EXPECT_EQ(0, ret);
1503 }
1504
1505 /*
1506 * @tc.name: SoftBusSocketSendTest004
1507 * @tc.desc: positive
1508 * @tc.type: FUNC
1509 * @tc.require: 1
1510 */
1511 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest004, TestSize.Level0)
1512 {
1513 sleep(1);
1514 int32_t pid = -1;
1515 if ((pid = fork()) == 0) {
1516 SocketServiceStart(0);
1517 return;
1518 }
1519 sleep(1);
1520 int32_t socketFd = -1;
1521 struct SocketProtocol buf = { 0 };
1522 ClientConnect(&socketFd);
1523
1524 buf.cmd = CMD_RECV;
1525 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1526 int32_t ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 1);
1527 EXPECT_TRUE(ret >= 0);
1528
1529 ClientExit(socketFd);
1530 }
1531
1532 /*
1533 * @tc.name: SoftBusSocketSendToTest001
1534 * @tc.desc: socketFd is illegal
1535 * @tc.type: FUNC
1536 * @tc.require: 1
1537 */
1538 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest001, TestSize.Level0)
1539 {
1540 int32_t socketFd = -1;
1541 SoftBusSockAddr addr = {
1542 .saFamily = SOFTBUS_AF_INET,
1543 };
1544 struct SocketProtocol buf = { 0 };
1545 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddrIn));
1546 EXPECT_EQ(-1, ret);
1547 }
1548
1549 /*
1550 * @tc.name: SoftBusSocketSendToTest002
1551 * @tc.desc: send to success
1552 * @tc.type: FUNC
1553 * @tc.require: 1
1554 */
1555 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest002, TestSize.Level0)
1556 {
1557 sleep(1);
1558 int32_t pid = -1;
1559 if ((pid = fork()) == 0) {
1560 SocketServiceStart(0);
1561 return;
1562 }
1563 sleep(1);
1564 int32_t socketFd = -1;
1565 struct SocketProtocol buf = { 0 };
1566 SoftBusSockAddr addr = {
1567 .saFamily = SOFTBUS_AF_INET,
1568 };
1569 ClientConnect(&socketFd);
1570
1571 buf.cmd = CMD_RECV;
1572 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1573 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddrIn));
1574 EXPECT_TRUE(ret >= 0);
1575
1576 ClientExit(socketFd);
1577 }
1578
1579 /*
1580 * @tc.name: SoftBusSocketSendToTest003
1581 * @tc.desc: buf is null
1582 * @tc.type: FUNC
1583 * @tc.require: 1
1584 */
1585 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest003, TestSize.Level0)
1586 {
1587 sleep(1);
1588 int32_t pid = -1;
1589 if ((pid = fork()) == 0) {
1590 SocketServiceStart(0);
1591 return;
1592 }
1593 sleep(1);
1594 int32_t socketFd = -1;
1595 struct SocketProtocol buf = { 0 };
1596 SoftBusSockAddr addr = {
1597 .saFamily = SOFTBUS_AF_INET,
1598 };
1599 ClientConnect(&socketFd);
1600
1601 int32_t ret = SoftBusSocketSendTo(socketFd, nullptr, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddrIn));
1602 EXPECT_TRUE(ret == -1);
1603
1604 ClientExit(socketFd);
1605 }
1606
1607 /*
1608 * @tc.name: SoftBusSocketSendToTest004
1609 * @tc.desc: addr is NULL
1610 * @tc.type: FUNC
1611 * @tc.require: 1
1612 */
1613 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest004, TestSize.Level0)
1614 {
1615 sleep(1);
1616 int32_t pid = -1;
1617 if ((pid = fork()) == 0) {
1618 SocketServiceStart(0);
1619 return;
1620 }
1621 sleep(1);
1622 int32_t socketFd = -1;
1623 struct SocketProtocol buf = { 0 };
1624 ClientConnect(&socketFd);
1625
1626 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, nullptr, sizeof(SoftBusSockAddrIn));
1627 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1628
1629 ClientExit(socketFd);
1630 }
1631
1632 /*
1633 * @tc.name: SoftBusSocketSendToTest005
1634 * @tc.desc: addrLen is illegal
1635 * @tc.type: FUNC
1636 * @tc.require: 1
1637 */
1638 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest005, TestSize.Level0)
1639 {
1640 sleep(1);
1641 int32_t pid = -1;
1642 if ((pid = fork()) == 0) {
1643 SocketServiceStart(0);
1644 return;
1645 }
1646 sleep(1);
1647 int32_t socketFd = -1;
1648 struct SocketProtocol buf = { 0 };
1649 SoftBusSockAddr addr = {
1650 .saFamily = SOFTBUS_AF_INET,
1651 };
1652 ClientConnect(&socketFd);
1653
1654 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, 0);
1655
1656 EXPECT_TRUE(ret < 0);
1657
1658 ClientExit(socketFd);
1659 }
1660
1661 /*
1662 * @tc.name: SoftBusSocketSendToTest006
1663 * @tc.desc: bufLen is illegal
1664 * @tc.type: FUNC
1665 * @tc.require: 1
1666 */
1667 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest006, TestSize.Level0)
1668 {
1669 sleep(1);
1670 int32_t pid = -1;
1671 if ((pid = fork()) == 0) {
1672 SocketServiceStart(0);
1673 return;
1674 }
1675 sleep(1);
1676 int32_t socketFd = -1;
1677 struct SocketProtocol buf = { 0 };
1678 SoftBusSockAddr addr = {
1679 .saFamily = SOFTBUS_AF_INET,
1680 };
1681 ClientConnect(&socketFd);
1682
1683 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, 0, 0, &addr, sizeof(SoftBusSockAddrIn));
1684 EXPECT_TRUE(ret == 0);
1685
1686 ClientExit(socketFd);
1687 }
1688
1689 /*
1690 * @tc.name: SoftBusSocketSendTest007
1691 * @tc.desc: buf is invalid
1692 * @tc.type: FUNC
1693 * @tc.require: 1
1694 */
1695 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest007, TestSize.Level0)
1696 {
1697 sleep(1);
1698 int32_t pid = -1;
1699 if ((pid = fork()) == 0) {
1700 SocketIpv6ServiceStart(0);
1701 return;
1702 }
1703 sleep(1);
1704 int32_t socketFd = -1;
1705 SoftBusSockAddrIn6 addrIn6 = { 0 };
1706 addrIn6.sin6Family = SOFTBUS_AF_INET6;
1707 addrIn6.sin6Port = SoftBusHtoNs(TEST_IPV6_PORT);
1708 const char *srcAddr = "::1";
1709 SoftBusInetPtoN(SOFTBUS_AF_INET6, srcAddr, &addrIn6.sin6Addr);
1710 addrIn6.sin6ScopeId = SoftBusIfNameToIndex("lo");
1711 struct SocketProtocol buf = { 0 };
1712 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET6, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1713 EXPECT_EQ(0, ret);
1714 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&addrIn6, sizeof(SoftBusSockAddrIn6));
1715 EXPECT_EQ(0, ret);
1716 ret = SoftBusSocketSend(socketFd, nullptr, 0, 0);
1717 EXPECT_TRUE(ret <= 0);
1718 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1719 buf.cmd = CMD_EXIT;
1720 ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1721 EXPECT_TRUE(ret != -1);
1722 ret = SoftBusSocketClose(socketFd);
1723 EXPECT_EQ(0, ret);
1724 }
1725
1726 /*
1727 * @tc.name: SoftBusSocketRecvTest001
1728 * @tc.desc: socketFd is NULL
1729 * @tc.type: FUNC
1730 * @tc.require: 1
1731 */
1732 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvTest001, TestSize.Level0)
1733 {
1734 int32_t socketFd = -1;
1735 struct SocketProtocol buf = { 0 };
1736 int32_t ret = SoftBusSocketRecv(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1737 EXPECT_NE(0, ret);
1738 }
1739
1740 /*
1741 * @tc.name: SoftBusSocketRecvTest002
1742 * @tc.desc: recv success
1743 * @tc.type: FUNC
1744 * @tc.require: 1
1745 */
1746 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvTest002, TestSize.Level0)
1747 {
1748 sleep(1);
1749 int32_t pid = -1;
1750 if ((pid = fork()) == 0) {
1751 SocketServiceStart(0);
1752 return;
1753 }
1754 sleep(1);
1755 int32_t socketFd = -1;
1756 struct SocketProtocol buf = { 0 };
1757 ClientConnect(&socketFd);
1758
1759 buf.cmd = CMD_RECV;
1760 (void)strncpy_s(buf.data, sizeof(buf.data), "Hello World!", sizeof(buf.data));
1761 int32_t ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1762 EXPECT_TRUE(ret != -1);
1763
1764 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1765 ret = SoftBusSocketRecv(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
1766 EXPECT_TRUE(ret != -1);
1767
1768 ClientExit(socketFd);
1769 }
1770
1771 /*
1772 * @tc.name: SoftBusSocketRecvFromTest001
1773 * @tc.desc: positive
1774 * @tc.type: FUNC
1775 * @tc.require: 1
1776 */
1777 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvFromTest001, TestSize.Level0)
1778 {
1779 int32_t socketFd = -1;
1780 SoftBusSockAddr fromAddr = { 0 };
1781 int32_t fromAddrLen;
1782 int32_t ret = SoftBusSocketRecvFrom(socketFd, nullptr, 0, 0, &fromAddr, &fromAddrLen);
1783 EXPECT_EQ(-1, ret);
1784 }
1785
1786 /*
1787 * @tc.name: SoftBusSocketShutDownTest001
1788 * @tc.desc: socketFd is service fd
1789 * @tc.type: FUNC
1790 * @tc.require: 1
1791 */
1792 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest001, TestSize.Level0)
1793 {
1794 int32_t socketFd = -1;
1795 int32_t optVal = 1;
1796 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1797 EXPECT_EQ(0, ret);
1798
1799 SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
1800 EXPECT_EQ(0, ret);
1801
1802 SoftBusSocketShutDown(socketFd, SOFTBUS_SHUT_RDWR);
1803 EXPECT_EQ(0, ret);
1804 ret = SoftBusSocketClose(socketFd);
1805 EXPECT_EQ(0, ret);
1806 }
1807
1808 /*
1809 * @tc.name: SoftBusSocketShutDownTest002
1810 * @tc.desc: socketFd is illegal
1811 * @tc.type: FUNC
1812 * @tc.require: 1
1813 */
1814 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest002, TestSize.Level0)
1815 {
1816 int32_t socketFd = -1;
1817 int32_t ret = SoftBusSocketShutDown(socketFd, SOFTBUS_SHUT_RDWR);
1818 EXPECT_TRUE(ret != 0);
1819 }
1820
1821 /*
1822 * @tc.name: SoftBusSocketShutDownTest003
1823 * @tc.desc: how is illegal
1824 * @tc.type: FUNC
1825 * @tc.require: 1
1826 */
1827 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest003, TestSize.Level0)
1828 {
1829 int32_t socketFd;
1830
1831 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1832 EXPECT_TRUE(ret == 0);
1833 ret = SoftBusSocketShutDown(socketFd, -1);
1834 EXPECT_TRUE(ret != 0);
1835 SoftBusSocketClose(socketFd);
1836 }
1837
1838 /*
1839 * @tc.name: SoftBusSocketCloseTest001
1840 * @tc.desc: normal close
1841 * @tc.type: FUNC
1842 * @tc.require: 1
1843 */
1844 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCloseTest001, TestSize.Level0)
1845 {
1846 int32_t socketFd;
1847
1848 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1849 EXPECT_TRUE(ret == 0);
1850 ret = SoftBusSocketClose(socketFd);
1851 EXPECT_TRUE(ret == 0);
1852 }
1853
1854 /*
1855 * @tc.name: SoftBusSocketCloseTest002
1856 * @tc.desc: fd is illegal
1857 * @tc.type: FUNC
1858 * @tc.require: 1
1859 */
1860 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCloseTest002, TestSize.Level0)
1861 {
1862 int32_t socketFd = -1;
1863
1864 int32_t ret = SoftBusSocketClose(socketFd);
1865 EXPECT_TRUE(ret == -1);
1866 }
1867
1868 /*
1869 * @tc.name: SoftBusInetPtoNTest001
1870 * @tc.desc: string is valid format
1871 * @tc.type: FUNC
1872 * @tc.require: 1
1873 */
1874 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest001, TestSize.Level0)
1875 {
1876 const char *src = "192.168.0.1";
1877 char dst[TEST_BUF_SIZE] = { 0 };
1878 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1879 EXPECT_EQ(0, ret);
1880 EXPECT_EQ(0x100A8C0, *(unsigned int *)dst);
1881 }
1882
1883 /*
1884 * @tc.name: SoftBusInetPtoNTest002
1885 * @tc.desc: string is invalid format
1886 * @tc.type: FUNC
1887 * @tc.require: 1
1888 */
1889 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest002, TestSize.Level0)
1890 {
1891 const char *src = "abcde";
1892 char dst[TEST_BUF_SIZE] = { 0 };
1893 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1894 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1895 }
1896
1897 /*
1898 * @tc.name: SoftBusInetPtoNTest003
1899 * @tc.desc: string is invalid format
1900 * @tc.type: FUNC
1901 * @tc.require: 1
1902 */
1903 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest003, TestSize.Level0)
1904 {
1905 const char *src = "1234";
1906 char dst[TEST_BUF_SIZE] = { 0 };
1907 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1908 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1909 }
1910
1911 /*
1912 * @tc.name: SoftBusInetPtoNTest004
1913 * @tc.desc: string is invalid format
1914 * @tc.type: FUNC
1915 * @tc.require: 1
1916 */
1917 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest004, TestSize.Level0)
1918 {
1919 const char *src = "0x1234";
1920 char dst[TEST_BUF_SIZE] = { 0 };
1921 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1922 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1923 }
1924
1925 /*
1926 * @tc.name: SoftBusInetPtoNTest005
1927 * @tc.desc: string is invalid format
1928 * @tc.type: FUNC
1929 * @tc.require: 1
1930 */
1931 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest005, TestSize.Level0)
1932 {
1933 const char *src = "__*0x1234";
1934 char dst[TEST_BUF_SIZE] = { 0 };
1935 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1936 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1937 }
1938
1939 /*
1940 * @tc.name: SoftBusInetPtoNTest006
1941 * @tc.desc: af is illegal
1942 * @tc.type: FUNC
1943 * @tc.require: 1
1944 */
1945 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest006, TestSize.Level0)
1946 {
1947 const char *src = "192.168.0.1";
1948 char dst[TEST_BUF_SIZE] = { 0 };
1949 int32_t ret = SoftBusInetPtoN(-1, src, dst);
1950 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1951 }
1952
1953 /*
1954 * @tc.name: SoftBusInetPtoNTest007
1955 * @tc.desc: loop back
1956 * @tc.type: FUNC
1957 * @tc.require: 1
1958 */
1959 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest007, TestSize.Level0)
1960 {
1961 const char *src = "::1";
1962 char dst[46] = { 0 };
1963 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET6, src, dst);
1964 EXPECT_EQ(0, ret);
1965 }
1966
1967 /*
1968 * @tc.name: SoftBusHtoNlTest001
1969 * @tc.desc: positive
1970 * @tc.type: FUNC
1971 * @tc.require: 1
1972 */
1973 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNlTest001, TestSize.Level0)
1974 {
1975 uint32_t hostlong = 0x12345678;
1976 uint32_t ret = SoftBusHtoNl(hostlong);
1977 EXPECT_EQ(0x78563412, ret);
1978 }
1979
1980 /*
1981 * @tc.name: SoftBusHtoNlTest002
1982 * @tc.desc: positive
1983 * @tc.type: FUNC
1984 * @tc.require: 1
1985 */
1986 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNlTest002, TestSize.Level0)
1987 {
1988 uint32_t hostlong = 0x0;
1989 uint32_t ret = SoftBusHtoNl(hostlong);
1990 EXPECT_EQ(0x0, ret);
1991 }
1992
1993 /*
1994 * @tc.name: SoftBusHtoNsTest001
1995 * @tc.desc: positive
1996 * @tc.type: FUNC
1997 * @tc.require: 1
1998 */
1999 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNsTest001, TestSize.Level0)
2000 {
2001 uint16_t hostshort = 0x1234;
2002 uint16_t ret = SoftBusHtoNs(hostshort);
2003 EXPECT_EQ(0x3412, ret);
2004 }
2005
2006 /*
2007 * @tc.name: SoftBusHtoNsTest002
2008 * @tc.desc: positive
2009 * @tc.type: FUNC
2010 * @tc.require: 1
2011 */
2012 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNsTest002, TestSize.Level0)
2013 {
2014 uint16_t hostshort = 0x0;
2015 uint16_t ret = SoftBusHtoNs(hostshort);
2016 EXPECT_EQ(0x0, ret);
2017 }
2018
2019 /*
2020 * @tc.name: SoftBusNtoHlTest001
2021 * @tc.desc: positive
2022 * @tc.type: FUNC
2023 * @tc.require: 1
2024 */
2025 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHlTest001, TestSize.Level0)
2026 {
2027 int32_t netlong = 0x12345678;
2028 int32_t ret = SoftBusNtoHl(netlong);
2029 EXPECT_EQ(0x78563412, ret);
2030 }
2031
2032 /*
2033 * @tc.name: SoftBusNtoHlTest002
2034 * @tc.desc: positive
2035 * @tc.type: FUNC
2036 * @tc.require: 1
2037 */
2038 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHlTest002, TestSize.Level0)
2039 {
2040 uint32_t netlong = 0x12;
2041 uint32_t ret = SoftBusNtoHl(netlong);
2042 EXPECT_EQ(0x12000000, ret);
2043 }
2044
2045 /*
2046 * @tc.name: SoftBusNtoHsTest001
2047 * @tc.desc: positive
2048 * @tc.type: FUNC
2049 * @tc.require: 1
2050 */
2051 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHsTest001, TestSize.Level0)
2052 {
2053 uint16_t netshort = 0x1234;
2054 uint16_t ret = SoftBusNtoHs(netshort);
2055 EXPECT_EQ(0x3412, ret);
2056 }
2057
2058 /*
2059 * @tc.name: SoftBusNtoHsTest002
2060 * @tc.desc: positive
2061 * @tc.type: FUNC
2062 * @tc.require: 1
2063 */
2064 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHsTest002, TestSize.Level0)
2065 {
2066 uint16_t netshort = 0x12;
2067 uint16_t ret = SoftBusNtoHs(netshort);
2068 EXPECT_EQ(0x1200, ret);
2069 }
2070
2071 /*
2072 * @tc.name: SoftBusInetAddrTest001
2073 * @tc.desc: positive
2074 * @tc.type: FUNC
2075 * @tc.require: 1
2076 */
2077 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest001, TestSize.Level0)
2078 {
2079 const char *cp = "127.0.0.1";
2080 int32_t ret = SoftBusInetAddr(cp);
2081 EXPECT_EQ(LOCAL_HOST_VALUE, ret);
2082 }
2083
2084 /*
2085 * @tc.name: SoftBusInetAddrTest002
2086 * @tc.desc: invalid cp
2087 * @tc.type: FUNC
2088 * @tc.require: 1
2089 */
2090 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest002, TestSize.Level0)
2091 {
2092 const char *cp = "abcde";
2093 int32_t ret = SoftBusInetAddr(cp);
2094 EXPECT_EQ(-1, ret);
2095 }
2096
2097 /*
2098 * @tc.name: SoftBusInetAddrTest003
2099 * @tc.desc: invalid cp
2100 * @tc.type: FUNC
2101 * @tc.require: 1
2102 */
2103 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest003, TestSize.Level0)
2104 {
2105 const char *cp = "0x1234";
2106 int32_t ret = SoftBusInetAddr(cp);
2107 EXPECT_EQ(0x34120000, ret);
2108 }
2109
2110 /*
2111 * @tc.name: SoftBusInetAddrTest004
2112 * @tc.desc: invalid cp
2113 * @tc.type: FUNC
2114 * @tc.require: 1
2115 */
2116 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest004, TestSize.Level0)
2117 {
2118 const char *cp = "1234";
2119 int32_t ret = SoftBusInetAddr(cp);
2120 EXPECT_EQ(0xD2040000, ret);
2121 }
2122
2123 /*
2124 * @tc.name: SoftBusInetAddrTest005
2125 * @tc.desc: invalid cp
2126 * @tc.type: FUNC
2127 * @tc.require: 1
2128 */
2129 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest005, TestSize.Level0)
2130 {
2131 const char *cp = "adc1234";
2132 int32_t ret = SoftBusInetAddr(cp);
2133 EXPECT_EQ(-1, ret);
2134 }
2135
2136 /*
2137 * @tc.name: SoftBusIfNameToIndexTest001
2138 * @tc.desc: chba0
2139 * @tc.type: FUNC
2140 * @tc.require: 4
2141 */
2142 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusIfNameToIndexTest001, TestSize.Level0)
2143 {
2144 const char *ifname = "wlan0";
2145 int32_t ret = SoftBusIfNameToIndex(ifname);
2146 EXPECT_TRUE(ret >= 0);
2147 }
2148
2149 /*
2150 * @tc.name: SoftBusIndexToIfNameTest001
2151 * @tc.desc: invalidIndex
2152 * @tc.type: FUNC
2153 * @tc.require: SOFTBUS_ADAPTER_ERR
2154 */
2155 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusIndexToIfNameTest001, TestSize.Level0)
2156 {
2157 char ifname[IF_NAME_SIZE] = { 0 };
2158 int32_t invalidIndex = -1;
2159 int32_t ret = SoftBusIndexToIfName(invalidIndex, ifname, IF_NAME_SIZE);
2160 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
2161 }
2162
2163 /*
2164 * @tc.name: SoftBusIndexToIfNameTest001
2165 * @tc.desc: invalidIndex
2166 * @tc.type: FUNC
2167 * @tc.require: SOFTBUS_INVALID_PARAM
2168 */
2169 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusIndexToIfNameTest002, TestSize.Level0)
2170 {
2171 char ifname[IF_NAME_SIZE] = { 0 };
2172 int32_t invalidIndex = 1000;
2173 int32_t ret = SoftBusIndexToIfName(invalidIndex, ifname, IF_NAME_SIZE);
2174 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
2175 }
2176
2177 /*
2178 * @tc.name: SoftBusIndexToIfNameTest001
2179 * @tc.desc: WLAN_INDEX
2180 * @tc.type: FUNC
2181 * @tc.require: SOFTBUS_ADAPTER_OK
2182 */
2183 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusIndexToIfNameTest003, TestSize.Level0)
2184 {
2185 char ifname[IF_NAME_SIZE] = { 0 };
2186 int32_t ret = SoftBusIndexToIfName(WLAN_INDEX, ifname, IF_NAME_SIZE);
2187 EXPECT_EQ(SOFTBUS_ADAPTER_OK, ret);
2188 }
2189
2190 /*
2191 * @tc.name: SoftBusSocketFullFunc001
2192 * @tc.desc: Cover Serial Multiple Interfaces
2193 * @tc.type: FUNC
2194 * @tc.require:
2195 */
2196 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFullFunc001, TestSize.Level0)
2197 {
2198 sleep(1);
2199 int32_t pid = -1;
2200 if ((pid = fork()) == 0) {
2201 SocketServiceStart(0);
2202 return;
2203 }
2204 sleep(1);
2205 int32_t ret;
2206 int32_t socketFd = -1;
2207 struct SocketProtocol buf = { 0 };
2208
2209 ClientConnect(&socketFd);
2210 EXPECT_TRUE(socketFd != -1);
2211
2212 buf.cmd = CMD_RECV;
2213 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
2214 ret = SoftBusSocketSend(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
2215 sleep(1);
2216 EXPECT_TRUE(ret >= 0);
2217 printf("data is %s\n", buf.data);
2218
2219 (void)memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
2220 ret = SoftBusSocketRecv(socketFd, (void *)&buf, sizeof(struct SocketProtocol), 0);
2221 EXPECT_TRUE(ret >= 0);
2222 printf("data is %s\n", buf.data);
2223
2224 ClientExit(socketFd);
2225 }
2226 } // namespace OHOS
2227