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