Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 684f5fa9 authored by William Escande's avatar William Escande Committed by Gerrit Code Review
Browse files

Merge changes I1710944a,I054f6d09,I09820b72,Iaaa58dfc,I10eff827 

* changes:
  Change the name of snoop log in test
  Print name of the test at setup and teardown
  Restore property in snoop_logger_test
  Fix delete_old_snooz_log_files
  Remove GMOCK_WARNING in snoop_logger_socket_test
parents 9b6ad125 4e892601

system/gd/hal/snoop_logger_socket_test.cc

+139 −302
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include "hal/snoop_logger_socket_thread.h"

#include "hal/syscall_wrapper_impl.h"

#include "hal/syscall_wrapper_mock.h"

#include "os/log.h"

#include "os/utils.h"



static const char* test_flags[] = {
@@ -48,163 +49,159 @@ class SnoopLoggerSocketModuleTest : public Test { 
  void SetUp() override {

    bluetooth::common::InitFlags::Load(test_flags);

  }

  SnoopLoggerSocketModuleTest() : sls(&mock) {}



  void TearDown() override {}

};



TEST_F(SnoopLoggerSocketModuleTest, test_Constructor_GetSyscallWrapperInterface) {

  SyscallWrapperMock mock;

  void InitializeCommunicationsSuccess(SnoopLoggerSocket& sls, SyscallWrapperMock& mock) {

    ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

      fds[0] = listen_fd;

      fds[1] = write_fd;

      return 0;

    }));

    ON_CALL(mock, Socket).WillByDefault((Return(fd)));

    ON_CALL(mock, Setsockopt(Eq(fd), _, _, _, _)).WillByDefault((Return(0)));

    ON_CALL(mock, Bind(Eq(fd), _, _)).WillByDefault((Return(0)));

    ON_CALL(mock, Listen(Eq(fd), _)).WillByDefault((Return(0)));



    EXPECT_CALL(mock, FDZero);

    EXPECT_CALL(mock, Pipe2(_, _));

    EXPECT_CALL(mock, FDSet(Eq(listen_fd), _));

    EXPECT_CALL(mock, FDSet(Eq(fd), _));

    EXPECT_CALL(mock, Socket);

    EXPECT_CALL(mock, Setsockopt);

    EXPECT_CALL(mock, Bind);

    EXPECT_CALL(mock, Listen);



  SnoopLoggerSocket sls(&mock);

    ASSERT_EQ(sls.InitializeCommunications(), 0);



  ASSERT_EQ(sls.GetSyscallWrapperInterface(), &mock);

    // will be called in destructor

    EXPECT_CALL(mock, Close(Eq(fd)));

    EXPECT_CALL(mock, FDClr(Eq(fd), _));

    EXPECT_CALL(mock, Close(Eq(listen_fd)));

    EXPECT_CALL(mock, FDClr(Eq(listen_fd), _));

    EXPECT_CALL(mock, Close(Eq(write_fd)));

    EXPECT_CALL(mock, FDClr(Eq(write_fd), _));

  }



TEST_F(SnoopLoggerSocketModuleTest, test_Destructor_implicit_cleanup) {

  SyscallWrapperMock mock;

  void TearDown() override {}



  {

    SnoopLoggerSocket sls(&mock);

  int fd = 11;

  const int listen_fd = 66;

  const int write_fd = 99;



    EXPECT_CALL(mock, Close).Times(0);

  }

}

  StrictMock<SyscallWrapperMock> mock;

  SnoopLoggerSocket sls;

};



TEST_F(SnoopLoggerSocketModuleTest, test_Cleanup_explicit) {

  SyscallWrapperMock mock;

TEST_F(SnoopLoggerSocketModuleTest, test_Constructor_GetSyscallWrapperInterface) {

  ASSERT_EQ(sls.GetSyscallWrapperInterface(), &mock);

}



  SnoopLoggerSocket sls(&mock);

TEST_F(SnoopLoggerSocketModuleTest, test_Destructor_implicit_cleanup) {}



  EXPECT_CALL(mock, Close).Times(0);

TEST_F(SnoopLoggerSocketModuleTest, test_Cleanup_explicit) {

  sls.Cleanup();

}



TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Socket) {

  SyscallWrapperMock mock;



  SnoopLoggerSocket sls(&mock);



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(-1)));



  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Close).Times(0);

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.CreateSocket(), INVALID_FD);

}



TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Setsockopt) {

  SyscallWrapperMock mock;



  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(-1)));



  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Setsockopt).Times(1);

  EXPECT_CALL(mock, Close).Times(1);

  EXPECT_CALL(mock, Socket);

  EXPECT_CALL(mock, Setsockopt);

  EXPECT_CALL(mock, Close);

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

  EXPECT_CALL(mock, FDSet(Eq(fd), _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.CreateSocket(), INVALID_FD);

}



TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Bind) {

  SyscallWrapperMock mock;



  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(-1)));



  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Setsockopt).Times(1);

  EXPECT_CALL(mock, Bind).Times(1);

  EXPECT_CALL(mock, Close).Times(1);

  EXPECT_CALL(mock, Socket);

  EXPECT_CALL(mock, Setsockopt);

  EXPECT_CALL(mock, Bind);

  EXPECT_CALL(mock, Close);

  EXPECT_CALL(mock, FDSet(Eq(fd), _));

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.CreateSocket(), INVALID_FD);

}



TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_fail_on_Listen) {

  SyscallWrapperMock mock;



  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(-1)));



  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Setsockopt).Times(1);

  EXPECT_CALL(mock, Bind).Times(1);

  EXPECT_CALL(mock, Listen).Times(1);

  EXPECT_CALL(mock, Close).Times(1);

  EXPECT_CALL(mock, Socket);

  EXPECT_CALL(mock, Setsockopt);

  EXPECT_CALL(mock, Bind);

  EXPECT_CALL(mock, Listen);

  EXPECT_CALL(mock, Close);

  EXPECT_CALL(mock, FDSet(Eq(fd), _));

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.CreateSocket(), INVALID_FD);

}



TEST_F(SnoopLoggerSocketModuleTest, test_CreateSocket_success) {

  SyscallWrapperMock mock;



  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));



  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Setsockopt).Times(1);

  EXPECT_CALL(mock, Bind).Times(1);

  EXPECT_CALL(mock, Listen).Times(1);

  EXPECT_CALL(mock, Close).Times(0);

  EXPECT_CALL(mock, Socket);

  EXPECT_CALL(mock, Setsockopt);

  EXPECT_CALL(mock, Bind);

  EXPECT_CALL(mock, Listen);

  EXPECT_CALL(mock, FDSet(Eq(fd), _));

  ASSERT_EQ(sls.CreateSocket(), fd);

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_invalid_fd) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = INVALID_FD;



  EXPECT_CALL(mock, Send).Times(0);

  EXPECT_CALL(mock, Close).Times(0);

  fd = INVALID_FD;



  sls.Write(fd, NULL, 0);

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_ECONNRESET) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  char data[10];



  ON_CALL(mock, Send(_, _, _, _)).WillByDefault((Return(-1)));

  ON_CALL(mock, GetErrno()).WillByDefault((Return(ECONNRESET)));



  EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _)).Times(1);

  EXPECT_CALL(mock, Close(Eq(fd))).Times(1);

  EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _));

  EXPECT_CALL(mock, Close(Eq(fd)));

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

  EXPECT_CALL(mock, GetErrno);



  sls.Write(fd, data, sizeof(data));

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_EINVAL) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  char data[10];



  ON_CALL(mock, Send(_, _, _, _)).WillByDefault((Return(-1)));

  ON_CALL(mock, GetErrno()).WillByDefault((Return(EINVAL)));



  EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _)).Times(1);

  EXPECT_CALL(mock, Close(Eq(fd))).Times(0);

  EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _));

  EXPECT_CALL(mock, GetErrno).Times(2);



  sls.Write(fd, data, sizeof(data));

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int client_fd = 33;

  char data[10];
@@ -214,19 +211,12 @@ TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_success) { 
}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fail_no_client) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  char data[10];



  EXPECT_CALL(mock, Send).Times(0);

  EXPECT_CALL(mock, Close).Times(0);



  sls.Write(data, sizeof(data));

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int client_fd = 33;

  char data[10];
@@ -236,12 +226,10 @@ TEST_F(SnoopLoggerSocketModuleTest, test_Write_success) { 
  sls.ClientSocketConnected(client_fd);



  sls.Write(data, sizeof(data));

  EXPECT_CALL(mock, FDClr(Eq(client_fd), _));

}



TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_EINTR) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  char data[10];

  int intr_count = 5;
@@ -256,20 +244,17 @@ TEST_F(SnoopLoggerSocketModuleTest, test_Write_fd_fail_on_Send_EINTR) { 
  }));



  EXPECT_CALL(mock, Send(Eq(fd), Eq(data), Eq(sizeof(data)), _)).Times(intr_count + 1);

  EXPECT_CALL(mock, Close(Eq(fd))).Times(0);



  sls.Write(fd, data, sizeof(data));

}



TEST_F(SnoopLoggerSocketModuleTest, test_ClientSocketConnected) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ASSERT_FALSE(sls.IsClientSocketConnected());



  EXPECT_CALL(mock, Close(Eq(fd))).Times(1);

  EXPECT_CALL(mock, Close(Eq(fd + 1))).Times(1);

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

  EXPECT_CALL(mock, FDClr(Eq(fd + 1), _));



  sls.ClientSocketConnected(fd);
@@ -281,10 +266,6 @@ TEST_F(SnoopLoggerSocketModuleTest, test_ClientSocketConnected) { 
}



TEST_F(SnoopLoggerSocketModuleTest, test_WaitForClientSocketConnected) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;



  ASSERT_FALSE(sls.IsClientSocketConnected());



  sls.ClientSocketConnected(fd);
@@ -292,11 +273,12 @@ TEST_F(SnoopLoggerSocketModuleTest, test_WaitForClientSocketConnected) { 
  ASSERT_TRUE(sls.IsClientSocketConnected());



  ASSERT_TRUE(sls.WaitForClientSocketConnected());



  EXPECT_CALL(mock, Close(Eq(fd)));

  EXPECT_CALL(mock, FDClr(Eq(fd), _));

}



TEST_F(SnoopLoggerSocketModuleTest, test_InitializeClientSocket) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int client_fd = 10;



  EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);
@@ -305,33 +287,28 @@ TEST_F(SnoopLoggerSocketModuleTest, test_InitializeClientSocket) { 
}



TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EINVAL) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  int client_fd = 0;



  ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));



  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), EINVAL);

}



TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EBADF) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  int client_fd = 0;



  ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(EBADF));



  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), EBADF);

}



TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_EINTR) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  int client_fd = 0;

  int intr_count = 5;
@@ -346,52 +323,48 @@ TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept 
        return client_fd;

      }));



  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _)).Times(intr_count + 1);  // 5 intr + 1 with errno = 0

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), 0);

}



TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_fail_on_accept_other_errors) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  int client_fd = 0;



  ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(INVALID_FD));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(EAGAIN));



  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd), 0);

  ASSERT_EQ(client_fd, -1);

}



TEST_F(SnoopLoggerSocketModuleTest, test_AcceptIncomingConnection_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 10;

  int client_fd = 13;

  int client_fd_out = 0;



  ON_CALL(mock, Accept(Eq(fd), _, _, _)).WillByDefault(Return(client_fd));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(0));



  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));



  ASSERT_EQ(sls.AcceptIncomingConnection(fd, client_fd_out), 0);

  ASSERT_EQ(client_fd, client_fd_out);

}



TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_fail_on_Pipe2) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int ret = -9;



  ON_CALL(mock, Pipe2(_, _)).WillByDefault(Invoke([ret](int* fds, int) { return ret; }));

  EXPECT_CALL(mock, FDZero);

  EXPECT_CALL(mock, Pipe2(_, _));



  ASSERT_EQ(sls.InitializeCommunications(), ret);

}



TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_fail_on_CreateSocket) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int ret = -9;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault(Return(ret));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {
@@ -400,144 +373,77 @@ TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_fail_on_Create 
    return 0;

  }));



  EXPECT_CALL(mock, FDZero).Times(1);

  EXPECT_CALL(mock, FDSet(listen_fd, _)).Times(1);

  EXPECT_CALL(mock, Close(Eq(listen_fd))).Times(1);

  EXPECT_CALL(mock, Close(Eq(write_fd))).Times(1);

  EXPECT_CALL(mock, FDZero);

  EXPECT_CALL(mock, Pipe2(_, _));

  EXPECT_CALL(mock, FDSet(listen_fd, _));

  EXPECT_CALL(mock, Socket);

  EXPECT_CALL(mock, GetErrno);



  EXPECT_CALL(mock, Close(Eq(listen_fd)));

  EXPECT_CALL(mock, FDClr(Eq(listen_fd), _));

  EXPECT_CALL(mock, Close(Eq(write_fd)));

  EXPECT_CALL(mock, FDClr(Eq(write_fd), _));



  ASSERT_EQ(sls.InitializeCommunications(), -1);

}



TEST_F(SnoopLoggerSocketModuleTest, test_InitializeCommunications_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));



  EXPECT_CALL(mock, FDZero).Times(1);

  EXPECT_CALL(mock, FDSet(listen_fd, _)).Times(1);

  EXPECT_CALL(mock, FDSet(fd, _)).Times(1);

  EXPECT_CALL(mock, Socket).Times(1);

  EXPECT_CALL(mock, Setsockopt).Times(1);

  EXPECT_CALL(mock, Bind).Times(1);

  EXPECT_CALL(mock, Listen).Times(1);

  EXPECT_CALL(mock, Pipe2).Times(1);

  EXPECT_CALL(mock, Close(Eq(fd))).Times(1);

  EXPECT_CALL(mock, Close(Eq(listen_fd))).Times(1);

  EXPECT_CALL(mock, Close(Eq(write_fd))).Times(1);



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_fail_on_Select_EINTR) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  ON_CALL(mock, Select).WillByDefault((Return(-1)));

  ON_CALL(mock, GetErrno()).WillByDefault((Return(EINTR)));



  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, GetErrno).Times(2);

  ASSERT_TRUE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_fail_on_Select_EINVAL) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  ON_CALL(mock, Select).WillByDefault((Return(-1)));

  ON_CALL(mock, GetErrno()).WillByDefault((Return(EINVAL)));



  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, GetErrno).Times(2);

  ASSERT_FALSE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_no_fds) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  ON_CALL(mock, Select).WillByDefault((Return(0)));



  EXPECT_CALL(mock, Select);

  ASSERT_TRUE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_FDIsSet_false) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Select).WillByDefault((Return(0)));

  ON_CALL(mock, FDIsSet(fd, _)).WillByDefault((Return(false)));

  ON_CALL(mock, FDIsSet(listen_fd, _)).WillByDefault((Return(false)));



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, FDIsSet(Eq(fd), _));

  EXPECT_CALL(mock, FDIsSet(Eq(listen_fd), _));

  ASSERT_TRUE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_close) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Select).WillByDefault((Return(0)));

  ON_CALL(mock, FDIsSet(fd, _)).WillByDefault((Return(false)));

  ON_CALL(mock, FDIsSet(listen_fd, _)).WillByDefault((Return(true)));



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, FDIsSet(Eq(fd), _));

  EXPECT_CALL(mock, FDIsSet(Eq(listen_fd), _));

  ASSERT_FALSE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_exit) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Select).WillByDefault((Return(0)));

  ON_CALL(mock, FDIsSet(fd, _)).WillByDefault((Return(true)));
@@ -546,27 +452,15 @@ TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_ 
  ON_CALL(mock, Accept(fd, _, _, _)).WillByDefault(Return(INVALID_FD));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(EINVAL));



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, FDIsSet(Eq(fd), _));

  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_FALSE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_connection_fail_on_accept_continue) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Select).WillByDefault((Return(0)));

  ON_CALL(mock, FDIsSet(fd, _)).WillByDefault((Return(true)));
@@ -575,28 +469,17 @@ TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_ 
  ON_CALL(mock, Accept(fd, _, _, _)).WillByDefault(Return(INVALID_FD));

  ON_CALL(mock, GetErrno()).WillByDefault(Return(ENOMEM));



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, FDIsSet(Eq(fd), _));

  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  EXPECT_CALL(mock, GetErrno);

  ASSERT_TRUE(sls.ProcessIncomingRequest());

}



TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_connection_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  int fd = 11;

  int client_fd = 23;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));



  ON_CALL(mock, Select).WillByDefault((Return(0)));

  ON_CALL(mock, FDIsSet(fd, _)).WillByDefault((Return(true)));
@@ -607,60 +490,32 @@ TEST_F(SnoopLoggerSocketModuleTest, test_ProcessIncomingRequest_signal_incoming_ 


  EXPECT_CALL(mock, Send(client_fd, _, _, _)).Times(1);



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Select);

  EXPECT_CALL(mock, FDIsSet(Eq(fd), _));

  EXPECT_CALL(mock, Accept(Eq(fd), _, _, _));

  ASSERT_TRUE(sls.ProcessIncomingRequest());



  EXPECT_CALL(mock, Close(Eq(client_fd)));

  EXPECT_CALL(mock, FDClr(Eq(client_fd), _));

}



TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_no_fd) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  ASSERT_EQ(sls.NotifySocketListener(), 0);

}



TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_fail_on_write) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Write).WillByDefault((Return(-1)));



  EXPECT_CALL(mock, Write(write_fd, _, _)).Times(1);



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  ASSERT_EQ(sls.NotifySocketListener(), -1);

}



TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_fail_on_write_EINTR_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);

  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;

  int intr_count = 5;

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  int intr_count = 5;



  ON_CALL(mock, Write).WillByDefault(Invoke([&](int, const void*, size_t count) {

    if (intr_count > 0) {
@@ -674,33 +529,15 @@ TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_fail_on_write_EINT 


  EXPECT_CALL(mock, Write(write_fd, _, _)).Times(intr_count + 1);



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  ASSERT_EQ(sls.NotifySocketListener(), 0);

}



TEST_F(SnoopLoggerSocketModuleTest, test_NotifySocketListener_success) {

  SyscallWrapperMock mock;

  SnoopLoggerSocket sls(&mock);



  int fd = 11;

  int listen_fd = 66;

  int write_fd = 99;



  ON_CALL(mock, Socket(_, _, _)).WillByDefault((Return(fd)));

  ON_CALL(mock, Setsockopt(_, _, _, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Bind(_, _, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Listen(_, _)).WillByDefault((Return(0)));

  ON_CALL(mock, Pipe2).WillByDefault(Invoke([&](int* fds, int) {

    fds[0] = listen_fd;

    fds[1] = write_fd;

    return 0;

  }));

  ASSERT_NO_FATAL_FAILURE(InitializeCommunicationsSuccess(sls, mock));



  ON_CALL(mock, Write).WillByDefault((Return(0)));



  EXPECT_CALL(mock, Write(write_fd, _, _)).Times(1);



  ASSERT_EQ(sls.InitializeCommunications(), 0);

  EXPECT_CALL(mock, Write(write_fd, _, _));

  ASSERT_EQ(sls.NotifySocketListener(), 0);

}

system/gd/hal/snoop_logger_test.cc

+46 −15

File changed.

Preview size limit exceeded, changes collapsed.