1#include "uds/ipc_helper.h" 2 3#include <gmock/gmock.h> 4#include <gtest/gtest.h> 5 6using testing::Return; 7using testing::SetErrnoAndReturn; 8using testing::_; 9 10using android::pdx::BorrowedHandle; 11using android::pdx::uds::SendInterface; 12using android::pdx::uds::RecvInterface; 13using android::pdx::uds::SendAll; 14using android::pdx::uds::SendMsgAll; 15using android::pdx::uds::RecvAll; 16using android::pdx::uds::RecvMsgAll; 17 18namespace { 19 20// Useful constants for tests. 21static constexpr intptr_t kPtr = 1234; 22static constexpr int kSocketFd = 5678; 23static const BorrowedHandle kSocket{kSocketFd}; 24 25// Helper functions to construct test data pointer values. 26void* IntToPtr(intptr_t value) { return reinterpret_cast<void*>(value); } 27const void* IntToConstPtr(intptr_t value) { 28 return reinterpret_cast<const void*>(value); 29} 30 31// Mock classes for SendInterface/RecvInterface. 32class MockSender : public SendInterface { 33 public: 34 MOCK_METHOD4(Send, ssize_t(int socket_fd, const void* data, size_t size, 35 int flags)); 36 MOCK_METHOD3(SendMessage, 37 ssize_t(int socket_fd, const msghdr* msg, int flags)); 38}; 39 40class MockReceiver : public RecvInterface { 41 public: 42 MOCK_METHOD4(Receive, 43 ssize_t(int socket_fd, void* data, size_t size, int flags)); 44 MOCK_METHOD3(ReceiveMessage, ssize_t(int socket_fd, msghdr* msg, int flags)); 45}; 46 47// Test case classes. 48class SendTest : public testing::Test { 49 public: 50 SendTest() { 51 ON_CALL(sender_, Send(_, _, _, _)) 52 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 53 ON_CALL(sender_, SendMessage(_, _, _)) 54 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 55 } 56 57 protected: 58 MockSender sender_; 59}; 60 61class RecvTest : public testing::Test { 62 public: 63 RecvTest() { 64 ON_CALL(receiver_, Receive(_, _, _, _)) 65 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 66 ON_CALL(receiver_, ReceiveMessage(_, _, _)) 67 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 68 } 69 70 protected: 71 MockReceiver receiver_; 72}; 73 74class MessageTestBase : public testing::Test { 75 public: 76 MessageTestBase() { 77 memset(&msg_, 0, sizeof(msg_)); 78 msg_.msg_iovlen = data_.size(); 79 msg_.msg_iov = data_.data(); 80 } 81 82 protected: 83 static constexpr intptr_t kPtr1 = kPtr; 84 static constexpr intptr_t kPtr2 = kPtr + 200; 85 static constexpr intptr_t kPtr3 = kPtr + 1000; 86 87 MockSender sender_; 88 msghdr msg_; 89 std::vector<iovec> data_{ 90 {IntToPtr(kPtr1), 100}, {IntToPtr(kPtr2), 200}, {IntToPtr(kPtr3), 300}}; 91}; 92 93class SendMessageTest : public MessageTestBase { 94 public: 95 SendMessageTest() { 96 ON_CALL(sender_, Send(_, _, _, _)) 97 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 98 ON_CALL(sender_, SendMessage(_, _, _)) 99 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 100 } 101 102 protected: 103 MockSender sender_; 104}; 105 106class RecvMessageTest : public MessageTestBase { 107 public: 108 RecvMessageTest() { 109 ON_CALL(receiver_, Receive(_, _, _, _)) 110 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 111 ON_CALL(receiver_, ReceiveMessage(_, _, _)) 112 .WillByDefault(SetErrnoAndReturn(EIO, -1)); 113 } 114 115 protected: 116 MockReceiver receiver_; 117}; 118 119// Actual tests. 120 121// SendAll 122TEST_F(SendTest, Complete) { 123 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL)) 124 .WillOnce(Return(100)); 125 126 auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100); 127 EXPECT_TRUE(status); 128} 129 130TEST_F(SendTest, Signal) { 131 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL)) 132 .WillOnce(Return(20)); 133 EXPECT_CALL(sender_, 134 Send(kSocketFd, IntToConstPtr(kPtr + 20), 80, MSG_NOSIGNAL)) 135 .WillOnce(Return(40)); 136 EXPECT_CALL(sender_, 137 Send(kSocketFd, IntToConstPtr(kPtr + 60), 40, MSG_NOSIGNAL)) 138 .WillOnce(Return(40)); 139 140 auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100); 141 EXPECT_TRUE(status); 142} 143 144TEST_F(SendTest, Eintr) { 145 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL)) 146 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 147 .WillOnce(Return(100)); 148 149 auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100); 150 EXPECT_TRUE(status); 151} 152 153TEST_F(SendTest, Error) { 154 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL)) 155 .WillOnce(SetErrnoAndReturn(EIO, -1)); 156 157 auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100); 158 ASSERT_FALSE(status); 159 EXPECT_EQ(EIO, status.error()); 160} 161 162TEST_F(SendTest, Error2) { 163 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr), 100, MSG_NOSIGNAL)) 164 .WillOnce(Return(50)); 165 EXPECT_CALL(sender_, 166 Send(kSocketFd, IntToConstPtr(kPtr + 50), 50, MSG_NOSIGNAL)) 167 .WillOnce(SetErrnoAndReturn(EIO, -1)); 168 169 auto status = SendAll(&sender_, kSocket, IntToConstPtr(kPtr), 100); 170 ASSERT_FALSE(status); 171 EXPECT_EQ(EIO, status.error()); 172} 173 174// RecvAll 175TEST_F(RecvTest, Complete) { 176 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, 177 MSG_WAITALL | MSG_CMSG_CLOEXEC)) 178 .WillOnce(Return(100)); 179 180 auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100); 181 EXPECT_TRUE(status); 182} 183 184TEST_F(RecvTest, Signal) { 185 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _)) 186 .WillOnce(Return(20)); 187 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 20), 80, _)) 188 .WillOnce(Return(40)); 189 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 60), 40, _)) 190 .WillOnce(Return(40)); 191 192 auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100); 193 EXPECT_TRUE(status); 194} 195 196TEST_F(RecvTest, Eintr) { 197 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _)) 198 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 199 .WillOnce(Return(100)); 200 201 auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100); 202 EXPECT_TRUE(status); 203} 204 205TEST_F(RecvTest, Error) { 206 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _)) 207 .WillOnce(SetErrnoAndReturn(EIO, -1)); 208 209 auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100); 210 ASSERT_FALSE(status); 211 EXPECT_EQ(EIO, status.error()); 212} 213 214TEST_F(RecvTest, Error2) { 215 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr), 100, _)) 216 .WillOnce(Return(30)); 217 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr + 30), 70, _)) 218 .WillOnce(SetErrnoAndReturn(EIO, -1)); 219 220 auto status = RecvAll(&receiver_, kSocket, IntToPtr(kPtr), 100); 221 ASSERT_FALSE(status); 222 EXPECT_EQ(EIO, status.error()); 223} 224 225// SendMsgAll 226TEST_F(SendMessageTest, Complete) { 227 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, MSG_NOSIGNAL)) 228 .WillOnce(Return(600)); 229 230 auto status = SendMsgAll(&sender_, kSocket, &msg_); 231 EXPECT_TRUE(status); 232} 233 234TEST_F(SendMessageTest, Partial) { 235 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(70)); 236 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 70), 30, _)) 237 .WillOnce(Return(30)); 238 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2), 200, _)) 239 .WillOnce(Return(190)); 240 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2 + 190), 10, _)) 241 .WillOnce(Return(10)); 242 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3), 300, _)) 243 .WillOnce(Return(300)); 244 245 auto status = SendMsgAll(&sender_, kSocket, &msg_); 246 EXPECT_TRUE(status); 247} 248 249TEST_F(SendMessageTest, Partial2) { 250 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(310)); 251 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3 + 10), 290, _)) 252 .WillOnce(Return(290)); 253 254 auto status = SendMsgAll(&sender_, kSocket, &msg_); 255 EXPECT_TRUE(status); 256} 257 258TEST_F(SendMessageTest, Eintr) { 259 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)) 260 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 261 .WillOnce(Return(70)); 262 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 70), 30, _)) 263 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 264 .WillOnce(Return(30)); 265 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr2), 200, _)) 266 .WillOnce(Return(200)); 267 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr3), 300, _)) 268 .WillOnce(Return(300)); 269 270 auto status = SendMsgAll(&sender_, kSocket, &msg_); 271 EXPECT_TRUE(status); 272} 273 274TEST_F(SendMessageTest, Error) { 275 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)) 276 .WillOnce(SetErrnoAndReturn(EBADF, -1)); 277 278 auto status = SendMsgAll(&sender_, kSocket, &msg_); 279 ASSERT_FALSE(status); 280 EXPECT_EQ(EBADF, status.error()); 281} 282 283TEST_F(SendMessageTest, Error2) { 284 EXPECT_CALL(sender_, SendMessage(kSocketFd, &msg_, _)).WillOnce(Return(20)); 285 EXPECT_CALL(sender_, Send(kSocketFd, IntToConstPtr(kPtr1 + 20), 80, _)) 286 .WillOnce(SetErrnoAndReturn(EBADF, -1)); 287 288 auto status = SendMsgAll(&sender_, kSocket, &msg_); 289 ASSERT_FALSE(status); 290 EXPECT_EQ(EBADF, status.error()); 291} 292 293// RecvMsgAll 294TEST_F(RecvMessageTest, Complete) { 295 EXPECT_CALL(receiver_, 296 ReceiveMessage(kSocketFd, &msg_, MSG_WAITALL | MSG_CMSG_CLOEXEC)) 297 .WillOnce(Return(600)); 298 299 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 300 EXPECT_TRUE(status); 301} 302 303TEST_F(RecvMessageTest, Partial) { 304 EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _)) 305 .WillOnce(Return(70)); 306 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 70), 30, _)) 307 .WillOnce(Return(30)); 308 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2), 200, _)) 309 .WillOnce(Return(190)); 310 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2 + 190), 10, _)) 311 .WillOnce(Return(10)); 312 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3), 300, _)) 313 .WillOnce(Return(300)); 314 315 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 316 EXPECT_TRUE(status); 317} 318 319TEST_F(RecvMessageTest, Partial2) { 320 EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _)) 321 .WillOnce(Return(310)); 322 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3 + 10), 290, _)) 323 .WillOnce(Return(290)); 324 325 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 326 EXPECT_TRUE(status); 327} 328 329TEST_F(RecvMessageTest, Eintr) { 330 EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _)) 331 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 332 .WillOnce(Return(70)); 333 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 70), 30, _)) 334 .WillOnce(SetErrnoAndReturn(EINTR, -1)) 335 .WillOnce(Return(30)); 336 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr2), 200, _)) 337 .WillOnce(Return(200)); 338 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr3), 300, _)) 339 .WillOnce(Return(300)); 340 341 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 342 EXPECT_TRUE(status); 343} 344 345TEST_F(RecvMessageTest, Error) { 346 EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _)) 347 .WillOnce(SetErrnoAndReturn(EBADF, -1)); 348 349 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 350 ASSERT_FALSE(status); 351 EXPECT_EQ(EBADF, status.error()); 352} 353 354TEST_F(RecvMessageTest, Error2) { 355 EXPECT_CALL(receiver_, ReceiveMessage(kSocketFd, &msg_, _)) 356 .WillOnce(Return(20)); 357 EXPECT_CALL(receiver_, Receive(kSocketFd, IntToPtr(kPtr1 + 20), 80, _)) 358 .WillOnce(SetErrnoAndReturn(EBADF, -1)); 359 360 auto status = RecvMsgAll(&receiver_, kSocket, &msg_); 361 ASSERT_FALSE(status); 362 EXPECT_EQ(EBADF, status.error()); 363} 364 365} // namespace 366