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