1 /*
2  * Copyright 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "hal/snoop_logger_socket.h"
18 
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <netinet/in.h>
22 #include <sys/socket.h>
23 
24 #include <cerrno>
25 
26 #include "hal/snoop_logger_common.h"
27 #include "hal/syscall_wrapper_impl.h"
28 #include "hal/syscall_wrapper_mock.h"
29 
30 namespace testing {
31 
32 using bluetooth::hal::SnoopLoggerCommon;
33 using bluetooth::hal::SnoopLoggerSocket;
34 using bluetooth::hal::SyscallWrapperImpl;
35 using bluetooth::hal::SyscallWrapperMock;
36 
37 static constexpr int INVALID_FD = -1;
38 
39 class SnoopLoggerSocketModuleTest : public Test {
40 protected:
SnoopLoggerSocketModuleTest()41   SnoopLoggerSocketModuleTest() : sls(&mock) {}
42 
InitializeCommunicationsSuccess(SnoopLoggerSocket & sls,SyscallWrapperMock & mock)43   void InitializeCommunicationsSuccess(SnoopLoggerSocket& sls, SyscallWrapperMock& mock) {
44     ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {
45       fds[0] = listen_fd;
46       fds[1] = write_fd;
47       return 0;
48     }));
49     ON_CALL(mock, Socket).WillByDefault(Return(fd));
50     ON_CALL(mock, Setsockopt(Eq(fd), _, _, _, _)).WillByDefault(Return(0));
51     ON_CALL(mock, Bind(Eq(fd), _, _)).WillByDefault(Return(0));
52     ON_CALL(mock, Listen(Eq(fd), _)).WillByDefault(Return(0));
53 
54     EXPECT_CALL(mock, Pipe2(_, _));
55     EXPECT_CALL(mock, Socket);
56     EXPECT_CALL(mock, Setsockopt);
57     EXPECT_CALL(mock, Bind);
58     EXPECT_CALL(mock, Listen);
59 
60     ASSERT_EQ(sls.InitializeCommunications(), 0);
61 
62     // will be called in destructor
63     EXPECT_CALL(mock, Close(Eq(fd)));
64     EXPECT_CALL(mock, Close(Eq(listen_fd)));
65     EXPECT_CALL(mock, Close(Eq(write_fd)));
66   }
67 
TearDown()68   void TearDown() override {}
69 
70   int fd = 11;
71   const int listen_fd = 66;
72   const int write_fd = 99;
73 
74   StrictMock<SyscallWrapperMock> mock;
75   SnoopLoggerSocket sls;
76 };
77 
TEST_F(SnoopLoggerSocketModuleTest,test_Constructor_GetSyscallWrapperInterface)78 TEST_F(SnoopLoggerSocketModuleTest, test_Constructor_GetSyscallWrapperInterface) {
79   ASSERT_EQ(sls.GetSyscallWrapperInterface(), &mock);
80 }
81 
TEST_F(SnoopLoggerSocketModuleTest,test_Destructor_implicit_cleanup)82 TEST_F(SnoopLoggerSocketModuleTest, test_Destructor_implicit_cleanup) {}
83 
TEST_F(SnoopLoggerSocketModuleTest,test_Cleanup_explicit)84 TEST_F(SnoopLoggerSocketModuleTest, test_Cleanup_explicit) { sls.Cleanup(); }
85 
TEST_F(SnoopLoggerSocketModuleTest,test_CreateSocket_fail_on_Socket)86 TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Socket) {
87   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(-1));
88 
89   EXPECT_CALL(mock, Socket).Times(1);
90   EXPECT_CALL(mock, GetErrno);
91   ASSERT_EQ(sls.CreateSocket(), INVALID_FD);
92 }
93 
TEST_F(SnoopLoggerSocketModuleTest,test_CreateSocket_fail_on_Setsockopt)94 TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Setsockopt) {
95   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(fd));
96   ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault(Return(-1));
97 
98   EXPECT_CALL(mock, Socket);
99   EXPECT_CALL(mock, Setsockopt);
100   EXPECT_CALL(mock, Close);
101   EXPECT_CALL(mock, GetErrno);
102   ASSERT_EQ(sls.CreateSocket(), INVALID_FD);
103 }
104 
TEST_F(SnoopLoggerSocketModuleTest,test_CreateSocket_fail_on_Bind)105 TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Bind) {
106   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(fd));
107   ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault(Return(0));
108   ON_CALL(mock, Bind(_, _, _)).WillByDefault(Return(-1));
109 
110   EXPECT_CALL(mock, Socket);
111   EXPECT_CALL(mock, Setsockopt);
112   EXPECT_CALL(mock, Bind);
113   EXPECT_CALL(mock, Close);
114   EXPECT_CALL(mock, GetErrno);
115   ASSERT_EQ(sls.CreateSocket(), INVALID_FD);
116 }
117 
TEST_F(SnoopLoggerSocketModuleTest,test_CreateSocket_fail_on_Listen)118 TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Listen) {
119   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(fd));
120   ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault(Return(0));
121   ON_CALL(mock, Bind(_, _, _)).WillByDefault(Return(0));
122   ON_CALL(mock, Listen(_, _)).WillByDefault(Return(-1));
123 
124   EXPECT_CALL(mock, Socket);
125   EXPECT_CALL(mock, Setsockopt);
126   EXPECT_CALL(mock, Bind);
127   EXPECT_CALL(mock, Listen);
128   EXPECT_CALL(mock, Close);
129   EXPECT_CALL(mock, GetErrno);
130   ASSERT_EQ(sls.CreateSocket(), INVALID_FD);
131 }
132 
TEST_F(SnoopLoggerSocketModuleTest,test_CreateSocket_success)133 TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_success) {
134   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(fd));
135   ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault(Return(0));
136   ON_CALL(mock, Bind(_, _, _)).WillByDefault(Return(0));
137   ON_CALL(mock, Listen(_, _)).WillByDefault(Return(0));
138 
139   EXPECT_CALL(mock, Socket);
140   EXPECT_CALL(mock, Setsockopt);
141   EXPECT_CALL(mock, Bind);
142   EXPECT_CALL(mock, Listen);
143   ASSERT_EQ(sls.CreateSocket(), fd);
144 }
145 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fd_invalid_fd)146 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_invalid_fd) {
147   fd = INVALID_FD;
148 
149   sls.Write(fd, NULL, 0);
150 }
151 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fd_fail_on_Send_ECONNRESET)152 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_ECONNRESET) {
153   char data[10];
154 
155   ON_CALL(mock, Send(_, _, _, _)).WillByDefault(Return(-1));
156   ON_CALL(mock, GetErrno()).WillByDefault(Return(ECONNRESET));
157 
158   EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _));
159   EXPECT_CALL(mock, Close(Eq(fd)));
160   EXPECT_CALL(mock, GetErrno);
161 
162   sls.Write(fd, data, sizeof(data));
163 }
164 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fd_fail_on_Send_EINVAL)165 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_EINVAL) {
166   char data[10];
167 
168   ON_CALL(mock, Send(_, _, _, _)).WillByDefault(Return(-1));
169   ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));
170 
171   EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _));
172   EXPECT_CALL(mock, GetErrno).Times(2);
173 
174   sls.Write(fd, data, sizeof(data));
175 }
176 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fd_success)177 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_success) {
178   int client_fd = 33;
179   char data[10];
180 
181   EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);
182 
183   sls.Write(client_fd, data, sizeof(data));
184 }
185 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fail_no_client)186 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fail_no_client) {
187   char data[10];
188 
189   sls.Write(data, sizeof(data));
190 }
191 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_success)192 TEST_F(SnoopLoggerSocketModuleTest, test_Write_success) {
193   int client_fd = 33;
194   char data[10];
195 
196   EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);
197   EXPECT_CALL(mock, Close(client_fd)).Times(1);
198 
199   sls.ClientSocketConnected(client_fd);
200 
201   sls.Write(data, sizeof(data));
202 }
203 
TEST_F(SnoopLoggerSocketModuleTest,test_Write_fd_fail_on_Send_EINTR)204 TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_EINTR) {
205   char data[10];
206   int intr_count = 5;
207 
208   ON_CALL(mock, Send)
209           .WillByDefault(
210                   Invoke([&](int /* fd */, const void* /* buf */, size_t /* n */, int /* flags */) {
211                     if (intr_count > 0) {
212                       intr_count--;
213                       errno = EINTR;
214                       return -1;
215                     }
216                     errno = 0;
217                     return 0;
218                   }));
219 
220   EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _)).Times(intr_count + 1);
221 
222   sls.Write(fd, data, sizeof(data));
223 }
224 
TEST_F(SnoopLoggerSocketModuleTest,test_ClientSocketConnected)225 TEST_F(SnoopLoggerSocketModuleTest, test_ClientSocketConnected) {
226   ASSERT_FALSE(sls.IsClientSocketConnected());
227 
228   EXPECT_CALL(mock, Close(Eq(fd))).Times(1);
229   EXPECT_CALL(mock, Close(Eq(fd + 1))).Times(1);
230 
231   sls.ClientSocketConnected(fd);
232 
233   ASSERT_TRUE(sls.IsClientSocketConnected());
234 
235   sls.ClientSocketConnected(fd + 1);
236 
237   ASSERT_TRUE(sls.IsClientSocketConnected());
238 }
239 
TEST_F(SnoopLoggerSocketModuleTest,test_WaitForClientSocketConnected)240 TEST_F(SnoopLoggerSocketModuleTest, test_WaitForClientSocketConnected) {
241   ASSERT_FALSE(sls.IsClientSocketConnected());
242 
243   sls.ClientSocketConnected(fd);
244 
245   ASSERT_TRUE(sls.IsClientSocketConnected());
246 
247   ASSERT_TRUE(sls.WaitForClientSocketConnected());
248 
249   EXPECT_CALL(mock, Close(Eq(fd)));
250 }
251 
TEST_F(SnoopLoggerSocketModuleTest,test_InitializeClientSocket)252 TEST_F(SnoopLoggerSocketModuleTest, test_InitializeClientSocket) {
253   int client_fd = 10;
254 
255   EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);
256 
257   sls.InitializeClientSocket(client_fd);
258 }
259 
TEST_F(SnoopLoggerSocketModuleTest,test_AcceptIncomingConnection_fail_on_accept_EINVAL)260 TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EINVAL) {
261   int client_fd = 0;
262 
263   ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));
264   ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));
265 
266   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
267   EXPECT_CALL(mock, GetErrno);
268   ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), EINVAL);
269 }
270 
TEST_F(SnoopLoggerSocketModuleTest,test_AcceptIncomingConnection_fail_on_accept_EBADF)271 TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EBADF) {
272   int client_fd = 0;
273 
274   ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));
275   ON_CALL(mock, GetErrno()).WillByDefault(Return(EBADF));
276 
277   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
278   EXPECT_CALL(mock, GetErrno);
279   ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), EBADF);
280 }
281 
TEST_F(SnoopLoggerSocketModuleTest,test_AcceptIncomingConnection_fail_on_accept_EINTR)282 TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EINTR) {
283   int client_fd = 0;
284   int intr_count = 5;
285 
286   ON_CALL(mock, Accept(Eq(fd), _, _, _))
287           .WillByDefault(Invoke([&](int /* fd */, struct sockaddr* /* addr */,
288                                     socklen_t* /* addr_len */, int /* flags */) {
289             if (intr_count > 0) {
290               intr_count--;
291               errno = EINTR;
292               return -1;
293             }
294             errno = 0;
295             return client_fd;
296           }));
297 
298   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _)).Times(intr_count + 1);  // 5 intr + 1 with errno = 0
299   EXPECT_CALL(mock, GetErrno);
300   ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), 0);
301 }
302 
TEST_F(SnoopLoggerSocketModuleTest,test_AcceptIncomingConnection_fail_on_accept_other_errors)303 TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_other_errors) {
304   int client_fd = 0;
305 
306   ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));
307   ON_CALL(mock, GetErrno()).WillByDefault(Return(EAGAIN));
308 
309   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
310   EXPECT_CALL(mock, GetErrno);
311   ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), 0);
312   ASSERT_EQ(client_fd, -1);
313 }
314 
TEST_F(SnoopLoggerSocketModuleTest,test_AcceptIncomingConnection_success)315 TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_success) {
316   int client_fd = 13;
317   int client_fd_out = 0;
318 
319   ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(client_fd));
320   ON_CALL(mock, GetErrno()).WillByDefault(Return(0));
321 
322   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
323 
324   ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd_out), 0);
325   ASSERT_EQ(client_fd, client_fd_out);
326 }
327 
TEST_F(SnoopLoggerSocketModuleTest,test_InitializeCommunications_fail_on_Pipe2)328 TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_fail_on_Pipe2) {
329   int ret = -9;
330 
331   ON_CALL(mock, Pipe2(_, _)).WillByDefault(Invoke([ret](int* /* fds */, int) { return ret; }));
332   EXPECT_CALL(mock, Pipe2(_, _));
333 
334   ASSERT_EQ(sls.InitializeCommunications(), ret);
335 }
336 
TEST_F(SnoopLoggerSocketModuleTest,test_InitializeCommunications_fail_on_CreateSocket)337 TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_fail_on_CreateSocket) {
338   int ret = -9;
339 
340   ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(ret));
341   ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {
342     fds[0] = listen_fd;
343     fds[1] = write_fd;
344     return 0;
345   }));
346 
347   EXPECT_CALL(mock, Pipe2(_, _));
348   EXPECT_CALL(mock, Socket);
349   EXPECT_CALL(mock, GetErrno);
350 
351   EXPECT_CALL(mock, Close(Eq(listen_fd)));
352   EXPECT_CALL(mock, Close(Eq(write_fd)));
353 
354   ASSERT_EQ(sls.InitializeCommunications(), -1);
355 }
356 
TEST_F(SnoopLoggerSocketModuleTest,test_InitializeCommunications_success)357 TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_success) {
358   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
359 }
360 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_fail_on_Poll_EINTR)361 TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_fail_on_Poll_EINTR) {
362   ON_CALL(mock, Poll).WillByDefault(Return(-1));
363   ON_CALL(mock, GetErrno()).WillByDefault(Return(EINTR));
364 
365   EXPECT_CALL(mock, Poll);
366   EXPECT_CALL(mock, GetErrno).Times(2);
367   ASSERT_TRUE(sls.ProcessIncomingRequest());
368 }
369 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_fail_on_Poll_EINVAL)370 TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_fail_on_Poll_EINVAL) {
371   ON_CALL(mock, Poll).WillByDefault(Return(-1));
372   ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));
373 
374   EXPECT_CALL(mock, Poll);
375   EXPECT_CALL(mock, GetErrno).Times(2);
376   ASSERT_FALSE(sls.ProcessIncomingRequest());
377 }
378 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_spurious)379 TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_spurious) {
380   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
381 
382   ON_CALL(mock, Poll)
383           .WillByDefault(Invoke([](struct pollfd* fds, nfds_t /*nfds*/, int /*timeout*/) {
384             fds[0].revents = 0;
385             fds[1].revents = 0;
386             return 0;
387           }));
388 
389   EXPECT_CALL(mock, Poll);
390   ASSERT_TRUE(sls.ProcessIncomingRequest());
391 }
392 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_signal_close)393 TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_close) {
394   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
395 
396   ON_CALL(mock, Poll)
397           .WillByDefault(Invoke([](struct pollfd* fds, nfds_t /*nfds*/, int /*timeout*/) {
398             fds[0].revents = POLLIN;
399             fds[1].revents = 0;
400             return 0;
401           }));
402 
403   EXPECT_CALL(mock, Poll);
404   ASSERT_FALSE(sls.ProcessIncomingRequest());
405 }
406 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_exit)407 TEST_F(SnoopLoggerSocketModuleTest,
408        test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_exit) {
409   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
410 
411   ON_CALL(mock, Poll)
412           .WillByDefault(Invoke([](struct pollfd* fds, nfds_t /*nfds*/, int /*timeout*/) {
413             fds[0].revents = 0;
414             fds[1].revents = POLLIN;
415             return 0;
416           }));
417 
418   ON_CALL(mock, Accept(fd, _, _, _)).WillByDefault(Return(INVALID_FD));
419   ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));
420 
421   EXPECT_CALL(mock, Poll);
422   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
423   EXPECT_CALL(mock, GetErrno);
424   ASSERT_FALSE(sls.ProcessIncomingRequest());
425 }
426 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_continue)427 TEST_F(SnoopLoggerSocketModuleTest,
428        test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_continue) {
429   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
430 
431   ON_CALL(mock, Poll)
432           .WillByDefault(Invoke([](struct pollfd* fds, nfds_t /*nfds*/, int /*timeout*/) {
433             fds[0].revents = 0;
434             fds[1].revents = POLLIN;
435             return 0;
436           }));
437 
438   ON_CALL(mock, Accept(fd, _, _, _)).WillByDefault(Return(INVALID_FD));
439   ON_CALL(mock, GetErrno()).WillByDefault(Return(ENOMEM));
440 
441   EXPECT_CALL(mock, Poll);
442   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
443   EXPECT_CALL(mock, GetErrno);
444   ASSERT_TRUE(sls.ProcessIncomingRequest());
445 }
446 
TEST_F(SnoopLoggerSocketModuleTest,test_ProcessIncomingRequest_signal_incoming_connection_success)447 TEST_F(SnoopLoggerSocketModuleTest,
448        test_ProcessIncomingRequest_signal_incoming_connection_success) {
449   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
450 
451   int client_fd = 23;
452 
453   ON_CALL(mock, Poll)
454           .WillByDefault(Invoke([](struct pollfd* fds, nfds_t /*nfds*/, int /*timeout*/) {
455             fds[0].revents = 0;
456             fds[1].revents = POLLIN;
457             return 0;
458           }));
459 
460   ON_CALL(mock, Accept(fd, _, _, _)).WillByDefault(Return(client_fd));
461   ON_CALL(mock, GetErrno()).WillByDefault(Return(0));
462 
463   EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);
464 
465   EXPECT_CALL(mock, Poll);
466   EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));
467   ASSERT_TRUE(sls.ProcessIncomingRequest());
468 
469   EXPECT_CALL(mock, Close(Eq(client_fd)));
470 }
471 
TEST_F(SnoopLoggerSocketModuleTest,test_NotifySocketListener_no_fd)472 TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_no_fd) {
473   ASSERT_EQ(sls.NotifySocketListener(), 0);
474 }
475 
TEST_F(SnoopLoggerSocketModuleTest,test_NotifySocketListener_fail_on_write)476 TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_fail_on_write) {
477   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
478 
479   ON_CALL(mock, Write).WillByDefault(Return(-1));
480   EXPECT_CALL(mock, Write(write_fd, _, _)).Times(1);
481 
482   ASSERT_EQ(sls.NotifySocketListener(), -1);
483 }
484 
TEST_F(SnoopLoggerSocketModuleTest,test_NotifySocketListener_fail_on_write_EINTR_success)485 TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_fail_on_write_EINTR_success) {
486   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
487 
488   int intr_count = 5;
489 
490   ON_CALL(mock, Write).WillByDefault(Invoke([&](int, const void*, size_t count) {
491     if (intr_count > 0) {
492       intr_count--;
493       errno = EINTR;
494       return (ssize_t)-1;
495     }
496     errno = 0;
497     return (ssize_t)count;
498   }));
499 
500   EXPECT_CALL(mock, Write(write_fd, _, _)).Times(intr_count + 1);
501 
502   ASSERT_EQ(sls.NotifySocketListener(), 0);
503 }
504 
TEST_F(SnoopLoggerSocketModuleTest,test_NotifySocketListener_success)505 TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_success) {
506   ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));
507 
508   ON_CALL(mock, Write).WillByDefault(Return(0));
509 
510   EXPECT_CALL(mock, Write(write_fd, _, _));
511   ASSERT_EQ(sls.NotifySocketListener(), 0);
512 }
513 
514 }  // namespace testing
515