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