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 AdapterDsoftbusSocketTest : 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 AdapterDsoftbusSocketTest::SetUpTestCase(void)
59 {
60 }
61
TearDownTestCase(void)62 void AdapterDsoftbusSocketTest::TearDownTestCase(void)
63 {
64 }
65
SetUp()66 void AdapterDsoftbusSocketTest::SetUp()
67 {
68 }
69
TearDown()70 void AdapterDsoftbusSocketTest::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, reinterpret_cast<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, reinterpret_cast<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 != nullptr);
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, reinterpret_cast<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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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(AdapterDsoftbusSocketTest, 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 fdsBits zero success
938 * @tc.type: FUNC
939 * @tc.require: 1
940 */
941 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdZeroTest001, TestSize.Level0)
942 {
943 SoftBusFdSet set = {0};
944 set.fdsBits[0] = 1;
945 SoftBusSocketFdZero(&set);
946 EXPECT_TRUE(set.fdsBits[0] == 0);
947 }
948
949 /*
950 * @tc.name: SoftBusSocketFdSetTest001
951 * @tc.desc: socketFd set success
952 * @tc.type: FUNC
953 * @tc.require: 1
954 */
955 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdSetTest001, TestSize.Level0)
956 {
957 int32_t socketFd;
958 SoftBusFdSet set = {0};
959 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
960 EXPECT_EQ(0, ret);
961 SoftBusSocketFdSet(socketFd, &set);
962 ret = SoftBusSocketClose(socketFd);
963 EXPECT_EQ(0, ret);
964 }
965
966 /*
967 * @tc.name: SoftBusSocketFdSetTest003
968 * @tc.desc: set is NULL
969 * @tc.type: FUNC
970 * @tc.require: 1
971 */
972 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdSetTest003, TestSize.Level0)
973 {
974 int32_t socketFd;
975 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
976 EXPECT_EQ(0, ret);
977 SoftBusSocketFdSet(socketFd, NULL);
978
979 ret = SoftBusSocketClose(socketFd);
980 EXPECT_EQ(0, ret);
981 }
982
983 /*
984 * @tc.name: SoftBusSocketFdClrTest001
985 * @tc.desc: fd clr success
986 * @tc.type: FUNC
987 * @tc.require: 1
988 */
989 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdClrTest001, TestSize.Level0)
990 {
991 SoftBusFdSet set;
992 SoftBusSocketFdZero(&set);
993 SoftBusSocketFdSet(1, &set);
994 SoftBusSocketFdClr(1, &set);
995 EXPECT_TRUE(set.fdsBits[0] == 0);
996 }
997
998 /*
999 * @tc.name: SoftBusSocketFdIssetTest001
1000 * @tc.desc: FdIsset success
1001 * @tc.type: FUNC
1002 * @tc.require: 1
1003 */
1004 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest001, TestSize.Level0)
1005 {
1006 SoftBusFdSet set;
1007 SoftBusSocketFdSet(1, &set);
1008 int ret = SoftBusSocketFdIsset(1, &set);
1009 EXPECT_TRUE(ret == 1);
1010 }
1011
1012 /*
1013 * @tc.name: SoftBusSocketFdIssetTest002
1014 * @tc.desc: fd not in set
1015 * @tc.type: FUNC
1016 * @tc.require: 1
1017 */
1018 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest002, TestSize.Level0)
1019 {
1020 SoftBusFdSet set = {0};
1021 SoftBusSocketFdClr(1, &set);
1022 int ret = SoftBusSocketFdIsset(1, &set);
1023 EXPECT_TRUE(ret == 0);
1024 }
1025
1026 /*
1027 * @tc.name: SoftBusSocketFdIssetTest003
1028 * @tc.desc: set is null
1029 * @tc.type: FUNC
1030 * @tc.require: 1
1031 */
1032 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFdIssetTest003, TestSize.Level0)
1033 {
1034 int ret = SoftBusSocketFdIsset(1, NULL);
1035 EXPECT_TRUE(ret == 0);
1036 }
1037
1038 /*
1039 * @tc.name: SoftBusSocketSelectTest001
1040 * @tc.desc: select read fds
1041 * @tc.type: FUNC
1042 * @tc.require: 1
1043 */
1044 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest001, TestSize.Level0)
1045 {
1046 int32_t socketFd;
1047 SoftBusFdSet readFds;
1048 SoftBusSockTimeOut tv = {
1049 .sec = 5,
1050 .usec = 1
1051 };
1052 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1053 EXPECT_EQ(0, ret);
1054
1055 SoftBusSocketFdZero(&readFds);
1056 SoftBusSocketFdSet(socketFd, &readFds);
1057 ret = SoftBusSocketSelect(SET_SIZE, &readFds, NULL, NULL, &tv);
1058 EXPECT_TRUE(ret >= 0);
1059
1060 ret = SoftBusSocketClose(socketFd);
1061 EXPECT_EQ(0, ret);
1062 }
1063
1064 /*
1065 * @tc.name: SoftBusSocketSelectTest002
1066 * @tc.desc: select write fds
1067 * @tc.type: FUNC
1068 * @tc.require: 1
1069 */
1070 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest002, TestSize.Level0)
1071 {
1072 int32_t socketFd;
1073 SoftBusFdSet writeFds;
1074 SoftBusFdSet fdSelect;
1075 SoftBusSockTimeOut tv = {
1076 .sec = 5,
1077 .usec = 1
1078 };
1079 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1080 EXPECT_EQ(0, ret);
1081
1082 SoftBusSocketFdZero(&writeFds);
1083 SoftBusSocketFdSet(socketFd, &writeFds);
1084 fdSelect = writeFds;
1085 ret = SoftBusSocketSelect(SET_SIZE, NULL, &fdSelect, NULL, &tv);
1086 EXPECT_TRUE(ret >= 0);
1087
1088 ret = SoftBusSocketClose(socketFd);
1089 EXPECT_EQ(0, ret);
1090 }
1091
1092 /*
1093 * @tc.name: SoftBusSocketSelectTest003
1094 * @tc.desc: select expcept fds
1095 * @tc.type: FUNC
1096 * @tc.require: 1
1097 */
1098 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest003, TestSize.Level0)
1099 {
1100 int32_t socketFd;
1101 SoftBusFdSet exceptFds;
1102 SoftBusFdSet fdSelect;
1103 SoftBusSockTimeOut tv = {
1104 .sec = 5,
1105 .usec = 1
1106 };
1107 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1108 EXPECT_EQ(0, ret);
1109
1110 SoftBusSocketFdZero(&exceptFds);
1111 SoftBusSocketFdSet(socketFd, &exceptFds);
1112 fdSelect = exceptFds;
1113 ret = SoftBusSocketSelect(SET_SIZE, NULL, NULL, &fdSelect, &tv);
1114 EXPECT_TRUE(ret >= 0);
1115
1116 ret = SoftBusSocketClose(socketFd);
1117 EXPECT_EQ(0, ret);
1118 }
1119
1120 /*
1121 * @tc.name: SoftBusSocketSelectTest004
1122 * @tc.desc: select all fds
1123 * @tc.type: FUNC
1124 * @tc.require: 1
1125 */
1126 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest004, TestSize.Level0)
1127 {
1128 SoftBusFdSet readFds, writeFds, exceptFds;
1129 SoftBusSockTimeOut tv = {
1130 .sec = 5,
1131 .usec = 1
1132 };
1133 SoftBusSocketFdZero(&readFds);
1134 SoftBusSocketFdZero(&writeFds);
1135 SoftBusSocketFdZero(&exceptFds);
1136 int32_t ret = SoftBusSocketSelect(SET_SIZE, &readFds, &writeFds, &exceptFds, &tv);
1137 EXPECT_TRUE(ret >= 0);
1138 }
1139
1140 /*
1141 * @tc.name: SoftBusSocketSelectTest005
1142 * @tc.desc: nfds is illegal
1143 * @tc.type: FUNC
1144 * @tc.require: 1
1145 */
1146 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest005, TestSize.Level0)
1147 {
1148 SoftBusSockTimeOut tv = {
1149 .sec = 5,
1150 .usec = 1
1151 };
1152 int32_t ret = SoftBusSocketSelect(SET_SIZE, NULL, NULL, NULL, &tv);
1153 EXPECT_TRUE(ret >= 0);
1154 }
1155
1156 /*
1157 * @tc.name: SoftBusSocketSelectTest006
1158 * @tc.desc: The value of timeOut is 0
1159 * @tc.type: FUNC
1160 * @tc.require: 1
1161 */
1162 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSelectTest006, TestSize.Level0)
1163 {
1164 SoftBusSockTimeOut tv = {
1165 .sec = 0,
1166 .usec = 0
1167 };
1168 SoftBusFdSet readFds, writeFds, exceptFds;
1169 int32_t ret = SoftBusSocketSelect(SET_SIZE, &readFds, &writeFds, &exceptFds, &tv);
1170 EXPECT_TRUE(ret >= 0);
1171 }
1172
1173 /*
1174 * @tc.name: SoftBusSocketIoctlTest001
1175 * @tc.desc:fd is illegal
1176 * @tc.type: FUNC
1177 * @tc.require: 1
1178 */
1179 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketIoctlTest001, TestSize.Level0)
1180 {
1181 int32_t nread = 0;
1182 long cmd = 1;
1183 int32_t socketFd = -1;
1184 int32_t ret = SoftBusSocketIoctl(socketFd, cmd, &nread);
1185 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1186 }
1187
1188 /*
1189 * @tc.name: SoftBusSocketIoctlTest002
1190 * @tc.desc: cmd is illegal
1191 * @tc.type: FUNC
1192 * @tc.require: 1
1193 */
1194 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketIoctlTest002, TestSize.Level0)
1195 {
1196 int32_t nread;
1197 long cmd = -1;
1198 int32_t socketFd;
1199 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1200 EXPECT_EQ(0, ret);
1201
1202 ret = SoftBusSocketIoctl(socketFd, cmd, &nread);
1203 EXPECT_EQ(-1, ret);
1204
1205 ret = SoftBusSocketClose(socketFd);
1206 EXPECT_EQ(0, ret);
1207 }
1208
1209 /*
1210 * @tc.name: SoftBusSocketFcntlTest001
1211 * @tc.desc: Fcntl is success
1212 * @tc.type: FUNC
1213 * @tc.require: 1
1214 */
1215 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFcntlTest001, TestSize.Level0)
1216 {
1217 int32_t socketFd;
1218 long cmd = 1;
1219 long flag = 0;
1220 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1221 EXPECT_EQ(0, ret);
1222
1223 ret = SoftBusSocketFcntl(socketFd, cmd, flag);
1224 EXPECT_EQ(0, ret);
1225
1226 ret = SoftBusSocketClose(socketFd);
1227 EXPECT_EQ(0, ret);
1228 }
1229
1230 /*
1231 * @tc.name: SoftBusSocketFcntlTest002
1232 * @tc.desc: socketFd is illegal
1233 * @tc.type: FUNC
1234 * @tc.require: 1
1235 */
1236 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFcntlTest002, TestSize.Level0)
1237 {
1238 int32_t socketFd = -1;
1239 long cmd = F_DUPFD;
1240 long flag = 0;
1241 int32_t ret = SoftBusSocketFcntl(socketFd, cmd, flag);
1242 EXPECT_EQ(-1, ret);
1243 }
1244
1245 #if HAVE_PRO
1246 /*
1247 * @tc.name: SoftBusSocketSendTest001
1248 * @tc.desc: socketFd is invalid
1249 * @tc.type: FUNC
1250 * @tc.require: 1
1251 */
1252 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest001, TestSize.Level0)
1253 {
1254 int32_t socketFd = -1;
1255 char buf[TEST_BUF_SIZE] = {0};
1256
1257 int32_t ret = SoftBusSocketSend(socketFd, buf, TEST_BUF_SIZE, 0);
1258 EXPECT_EQ(-1, ret);
1259 }
1260 #endif
1261
1262 /*
1263 * @tc.name: SoftBusSocketSendTest002
1264 * @tc.desc: buf is invalid
1265 * @tc.type: FUNC
1266 * @tc.require: 1
1267 */
1268 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest002, TestSize.Level0)
1269 {
1270 sleep(1);
1271 int pid = -1;
1272 if ((pid = fork()) == 0) {
1273 SocketServiceStart(0);
1274 return;
1275 }
1276 sleep(1);
1277 int32_t socketFd = -1;
1278 SoftBusSockAddrIn serAddr = {
1279 .sinFamily = SOFTBUS_AF_INET,
1280 .sinPort = SoftBusHtoNs(8888),
1281 .sinAddr = {
1282 .sAddr = SoftBusInetAddr("127.0.0.1")
1283 }
1284 };
1285 struct SocketProtocol buf = {0};
1286 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1287 EXPECT_EQ(0, ret);
1288 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1289 EXPECT_EQ(0, ret);
1290 ret = SoftBusSocketSend(socketFd, NULL, 0, 0);
1291 EXPECT_TRUE(ret <= 0);
1292 memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1293 buf.cmd = CMD_EXIT;
1294 ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1295 EXPECT_TRUE(ret != -1);
1296 ret = SoftBusSocketClose(socketFd);
1297 EXPECT_EQ(0, ret);
1298 }
1299
1300 /*
1301 * @tc.name: SoftBusSocketSendTest003
1302 * @tc.desc: bufLen is invalid
1303 * @tc.type: FUNC
1304 * @tc.require: 1
1305 */
1306 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest003, TestSize.Level0)
1307 {
1308 sleep(1);
1309 int pid = -1;
1310 if ((pid = fork()) == 0) {
1311 SocketServiceStart(0);
1312 return;
1313 }
1314 sleep(1);
1315 int32_t socketFd = -1;
1316 SoftBusSockAddrIn serAddr = {
1317 .sinFamily = SOFTBUS_AF_INET,
1318 .sinPort = SoftBusHtoNs(8888),
1319 .sinAddr = {
1320 .sAddr = SoftBusInetAddr("127.0.0.1")
1321 }
1322 };
1323 struct SocketProtocol buf = {0};
1324 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1325 EXPECT_EQ(0, ret);
1326 ret = SoftBusSocketConnect(socketFd, (SoftBusSockAddr *)&serAddr, sizeof(SoftBusSockAddrIn));
1327 EXPECT_EQ(0, ret);
1328 buf.cmd = CMD_RECV;
1329 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1330 ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), 0, 0);
1331 EXPECT_TRUE(ret <= 0);
1332 memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1333 buf.cmd = CMD_EXIT;
1334 ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1335 EXPECT_TRUE(ret != -1);
1336 ret = SoftBusSocketClose(socketFd);
1337 EXPECT_EQ(0, ret);
1338 }
1339
1340 /*
1341 * @tc.name: SoftBusSocketSendTest004
1342 * @tc.desc: positive
1343 * @tc.type: FUNC
1344 * @tc.require: 1
1345 */
1346 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendTest004, TestSize.Level0)
1347 {
1348 sleep(1);
1349 int pid = -1;
1350 if ((pid = fork()) == 0) {
1351 SocketServiceStart(0);
1352 return;
1353 }
1354 sleep(1);
1355 int32_t socketFd = -1;
1356 struct SocketProtocol buf = {0};
1357 ClientConnect(&socketFd);
1358
1359 buf.cmd = CMD_RECV;
1360 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1361 int32_t ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 1);
1362 EXPECT_TRUE(ret >= 0);
1363
1364 ClientExit(socketFd);
1365 }
1366
1367 /*
1368 * @tc.name: SoftBusSocketSendToTest001
1369 * @tc.desc: socketFd is illegal
1370 * @tc.type: FUNC
1371 * @tc.require: 1
1372 */
1373 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest001, TestSize.Level0)
1374 {
1375 int32_t socketFd = -1;
1376 SoftBusSockAddr addr = {
1377 .saFamily = SOFTBUS_AF_INET,
1378 };
1379 struct SocketProtocol buf = {0};
1380 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddr));
1381 EXPECT_EQ(-1, ret);
1382 }
1383
1384 /*
1385 * @tc.name: SoftBusSocketSendToTest002
1386 * @tc.desc: send to success
1387 * @tc.type: FUNC
1388 * @tc.require: 1
1389 */
1390 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest002, TestSize.Level0)
1391 {
1392 sleep(1);
1393 int pid = -1;
1394 if ((pid = fork()) == 0) {
1395 SocketServiceStart(0);
1396 return;
1397 }
1398 sleep(1);
1399 int32_t socketFd = -1;
1400 struct SocketProtocol buf = {0};
1401 SoftBusSockAddr addr = {
1402 .saFamily = SOFTBUS_AF_INET,
1403 };
1404 ClientConnect(&socketFd);
1405
1406 buf.cmd = CMD_RECV;
1407 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1408 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddr));
1409 EXPECT_TRUE(ret >= 0);
1410
1411 ClientExit(socketFd);
1412 }
1413
1414 /*
1415 * @tc.name: SoftBusSocketSendToTest003
1416 * @tc.desc: buf is null
1417 * @tc.type: FUNC
1418 * @tc.require: 1
1419 */
1420 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest003, TestSize.Level0)
1421 {
1422 sleep(1);
1423 int pid = -1;
1424 if ((pid = fork()) == 0) {
1425 SocketServiceStart(0);
1426 return;
1427 }
1428 sleep(1);
1429 int32_t socketFd = -1;
1430 struct SocketProtocol buf = {0};
1431 SoftBusSockAddr addr = {
1432 .saFamily = SOFTBUS_AF_INET,
1433 };
1434 ClientConnect(&socketFd);
1435
1436 int32_t ret = SoftBusSocketSendTo(socketFd, NULL, sizeof(buf), 0, &addr, sizeof(SoftBusSockAddr));
1437 EXPECT_TRUE(ret == -1);
1438
1439 ClientExit(socketFd);
1440 }
1441
1442 /*
1443 * @tc.name: SoftBusSocketSendToTest004
1444 * @tc.desc: addr is NULL
1445 * @tc.type: FUNC
1446 * @tc.require: 1
1447 */
1448 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest004, TestSize.Level0)
1449 {
1450 sleep(1);
1451 int pid = -1;
1452 if ((pid = fork()) == 0) {
1453 SocketServiceStart(0);
1454 return;
1455 }
1456 sleep(1);
1457 int32_t socketFd = -1;
1458 struct SocketProtocol buf = {0};
1459 ClientConnect(&socketFd);
1460
1461 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, NULL, sizeof(SoftBusSockAddr));
1462 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1463
1464 ClientExit(socketFd);
1465 }
1466
1467 /*
1468 * @tc.name: SoftBusSocketSendToTest005
1469 * @tc.desc: addrLen is illegal
1470 * @tc.type: FUNC
1471 * @tc.require: 1
1472 */
1473 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest005, TestSize.Level0)
1474 {
1475 sleep(1);
1476 int pid = -1;
1477 if ((pid = fork()) == 0) {
1478 SocketServiceStart(0);
1479 return;
1480 }
1481 sleep(1);
1482 int32_t socketFd = -1;
1483 struct SocketProtocol buf = {0};
1484 SoftBusSockAddr addr = {
1485 .saFamily = SOFTBUS_AF_INET,
1486 };
1487 ClientConnect(&socketFd);
1488
1489 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, sizeof(buf), 0, &addr, 0);
1490
1491 EXPECT_TRUE(ret < 0);
1492
1493 ClientExit(socketFd);
1494 }
1495
1496 /*
1497 * @tc.name: SoftBusSocketSendToTest006
1498 * @tc.desc: bufLen is illegal
1499 * @tc.type: FUNC
1500 * @tc.require: 1
1501 */
1502 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketSendToTest006, TestSize.Level0)
1503 {
1504 sleep(1);
1505 int pid = -1;
1506 if ((pid = fork()) == 0) {
1507 SocketServiceStart(0);
1508 return;
1509 }
1510 sleep(1);
1511 int32_t socketFd = -1;
1512 struct SocketProtocol buf = {0};
1513 SoftBusSockAddr addr = {
1514 .saFamily = SOFTBUS_AF_INET,
1515 };
1516 ClientConnect(&socketFd);
1517
1518 int32_t ret = SoftBusSocketSendTo(socketFd, (void *)&buf, 0, 0, &addr, sizeof(SoftBusSockAddr));
1519 EXPECT_TRUE(ret == 0);
1520
1521 ClientExit(socketFd);
1522 }
1523
1524 /*
1525 * @tc.name: SoftBusSocketRecvTest001
1526 * @tc.desc: socketFd is NULL
1527 * @tc.type: FUNC
1528 * @tc.require: 1
1529 */
1530 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvTest001, TestSize.Level0)
1531 {
1532 int32_t socketFd = -1;
1533 struct SocketProtocol buf = {0};
1534 int32_t ret = SoftBusSocketRecv(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1535 EXPECT_NE(0, ret);
1536 }
1537
1538 /*
1539 * @tc.name: SoftBusSocketRecvTest002
1540 * @tc.desc: recv success
1541 * @tc.type: FUNC
1542 * @tc.require: 1
1543 */
1544 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvTest002, TestSize.Level0)
1545 {
1546 sleep(1);
1547 int32_t pid = -1;
1548 if ((pid = fork()) == 0) {
1549 SocketServiceStart(0);
1550 return;
1551 }
1552 sleep(1);
1553 int32_t socketFd = -1;
1554 struct SocketProtocol buf = {0};
1555 ClientConnect(&socketFd);
1556
1557 buf.cmd = CMD_RECV;
1558 (void)strncpy_s(buf.data, sizeof(buf.data), "Hello World!", sizeof(buf.data));
1559 int32_t ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1560 EXPECT_TRUE(ret != -1);
1561
1562 memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1563 ret = SoftBusSocketRecv(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1564 EXPECT_TRUE(ret != -1);
1565
1566 ClientExit(socketFd);
1567 }
1568
1569 /*
1570 * @tc.name: SoftBusSocketRecvFromTest001
1571 * @tc.desc: positive
1572 * @tc.type: FUNC
1573 * @tc.require: 1
1574 */
1575 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketRecvFromTest001, TestSize.Level0)
1576 {
1577 int32_t socketFd = -1;
1578 SoftBusSockAddr fromAddr = {0};
1579 int32_t fromAddrLen;
1580 int32_t ret = SoftBusSocketRecvFrom(socketFd, NULL, 0, 0, &fromAddr, &fromAddrLen);
1581 EXPECT_EQ(-1, ret);
1582 }
1583
1584 /*
1585 * @tc.name: SoftBusSocketShutDownTest001
1586 * @tc.desc: socketFd is service fd
1587 * @tc.type: FUNC
1588 * @tc.require: 1
1589 */
1590 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest001, TestSize.Level0)
1591 {
1592 int32_t socketFd = -1;
1593 int32_t optVal = 1;
1594 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1595 EXPECT_EQ(0, ret);
1596
1597 SoftBusSocketSetOpt(socketFd, SOFTBUS_SOL_SOCKET, SOFTBUS_SO_REUSEADDR, &optVal, sizeof(optVal));
1598 EXPECT_EQ(0, ret);
1599
1600 SoftBusSocketShutDown(socketFd, SOFTBUS_SHUT_RDWR);
1601 EXPECT_EQ(0, ret);
1602 ret = SoftBusSocketClose(socketFd);
1603 EXPECT_EQ(0, ret);
1604 }
1605
1606 /*
1607 * @tc.name: SoftBusSocketShutDownTest002
1608 * @tc.desc: socketFd is illegal
1609 * @tc.type: FUNC
1610 * @tc.require: 1
1611 */
1612 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest002, TestSize.Level0)
1613 {
1614 int32_t socketFd = -1;
1615 int32_t ret = SoftBusSocketShutDown(socketFd, SOFTBUS_SHUT_RDWR);
1616 EXPECT_TRUE(ret != 0);
1617 }
1618
1619 /*
1620 * @tc.name: SoftBusSocketShutDownTest003
1621 * @tc.desc: how is illegal
1622 * @tc.type: FUNC
1623 * @tc.require: 1
1624 */
1625 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketShutDownTest003, TestSize.Level0)
1626 {
1627 int32_t socketFd;
1628
1629 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1630 EXPECT_TRUE(ret == 0);
1631 ret = SoftBusSocketShutDown(socketFd, -1);
1632 EXPECT_TRUE(ret != 0);
1633 SoftBusSocketClose(socketFd);
1634 }
1635
1636 /*
1637 * @tc.name: SoftBusSocketCloseTest001
1638 * @tc.desc: normal close
1639 * @tc.type: FUNC
1640 * @tc.require: 1
1641 */
1642 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCloseTest001, TestSize.Level0)
1643 {
1644 int32_t socketFd;
1645
1646 int32_t ret = SoftBusSocketCreate(SOFTBUS_AF_INET, SOFTBUS_SOCK_STREAM, 0, &socketFd);
1647 EXPECT_TRUE(ret == 0);
1648 ret = SoftBusSocketClose(socketFd);
1649 EXPECT_TRUE(ret == 0);
1650 }
1651
1652 /*
1653 * @tc.name: SoftBusSocketCloseTest002
1654 * @tc.desc: fd is illegal
1655 * @tc.type: FUNC
1656 * @tc.require: 1
1657 */
1658 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketCloseTest002, TestSize.Level0)
1659 {
1660 int32_t socketFd = -1;
1661
1662 int32_t ret = SoftBusSocketClose(socketFd);
1663 EXPECT_TRUE(ret == -1);
1664 }
1665
1666 /*
1667 * @tc.name: SoftBusInetPtoNTest001
1668 * @tc.desc: string is valid format
1669 * @tc.type: FUNC
1670 * @tc.require: 1
1671 */
1672 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest001, TestSize.Level0)
1673 {
1674 const char *src = "192.168.0.1";
1675 char dst[TEST_BUF_SIZE] = {0};
1676 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1677 EXPECT_EQ(0, ret);
1678 EXPECT_EQ(0x100A8C0, *reinterpret_cast<unsigned int *>(dst));
1679 }
1680
1681 /*
1682 * @tc.name: SoftBusInetPtoNTest002
1683 * @tc.desc: string is invalid format
1684 * @tc.type: FUNC
1685 * @tc.require: 1
1686 */
1687 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest002, TestSize.Level0)
1688 {
1689 const char *src = "abcde";
1690 char dst[TEST_BUF_SIZE] = {0};
1691 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1692 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1693 }
1694
1695 /*
1696 * @tc.name: SoftBusInetPtoNTest003
1697 * @tc.desc: string is invalid format
1698 * @tc.type: FUNC
1699 * @tc.require: 1
1700 */
1701 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest003, TestSize.Level0)
1702 {
1703 const char *src = "1234";
1704 char dst[TEST_BUF_SIZE] = {0};
1705 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1706 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1707 }
1708
1709 /*
1710 * @tc.name: SoftBusInetPtoNTest004
1711 * @tc.desc: string is invalid format
1712 * @tc.type: FUNC
1713 * @tc.require: 1
1714 */
1715 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest004, TestSize.Level0)
1716 {
1717 const char *src = "0x1234";
1718 char dst[TEST_BUF_SIZE] = {0};
1719 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1720 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1721 }
1722
1723 /*
1724 * @tc.name: SoftBusInetPtoNTest005
1725 * @tc.desc: string is invalid format
1726 * @tc.type: FUNC
1727 * @tc.require: 1
1728 */
1729 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest005, TestSize.Level0)
1730 {
1731 const char *src = "__*0x1234";
1732 char dst[TEST_BUF_SIZE] = {0};
1733 int32_t ret = SoftBusInetPtoN(SOFTBUS_AF_INET, src, dst);
1734 EXPECT_EQ(SOFTBUS_ADAPTER_INVALID_PARAM, ret);
1735 }
1736
1737 /*
1738 * @tc.name: SoftBusInetPtoNTest006
1739 * @tc.desc: af is illegal
1740 * @tc.type: FUNC
1741 * @tc.require: 1
1742 */
1743 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetPtoNTest006, TestSize.Level0)
1744 {
1745 const char *src = "192.168.0.1";
1746 char dst[TEST_BUF_SIZE] = {0};
1747 int32_t ret = SoftBusInetPtoN(-1, src, dst);
1748 EXPECT_EQ(SOFTBUS_ADAPTER_ERR, ret);
1749 }
1750
1751 /*
1752 * @tc.name: SoftBusHtoNlTest001
1753 * @tc.desc: positive
1754 * @tc.type: FUNC
1755 * @tc.require: 1
1756 */
1757 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNlTest001, TestSize.Level0)
1758 {
1759 uint32_t hostlong = 0x12345678;
1760 uint32_t ret = SoftBusHtoNl(hostlong);
1761 EXPECT_EQ(0x78563412, ret);
1762 }
1763
1764 /*
1765 * @tc.name: SoftBusHtoNlTest002
1766 * @tc.desc: positive
1767 * @tc.type: FUNC
1768 * @tc.require: 1
1769 */
1770 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNlTest002, TestSize.Level0)
1771 {
1772 uint32_t hostlong = 0x0;
1773 uint32_t ret = SoftBusHtoNl(hostlong);
1774 EXPECT_EQ(0x0, ret);
1775 }
1776
1777 /*
1778 * @tc.name: SoftBusHtoNsTest001
1779 * @tc.desc: positive
1780 * @tc.type: FUNC
1781 * @tc.require: 1
1782 */
1783 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNsTest001, TestSize.Level0)
1784 {
1785 uint16_t hostshort = 0x1234;
1786 uint16_t ret = SoftBusHtoNs(hostshort);
1787 EXPECT_EQ(0x3412, ret);
1788 }
1789
1790 /*
1791 * @tc.name: SoftBusHtoNsTest002
1792 * @tc.desc: positive
1793 * @tc.type: FUNC
1794 * @tc.require: 1
1795 */
1796 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusHtoNsTest002, TestSize.Level0)
1797 {
1798 uint16_t hostshort = 0x0;
1799 uint16_t ret = SoftBusHtoNs(hostshort);
1800 EXPECT_EQ(0x0, ret);
1801 }
1802
1803 /*
1804 * @tc.name: SoftBusNtoHlTest001
1805 * @tc.desc: positive
1806 * @tc.type: FUNC
1807 * @tc.require: 1
1808 */
1809 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHlTest001, TestSize.Level0)
1810 {
1811 int32_t netlong = 0x12345678;
1812 int32_t ret = SoftBusNtoHl(netlong);
1813 EXPECT_EQ(0x78563412, ret);
1814 }
1815
1816 /*
1817 * @tc.name: SoftBusNtoHlTest002
1818 * @tc.desc: positive
1819 * @tc.type: FUNC
1820 * @tc.require: 1
1821 */
1822 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHlTest002, TestSize.Level0)
1823 {
1824 uint32_t netlong = 0x12;
1825 uint32_t ret = SoftBusNtoHl(netlong);
1826 EXPECT_EQ(0x12000000, ret);
1827 }
1828
1829 /*
1830 * @tc.name: SoftBusNtoHsTest001
1831 * @tc.desc: positive
1832 * @tc.type: FUNC
1833 * @tc.require: 1
1834 */
1835 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHsTest001, TestSize.Level0)
1836 {
1837 uint16_t netshort = 0x1234;
1838 uint16_t ret = SoftBusNtoHs(netshort);
1839 EXPECT_EQ(0x3412, ret);
1840 }
1841
1842 /*
1843 * @tc.name: SoftBusNtoHsTest002
1844 * @tc.desc: positive
1845 * @tc.type: FUNC
1846 * @tc.require: 1
1847 */
1848 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusNtoHsTest002, TestSize.Level0)
1849 {
1850 uint16_t netshort = 0x12;
1851 uint16_t ret = SoftBusNtoHs(netshort);
1852 EXPECT_EQ(0x1200, ret);
1853 }
1854
1855 /*
1856 * @tc.name: SoftBusInetAddrTest001
1857 * @tc.desc: positive
1858 * @tc.type: FUNC
1859 * @tc.require: 1
1860 */
1861 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest001, TestSize.Level0)
1862 {
1863 const char *cp = "127.0.0.1";
1864 int32_t ret = SoftBusInetAddr(cp);
1865 EXPECT_EQ(LOCAL_HOST_VALUE, ret);
1866 }
1867
1868 /*
1869 * @tc.name: SoftBusInetAddrTest002
1870 * @tc.desc: invalid cp
1871 * @tc.type: FUNC
1872 * @tc.require: 1
1873 */
1874 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest002, TestSize.Level0)
1875 {
1876 const char *cp = "abcde";
1877 int32_t ret = SoftBusInetAddr(cp);
1878 EXPECT_EQ(-1, ret);
1879 }
1880
1881 /*
1882 * @tc.name: SoftBusInetAddrTest003
1883 * @tc.desc: invalid cp
1884 * @tc.type: FUNC
1885 * @tc.require: 1
1886 */
1887 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest003, TestSize.Level0)
1888 {
1889 const char *cp = "0x1234";
1890 int32_t ret = SoftBusInetAddr(cp);
1891 EXPECT_EQ(0x34120000, ret);
1892 }
1893
1894 /*
1895 * @tc.name: SoftBusInetAddrTest004
1896 * @tc.desc: invalid cp
1897 * @tc.type: FUNC
1898 * @tc.require: 1
1899 */
1900 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest004, TestSize.Level0)
1901 {
1902 const char *cp = "1234";
1903 int32_t ret = SoftBusInetAddr(cp);
1904 EXPECT_EQ(0xD2040000, ret);
1905 }
1906
1907 /*
1908 * @tc.name: SoftBusInetAddrTest005
1909 * @tc.desc: invalid cp
1910 * @tc.type: FUNC
1911 * @tc.require: 1
1912 */
1913 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusInetAddrTest005, TestSize.Level0)
1914 {
1915 const char *cp = "adc1234";
1916 int32_t ret = SoftBusInetAddr(cp);
1917 EXPECT_EQ(-1, ret);
1918 }
1919
1920 /*
1921 * @tc.name: SoftBusSocketFullFunc001
1922 * @tc.desc: Cover Serial Multiple Interfaces
1923 * @tc.type: FUNC
1924 * @tc.require:
1925 */
1926 HWTEST_F(AdapterDsoftbusSocketTest, SoftBusSocketFullFunc001, TestSize.Level0)
1927 {
1928 sleep(1);
1929 int32_t pid = -1;
1930 if ((pid = fork()) == 0) {
1931 SocketServiceStart(0);
1932 return;
1933 }
1934 sleep(1);
1935 int32_t ret;
1936 int32_t socketFd = -1;
1937 struct SocketProtocol buf = {0};
1938
1939 ClientConnect(&socketFd);
1940 EXPECT_TRUE(socketFd != -1);
1941
1942 buf.cmd = CMD_RECV;
1943 (void)strncpy_s(buf.data, sizeof(buf.data), "Happy New Year!", sizeof(buf.data));
1944 ret = SoftBusSocketSend(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1945 sleep(1);
1946 EXPECT_TRUE(ret >= 0);
1947 printf("data is %s\n", buf.data);
1948
1949 memset_s(&buf, sizeof(struct SocketProtocol), 0, sizeof(struct SocketProtocol));
1950 ret = SoftBusSocketRecv(socketFd, reinterpret_cast<void *>(&buf), sizeof(struct SocketProtocol), 0);
1951 EXPECT_TRUE(ret >= 0);
1952 printf("data is %s\n", buf.data);
1953
1954 ClientExit(socketFd);
1955 }
1956 }
1957