1 #include <errno.h>
2 #include <fcntl.h>
3 #include <gtest/gtest.h>
4 #include <netinet/ip.h>
5 #include <string.h>
6 #include <sys/un.h>
7 using namespace testing::ext;
8
9 class SocketTest : public testing::Test {
SetUp()10 void SetUp() override {}
TearDown()11 void TearDown() override {}
12 };
13
CloseOnExec(int fd,bool closeOnExec)14 static void CloseOnExec(int fd, bool closeOnExec)
15 {
16 int flags = fcntl(fd, F_GETFD);
17 EXPECT_NE(flags, -1);
18 if (closeOnExec) {
19 flags |= FD_CLOEXEC;
20 } else {
21 flags &= ~FD_CLOEXEC;
22 }
23 int err = fcntl(fd, F_SETFD, flags);
24 EXPECT_NE(err, -1);
25 }
26
27 struct DataLink {
28 std::function<bool(int)> callbackFn;
29 const char* sockPath;
30 };
31
FnLink(void * data)32 static void* FnLink(void* data)
33 {
34 DataLink* p = reinterpret_cast<DataLink*>(data);
35 std::function<bool(int)> callbackFn = p->callbackFn;
36 void* returnValue = nullptr;
37
38 int fd = socket(PF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
39 if (fd < 0) {
40 return reinterpret_cast<void*>(-1);
41 }
42
43 struct sockaddr_un addr;
44 memset(&addr, 0, sizeof(addr));
45 addr.sun_family = AF_UNIX;
46 addr.sun_path[0] = '\0';
47 strcpy(addr.sun_path + 1, p->sockPath);
48
49 if (connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) < 0) {
50 returnValue = reinterpret_cast<void*>(-1);
51 } else if (callbackFn && !callbackFn(fd)) {
52 returnValue = reinterpret_cast<void*>(-1);
53 }
54
55 close(fd);
56 return returnValue;
57 }
58
59 struct ReturnVal {
60 int fd;
61 struct sockaddr_un addr;
62 };
63
SockInit(const char * sockPath,struct ReturnVal & returnVal)64 static void SockInit(const char* sockPath, struct ReturnVal& returnVal)
65 {
66 int fd = socket(PF_UNIX, SOCK_SEQPACKET, 0);
67 EXPECT_NE(fd, -1);
68
69 struct sockaddr_un addr;
70 memset(&addr, 0, sizeof(addr));
71 addr.sun_family = AF_UNIX;
72 addr.sun_path[0] = '\0';
73 strcpy(addr.sun_path + 1, sockPath);
74 int result1 = bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
75 int result2 = listen(fd, 1);
76 EXPECT_NE(-1, result1);
77 EXPECT_NE(-1, result2);
78
79 returnVal.fd = fd;
80 returnVal.addr = addr;
81 }
82
SelectFunc(struct ReturnVal returnVal)83 static void SelectFunc(struct ReturnVal returnVal)
84 {
85 fd_set readSet;
86 FD_ZERO(&readSet);
87 FD_SET(returnVal.fd, &readSet);
88 timeval tv = { .tv_sec = 5, .tv_usec = 0 };
89 int result = select(returnVal.fd + 1, &readSet, nullptr, nullptr, &tv);
90 EXPECT_GT(result, 0);
91 }
92
93 const char* g_recvMmsgs[] = {
94 "musl_recvmmsg_001",
95 "musl_recvmmsg_02",
96 "musl_recvmmsg_3",
97 };
98
99 #define NUM_RECV_MSGS (sizeof(g_recvMmsgs) / sizeof(const char*))
100
SendMMsgTest(int fd)101 static bool SendMMsgTest(int fd)
102 {
103 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
104 if (send(fd, g_recvMmsgs[i], strlen(g_recvMmsgs[i]) + 1, 0) < 0) {
105 return false;
106 }
107 }
108 return true;
109 }
110
111 /**
112 * @tc.name: accept4_001
113 * @tc.desc: Test the functionality of the "accept4" function by creating a Unix domain socket, setting up a
114 * connection, and accepting incoming connections using accept4 with the SOCK_CLOEXEC flag.
115 * @tc.type: FUNC
116 **/
117 HWTEST_F(SocketTest, accept4_001, TestSize.Level1)
118 {
119 const char* sockPath = "test_accept4";
120 struct ReturnVal returnVal;
121
122 SockInit(sockPath, returnVal);
123 DataLink connData;
124 connData.callbackFn = nullptr;
125 connData.sockPath = sockPath;
126
127 struct sockaddr_un* addr = &returnVal.addr;
128 pthread_t thread;
129 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
130 EXPECT_EQ(0, cresult);
131 SelectFunc(returnVal);
132
133 socklen_t len = sizeof(*addr);
134 struct sockaddr* sockaddrPtr = reinterpret_cast<struct sockaddr*>(addr);
135 int acceptFd = accept4(returnVal.fd, sockaddrPtr, &len, SOCK_CLOEXEC);
136 EXPECT_NE(acceptFd, -1);
137 CloseOnExec(acceptFd, true);
138 close(acceptFd);
139
140 void* retVal;
141 int jresult = pthread_join(thread, &retVal);
142 EXPECT_EQ(0, jresult);
143 EXPECT_EQ(nullptr, retVal);
144 close(returnVal.fd);
145 }
146
147 /**
148 * @tc.name: accept4_002
149 * @tc.desc: Test the functionality of the "accept4" function by passing an invalid file descriptor (-1) and
150 * expecting it to return -1
151 * @tc.type: FUNC
152 **/
153 HWTEST_F(SocketTest, accept4_002, TestSize.Level1)
154 {
155 int err = accept4(-1, nullptr, nullptr, 0);
156 EXPECT_EQ(-1, err);
157 }
158
159 /**
160 * @tc.name: recvmmsg_001
161 * @tc.desc: Test the functionality of the "recvmmsg" function by creating a Unix domain socket, setting up a
162 * connection, and receiving multiple messages using "recvmmsg".
163 * @tc.type: FUNC
164 **/
165 HWTEST_F(SocketTest, recvmmsg_001, TestSize.Level1)
166 {
167 const char* sockPath = "test_revmmsg";
168 struct ReturnVal returnVal;
169
170 SockInit(sockPath, returnVal);
171 DataLink connData;
172 connData.callbackFn = SendMMsgTest;
173 connData.sockPath = sockPath;
174
175 struct sockaddr_un* addr = &returnVal.addr;
176 pthread_t thread;
177 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
178 EXPECT_EQ(0, cresult);
179 SelectFunc(returnVal);
180
181 socklen_t len = sizeof(*addr);
182 int acceptFd = accept(returnVal.fd, reinterpret_cast<struct sockaddr*>(addr), &len);
183 EXPECT_NE(acceptFd, -1);
184
185 std::array<struct mmsghdr, NUM_RECV_MSGS> msgs;
186 std::array<struct iovec, NUM_RECV_MSGS> io;
187 std::array<char[BUFSIZ], NUM_RECV_MSGS> bufs;
188 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
189 io[i].iov_base = bufs[i];
190 io[i].iov_len = strlen(g_recvMmsgs[i]) + 1;
191
192 msgs[i].msg_hdr.msg_iov = &io[i];
193 msgs[i].msg_hdr.msg_iovlen = 1;
194 msgs[i].msg_len = sizeof(struct msghdr);
195 }
196 struct timespec ts {
197 5, 0
198 };
199 EXPECT_EQ(NUM_RECV_MSGS, static_cast<size_t>(recvmmsg(acceptFd, msgs.data(), NUM_RECV_MSGS, 0, &ts)));
200 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
201 EXPECT_STREQ(g_recvMmsgs[i], bufs[i]);
202 }
203
204 void* retVal;
205 int jresult = pthread_join(thread, &retVal);
206 EXPECT_EQ(0, jresult);
207 EXPECT_EQ(nullptr, retVal);
208 close(returnVal.fd);
209 }
210
211 /**
212 * @tc.name: recvmmsg_002
213 * @tc.desc: Test the error handling functionality of the "recvmmsg" function by passing an invalid file
214 * descriptor (-1) and expecting it to return -1
215 * @tc.type: FUNC
216 **/
217 HWTEST_F(SocketTest, recvmmsg_002, TestSize.Level1)
218 {
219 EXPECT_EQ(-1, recvmmsg(-1, nullptr, 0, 0, nullptr));
220 EXPECT_EQ(EBADF, errno);
221 }
222
223 const char* g_sendMMsg[] = {
224 "musl_sendmmsg_001",
225 "musl_sendmmsg_02",
226 "musl_sendmmsg_3",
227 };
228 #define SEND_MSGS_NUM (sizeof(g_sendMMsg) / sizeof(const char*))
229
SendMMsg(int fd)230 static bool SendMMsg(int fd)
231 {
232 struct mmsghdr msgs[SEND_MSGS_NUM];
233 memset(&msgs, 0, sizeof(msgs));
234 struct iovec io[SEND_MSGS_NUM];
235 memset(&io, 0, sizeof(io));
236 for (size_t i = 0; i < SEND_MSGS_NUM; i++) {
237 io[i].iov_base = const_cast<char*>(g_sendMMsg[i]);
238 io[i].iov_len = strlen(g_sendMMsg[i]) + 1;
239 msgs[i].msg_hdr.msg_iov = &io[i];
240 msgs[i].msg_hdr.msg_iovlen = 1;
241 msgs[i].msg_len = sizeof(msghdr);
242 }
243 if (sendmmsg(fd, msgs, SEND_MSGS_NUM, 0) < 0) {
244 return false;
245 }
246 return true;
247 }
248
249 /**
250 * @tc.name: sendmmsg_001
251 * @tc.desc: Test the functionality of the "sendmmsg" function by creating a Unix domain socket, setting up a
252 * connection, and sending multiple messages using "sendmmsg".
253 * @tc.type: FUNC
254 **/
255 HWTEST_F(SocketTest, sendmmsg_001, TestSize.Level1)
256 {
257 const char* sockPath = "test_sendmmsg";
258 struct ReturnVal returnVal;
259 SockInit(sockPath, returnVal);
260 DataLink connData;
261 connData.callbackFn = SendMMsg;
262 connData.sockPath = sockPath;
263
264 struct sockaddr_un* addr = &returnVal.addr;
265 pthread_t thread;
266 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
267 EXPECT_EQ(0, cresult);
268 SelectFunc(returnVal);
269
270 socklen_t len = sizeof(*addr);
271 int acceptFd = accept(returnVal.fd, reinterpret_cast<struct sockaddr*>(addr), &len);
272 EXPECT_NE(acceptFd, -1) << strerror(errno);
273 fd_set readSet;
274 FD_ZERO(&readSet);
275 FD_SET(acceptFd, &readSet);
276 for (size_t i = 0; i < SEND_MSGS_NUM; i++) {
277 timeval tv;
278 tv.tv_sec = 5;
279 tv.tv_usec = 0;
280 EXPECT_LT(0, select(acceptFd + 1, &readSet, nullptr, nullptr, &tv));
281 char buf[BUFSIZ];
282 int len1 = sizeof(buf);
283 ssize_t bytesReceived = recv(acceptFd, buf, len1, 0);
284 EXPECT_EQ(strlen(g_sendMMsg[i]) + 1, static_cast<size_t>(bytesReceived));
285 EXPECT_STREQ(g_sendMMsg[i], buf);
286 }
287 close(acceptFd);
288
289 void* retVal;
290 int jresult = pthread_join(thread, &retVal);
291 EXPECT_EQ(0, jresult);
292 EXPECT_EQ(nullptr, retVal);
293 close(returnVal.fd);
294 }
295
296 /**
297 * @tc.name: sendmmsg_002
298 * @tc.desc: Test the error handling functionality of the "sendmmsg" function by passing an invalid file descriptor
299 * (-1) and expecting it to return -1
300 * @tc.type: FUNC
301 **/
302 HWTEST_F(SocketTest, sendmmsg_002, TestSize.Level1)
303 {
304 EXPECT_GE(0, sendmmsg(-1, nullptr, 0, 0));
305 EXPECT_EQ(EBADF, errno);
306 }
307
308 /**
309 * @tc.name: bind_listen_001
310 * @tc.desc: Ensure that the binding and listening operations on the Unix domain socket are functioning as expected.
311 * @tc.type: FUNC
312 **/
313 HWTEST_F(SocketTest, bind_listen_001, TestSize.Level1)
314 {
315 auto fd = std::make_unique<int>(socket(PF_UNIX, SOCK_SEQPACKET, 0));
316 EXPECT_NE(*fd, -1);
317 struct sockaddr_un addr;
318 memset(&addr, 0, sizeof(addr));
319 addr.sun_family = AF_UNIX;
320 addr.sun_path[0] = '\0';
321 const char* sockPath = "bind_listen_test1";
322 strcpy(addr.sun_path + 1, sockPath);
323 int result1 = bind(*fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
324 int result2 = listen(*fd, 1);
325 EXPECT_NE(-1, result1);
326 EXPECT_NE(-1, result2);
327 }
328
329 /**
330 * @tc.name: accept_001
331 * @tc.desc: This test case helps ensure that the socket can successfully accept incoming connections and that the
332 * connection handling thread completes without errors.
333 * @tc.type: FUNC
334 **/
335 HWTEST_F(SocketTest, accept_001, TestSize.Level1)
336 {
337 const char* sockPath = "accept_test";
338 struct ReturnVal returnVal;
339 SockInit(sockPath, returnVal);
340 DataLink connData;
341 connData.callbackFn = SendMMsg;
342 connData.sockPath = sockPath;
343
344 struct sockaddr_un* addr = &returnVal.addr;
345 pthread_t thread;
346 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
347 EXPECT_EQ(0, cresult);
348 SelectFunc(returnVal);
349
350 socklen_t len = sizeof(*addr);
351 int acceptFd = accept(returnVal.fd, reinterpret_cast<struct sockaddr*>(addr), &len);
352 EXPECT_NE(-1, acceptFd);
353
354 void* retVal;
355 int jresult = pthread_join(thread, &retVal);
356 EXPECT_EQ(0, jresult);
357 EXPECT_EQ(nullptr, retVal);
358 close(acceptFd);
359 close(returnVal.fd);
360 }
361
362 const char* g_message = "hello";
SendTest(int fd)363 static bool SendTest(int fd)
364 {
365 if (send(fd, g_message, strlen(g_message) + 1, 0) < 0) {
366 return false;
367 }
368 return true;
369 }
370
371 /**
372 * @tc.name: recv_001
373 * @tc.desc: This test case helps ensure that the recv function can successfully receive data from a connected
374 * socket and that the received data matches the expected content.
375 * @tc.type: FUNC
376 **/
377 HWTEST_F(SocketTest, recv_001, TestSize.Level1)
378 {
379 const char* sockPath = "test_recv";
380 struct ReturnVal returnVal;
381 SockInit(sockPath, returnVal);
382 DataLink connData;
383 connData.callbackFn = SendTest;
384 connData.sockPath = sockPath;
385
386 struct sockaddr_un* addr = &returnVal.addr;
387 pthread_t thread;
388 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
389 EXPECT_EQ(0, cresult);
390 SelectFunc(returnVal);
391
392 socklen_t len = sizeof(*addr);
393 int acceptFd = accept(returnVal.fd, reinterpret_cast<struct sockaddr*>(addr), &len);
394 EXPECT_NE(acceptFd, -1) << strerror(errno);
395 char buf[BUFSIZ];
396 memset(buf, 0, sizeof(buf));
397 EXPECT_EQ(strlen(g_message) + 1, static_cast<size_t>(recv(acceptFd, buf, sizeof(buf), 0)));
398 EXPECT_STREQ(g_message, buf);
399 close(acceptFd);
400
401 void* retVal;
402 int jresult = pthread_join(thread, &retVal);
403 EXPECT_EQ(0, jresult);
404 EXPECT_EQ(nullptr, retVal);
405 close(returnVal.fd);
406 }
407
408 /**
409 * @tc.name: recv_002
410 * @tc.desc: It checks if the function correctly handles the error condition and sets the appropriate errno value.
411 * @tc.type: FUNC
412 **/
413 HWTEST_F(SocketTest, recv_002, TestSize.Level1)
414 {
415 int err = recv(-1, nullptr, 0, 0);
416 EXPECT_EQ(-1, err);
417 EXPECT_EQ(EBADF, errno);
418 }
419
420 /**
421 * @tc.name: send_001
422 * @tc.desc: This test case helps ensure that the send function can successfully send data to a connected socket and
423 * that the received data matches the expected content.
424 * @tc.type: FUNC
425 **/
426 HWTEST_F(SocketTest, send_001, TestSize.Level1)
427 {
428 const char* sockPath = "test_send";
429 struct ReturnVal returnVal;
430 SockInit(sockPath, returnVal);
431 DataLink connData;
432 connData.callbackFn = SendTest;
433 connData.sockPath = sockPath;
434
435 struct sockaddr_un* addr = &returnVal.addr;
436 pthread_t thread;
437 int cresult = pthread_create(&thread, nullptr, FnLink, &connData);
438 EXPECT_EQ(0, cresult);
439 SelectFunc(returnVal);
440
441 socklen_t len = sizeof(*addr);
442 int acceptFd = accept(returnVal.fd, reinterpret_cast<struct sockaddr*>(addr), &len);
443 EXPECT_NE(acceptFd, -1);
444 fd_set readSet;
445 FD_ZERO(&readSet);
446 FD_SET(acceptFd, &readSet);
447 timeval tv;
448 tv.tv_sec = 5;
449 tv.tv_usec = 0;
450 EXPECT_LT(0, select(acceptFd + 1, &readSet, nullptr, nullptr, &tv));
451 char buf[BUFSIZ];
452 size_t len1 = sizeof(buf);
453 EXPECT_EQ(strlen(g_message) + 1, static_cast<size_t>(recv(acceptFd, buf, len1, 0)));
454 EXPECT_STREQ(g_message, buf);
455 close(acceptFd);
456
457 void* retVal;
458 int jresult = pthread_join(thread, &retVal);
459 EXPECT_EQ(0, jresult);
460 EXPECT_EQ(nullptr, retVal);
461 close(returnVal.fd);
462 }
463
464 /**
465 * @tc.name: send_002
466 * @tc.desc: It checks if the function correctly handles the error condition and sets the appropriate errno value.
467 * @tc.type: FUNC
468 **/
469 HWTEST_F(SocketTest, send_002, TestSize.Level1)
470 {
471 int err = send(-1, nullptr, 0, 0);
472 EXPECT_EQ(-1, err);
473 EXPECT_EQ(EBADF, errno);
474 }
475
476 /**
477 * @tc.name: socket_001
478 * @tc.desc: The purpose of this test case is to verify that the socket function can successfully create a socket of
479 * the specified type (TCP, IPv4) and return a valid file descriptor.
480 * @tc.type: FUNC
481 **/
482 HWTEST_F(SocketTest, socket_001, TestSize.Level1)
483 {
484 int fd = socket(AF_INET, SOCK_STREAM, 0);
485 EXPECT_GT(fd, 0);
486 }
487
488 /**
489 * @tc.name: socketpair_001
490 * @tc.desc: A pair of sockets created by testing socketpair can be used for inter process communication
491 * @tc.type: FUNC
492 **/
493 HWTEST_F(SocketTest, socketpair_001, TestSize.Level1)
494 {
495 int sv[2];
496 char buf[BUFSIZ];
497 int fd = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
498 EXPECT_NE(-1, fd);
499 pid_t pid = fork();
500 EXPECT_NE(-1, pid);
501 if (pid == 0) {
502 close(sv[0]);
503 const char* message = "hello";
504 write(sv[1], message, strlen(message) + 1);
505 _exit(0);
506 } else {
507 close(sv[1]);
508 read(sv[0], buf, sizeof(buf));
509 EXPECT_STREQ("hello", buf);
510 }
511 close(fd);
512 close(sv[0]);
513 close(sv[1]);
514 }
515
516 /**
517 * @tc.name: shutdown_001
518 * @tc.desc: Verify that the shutdown function successfully shuts down the sending side of a Unix domain socket,
519 * and that the function returns 0 to indicate successful operation.
520 * @tc.type: FUNC
521 **/
522 HWTEST_F(SocketTest, shutdown_001, TestSize.Level1)
523 {
524 int sockfd = socket(PF_UNIX, SOCK_STREAM, 0);
525 int result = shutdown(sockfd, SHUT_WR);
526 EXPECT_EQ(0, result);
527 close(sockfd);
528 }
529
530 /**
531 * @tc.name: recvmsg_001
532 * @tc.desc: Verify that the recvmsg function can successfully receive data from a connected socket and that the
533 * received data matches the expected content.
534 * @tc.type: FUNC
535 **/
536 HWTEST_F(SocketTest, recvmsg_001, TestSize.Level1)
537 {
538 int ret;
539 int socks[2];
540 struct msghdr msg;
541 struct iovec iov[1];
542 char sendBuf[BUFSIZ] = "it is a test";
543 struct msghdr msgr;
544 struct iovec iovr[1];
545 char recvBuf[BUFSIZ];
546 ret = socketpair(AF_LOCAL, SOCK_STREAM, 0, socks);
547
548 bzero(&msg, sizeof(msg));
549 msg.msg_name = nullptr;
550 msg.msg_namelen = 0;
551 iov[0].iov_base = sendBuf;
552 iov[0].iov_len = sizeof(sendBuf);
553 msg.msg_iov = iov;
554 msg.msg_iovlen = 1;
555
556 ret = sendmsg(socks[1], &msg, 0);
557 if (ret == -1) {
558 close(socks[0]);
559 close(socks[1]);
560 }
561
562 bzero(&msgr, sizeof(msgr));
563 msgr.msg_name = nullptr;
564 msgr.msg_namelen = 0;
565 iovr[0].iov_base = &recvBuf;
566 iovr[0].iov_len = sizeof(recvBuf);
567 msgr.msg_iov = iovr;
568 msgr.msg_iovlen = 1;
569 ret = recvmsg(socks[0], &msgr, 0);
570 EXPECT_NE(-1, ret);
571 close(socks[0]);
572 close(socks[1]);
573 }
574
575 /**
576 * @tc.name: sendmsg_001
577 * @tc.desc: Testing that sendmsg can correctly sendmsg buf data
578 * @tc.type: FUNC
579 **/
580 HWTEST_F(SocketTest, sendmsg_001, TestSize.Level1)
581 {
582 struct sockaddr_in addr;
583 int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
584 EXPECT_NE(-1, sockfd);
585 addr.sin_family = AF_INET;
586 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
587 addr.sin_port = htons(1234);
588 int result = connect(sockfd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
589 EXPECT_NE(-1, result);
590 struct msghdr msg;
591
592 int retval = sendmsg(sockfd, &msg, 2);
593 EXPECT_NE(-1, retval);
594 close(sockfd);
595 }
596
597 /**
598 * @tc.name: sendto_001
599 * @tc.desc: Testing the sendto() function to send data on a local socket
600 * @tc.type: FUNC
601 **/
602 HWTEST_F(SocketTest, sendto_001, TestSize.Level1)
603 {
604 int socks[2];
605 char sendBuf[BUFSIZ] = "it is a test";
606 int ret = socketpair(AF_LOCAL, SOCK_STREAM, 0, socks);
607 ret = sendto(socks[1], sendBuf, sizeof(sendBuf), 0, nullptr, 0);
608 EXPECT_NE(-1, ret);
609 close(socks[0]);
610 close(socks[1]);
611 }
612
613 /**
614 * @tc.name: setsockopt_001
615 * @tc.desc: Testing that the setsockopt function can correctly set socket options
616 * @tc.type: FUNC
617 **/
618 HWTEST_F(SocketTest, setsockopt_001, TestSize.Level1)
619 {
620 int sockfd = socket(AF_INET, SOCK_STREAM, 0);
621 EXPECT_NE(-1, sockfd);
622 int option = 1;
623 int result = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
624 EXPECT_NE(-1, result);
625 close(sockfd);
626 }
627