kernel_wrap_test.cc revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1
1// Copyright (c) 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5// The linux host build of nacl_io can't do wrapping of syscalls so all 6// these tests must be disabled. 7#if !defined(__linux__) 8 9#include <unistd.h> 10 11#include <string> 12#include <vector> 13 14#include "gtest/gtest.h" 15#include "mock_kernel_proxy.h" 16#include "nacl_io/kernel_intercept.h" 17#include "nacl_io/kernel_wrap.h" 18#include "nacl_io/osmman.h" 19#include "nacl_io/ossocket.h" 20#include "nacl_io/ostermios.h" 21 22#if defined(__native_client__) && !defined(__GLIBC__) 23extern "C" { 24// TODO(sbc): remove once these get added to the newlib toolchain headers. 25int fchdir(int fd); 26int utimes(const char *filename, const struct timeval times[2]); 27} 28#endif 29 30using namespace nacl_io; 31 32using ::testing::_; 33using ::testing::DoAll; 34using ::testing::Return; 35using ::testing::StrEq; 36 37namespace { 38 39#define COMPARE_FIELD(f) \ 40 if (arg->f != statbuf->f) { \ 41 *result_listener << "mismatch of field \"" #f \ 42 "\". " \ 43 "expected: " << statbuf->f << " actual: " << arg->f; \ 44 return false; \ 45 } 46 47MATCHER_P(IsEqualToStatbuf, statbuf, "") { 48 COMPARE_FIELD(st_dev); 49 COMPARE_FIELD(st_ino); 50 COMPARE_FIELD(st_mode); 51 COMPARE_FIELD(st_nlink); 52 COMPARE_FIELD(st_uid); 53 COMPARE_FIELD(st_gid); 54 COMPARE_FIELD(st_rdev); 55 COMPARE_FIELD(st_size); 56 COMPARE_FIELD(st_atime); 57 COMPARE_FIELD(st_mtime); 58 COMPARE_FIELD(st_ctime); 59 return true; 60} 61 62#undef COMPARE_FIELD 63 64ACTION_P(SetStat, statbuf) { 65 memset(arg1, 0, sizeof(struct stat)); 66 arg1->st_dev = statbuf->st_dev; 67 arg1->st_ino = statbuf->st_ino; 68 arg1->st_mode = statbuf->st_mode; 69 arg1->st_nlink = statbuf->st_nlink; 70 arg1->st_uid = statbuf->st_uid; 71 arg1->st_gid = statbuf->st_gid; 72 arg1->st_rdev = statbuf->st_rdev; 73 arg1->st_size = statbuf->st_size; 74 arg1->st_atime = statbuf->st_atime; 75 arg1->st_mtime = statbuf->st_mtime; 76 arg1->st_ctime = statbuf->st_ctime; 77} 78 79void MakeDummyStatbuf(struct stat* statbuf) { 80 memset(&statbuf[0], 0, sizeof(struct stat)); 81 statbuf->st_dev = 1; 82 statbuf->st_ino = 2; 83 statbuf->st_mode = 3; 84 statbuf->st_nlink = 4; 85 statbuf->st_uid = 5; 86 statbuf->st_gid = 6; 87 statbuf->st_rdev = 7; 88 statbuf->st_size = 8; 89 statbuf->st_atime = 9; 90 statbuf->st_mtime = 10; 91 statbuf->st_ctime = 11; 92} 93 94const mode_t kDummyMode = 0xbeef; 95const int kDummyInt = 0xdedbeef; 96const int kDummyInt2 = 0xcabba6e; 97const int kDummyInt3 = 0xf00ba4; 98const int kDummyInt4 = 0xabacdba; 99const size_t kDummySizeT = 0x60067e; 100const char* kDummyConstChar = "foobar"; 101const char* kDummyConstChar2 = "g00gl3"; 102const char* kDummyConstChar3 = "fr00gl3"; 103const void* kDummyVoidPtr = "blahblah"; 104const uid_t kDummyUid = 1001; 105const gid_t kDummyGid = 1002; 106 107class KernelWrapTest : public ::testing::Test { 108 public: 109 KernelWrapTest() {} 110 111 virtual void SetUp() { 112 // Initializing the KernelProxy opens stdin/stdout/stderr. 113 EXPECT_CALL(mock, open(_, _)) 114 .WillOnce(Return(0)) 115 .WillOnce(Return(1)) 116 .WillOnce(Return(2)); 117 // And will call mount / and /dev. 118 EXPECT_CALL(mock, mount(_, _, _, _, _)) 119 .WillOnce(Return(0)) 120 .WillOnce(Return(0)); 121 122 ASSERT_EQ(0, ki_push_state_for_testing()); 123 ASSERT_EQ(0, ki_init(&mock)); 124 } 125 126 void TearDown() { 127 // Uninitialize the kernel proxy so wrapped functions passthrough to their 128 // unwrapped versions. 129 ki_uninit(); 130 } 131 132 133 MockKernelProxy mock; 134}; 135 136} // namespace 137 138TEST_F(KernelWrapTest, access) { 139 EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(-1)); 140 EXPECT_EQ(-1, access(kDummyConstChar, kDummyInt)); 141 142 EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(0)); 143 EXPECT_EQ(0, access(kDummyConstChar, kDummyInt)); 144} 145 146TEST_F(KernelWrapTest, chdir) { 147 EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(-1)); 148 EXPECT_EQ(-1, chdir(kDummyConstChar)); 149 150 EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(0)); 151 EXPECT_EQ(0, chdir(kDummyConstChar)); 152} 153 154TEST_F(KernelWrapTest, chmod) { 155 EXPECT_CALL(mock, chmod(kDummyConstChar, kDummyMode)) 156 .WillOnce(Return(kDummyInt2)); 157 EXPECT_EQ(kDummyInt2,chmod(kDummyConstChar, kDummyMode)); 158} 159 160TEST_F(KernelWrapTest, chown) { 161 EXPECT_CALL(mock, chown(kDummyConstChar, kDummyUid, kDummyGid)) 162 .WillOnce(Return(kDummyInt)); 163 EXPECT_EQ(kDummyInt, chown(kDummyConstChar, kDummyUid, kDummyGid)); 164} 165 166TEST_F(KernelWrapTest, close) { 167 // The way we wrap close does not support returning arbitrary values, so we 168 // test 0 and -1. 169 EXPECT_CALL(mock, close(kDummyInt)) 170 .WillOnce(Return(0)) 171 .WillOnce(Return(-1)); 172 173 EXPECT_EQ(0, close(kDummyInt)); 174 EXPECT_EQ(-1, close(kDummyInt)); 175} 176 177TEST_F(KernelWrapTest, dup) { 178 EXPECT_CALL(mock, dup(kDummyInt)).WillOnce(Return(kDummyInt2)); 179 EXPECT_EQ(kDummyInt2, dup(kDummyInt)); 180} 181 182TEST_F(KernelWrapTest, dup2) { 183 // The way we wrap dup2 does not support returning aribtrary values, only -1 184 // or the value of the new fd. 185 EXPECT_CALL(mock, dup2(kDummyInt, kDummyInt2)) 186 .WillOnce(Return(kDummyInt2)) 187 .WillOnce(Return(-1)); 188 EXPECT_EQ(kDummyInt2, dup2(kDummyInt, kDummyInt2)); 189 EXPECT_EQ(-1, dup2(kDummyInt, kDummyInt2)); 190} 191 192TEST_F(KernelWrapTest, fchdir) { 193 EXPECT_CALL(mock, fchdir(kDummyInt)) 194 .WillOnce(Return(-1)); 195 EXPECT_EQ(-1, fchdir(kDummyInt)); 196} 197 198TEST_F(KernelWrapTest, fchmod) { 199 EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode)) 200 .WillOnce(Return(-1)); 201 EXPECT_EQ(-1, fchmod(kDummyInt, kDummyMode)); 202 203 EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode)) .WillOnce(Return(0)); 204 EXPECT_EQ(0, fchmod(kDummyInt, kDummyMode)); 205} 206 207TEST_F(KernelWrapTest, fchown) { 208 EXPECT_CALL(mock, fchown(kDummyInt, kDummyUid, kDummyGid)) 209 .WillOnce(Return(kDummyInt)); 210 EXPECT_EQ(kDummyInt, fchown(kDummyInt, kDummyUid, kDummyGid)); 211} 212 213TEST_F(KernelWrapTest, fcntl) { 214 char buffer[] = "fcntl"; 215 EXPECT_CALL(mock, fcntl(kDummyInt, kDummyInt2, _)) 216 .WillOnce(Return(kDummyInt3)); 217 EXPECT_EQ(kDummyInt3, fcntl(kDummyInt, kDummyInt2, buffer)); 218} 219 220TEST_F(KernelWrapTest, fdatasync) { 221 EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(-1)); 222 EXPECT_EQ(-1, fdatasync(kDummyInt)); 223 224 EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(0)); 225 EXPECT_EQ(0, fdatasync(kDummyInt)); 226} 227 228TEST_F(KernelWrapTest, fstat) { 229 // The way we wrap fstat does not support returning aribtrary values, only 0 230 // or -1. 231 struct stat in_statbuf; 232 MakeDummyStatbuf(&in_statbuf); 233 EXPECT_CALL(mock, fstat(kDummyInt, _)) 234 .WillOnce(DoAll(SetStat(&in_statbuf), Return(0))) 235 .WillOnce(Return(-1)); 236 struct stat out_statbuf; 237 EXPECT_EQ(0, fstat(kDummyInt, &out_statbuf)); 238 EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf)); 239 EXPECT_EQ(-1, fstat(kDummyInt, &out_statbuf)); 240} 241 242TEST_F(KernelWrapTest, ftruncate) { 243 EXPECT_CALL(mock, ftruncate(kDummyInt, kDummyInt2)) 244 .WillOnce(Return(kDummyInt3)); 245 EXPECT_EQ(kDummyInt3, ftruncate(kDummyInt, kDummyInt2)); 246} 247 248TEST_F(KernelWrapTest, fsync) { 249 EXPECT_CALL(mock, fsync(kDummyInt)).WillOnce(Return(-1)); 250 EXPECT_EQ(-1, fsync(kDummyInt)); 251} 252 253TEST_F(KernelWrapTest, getcwd) { 254 char result[] = "getcwd_result"; 255 char buffer[] = "getcwd"; 256 EXPECT_CALL(mock, getcwd(buffer, kDummySizeT)).WillOnce(Return(result)); 257 EXPECT_EQ(result, getcwd(buffer, kDummySizeT)); 258} 259 260TEST_F(KernelWrapTest, getdents) { 261#if !defined( __GLIBC__) && !defined(__BIONIC__) 262 // TODO(sbc): Find a way to test the getdents wrapper under glibc. 263 // It looks like the only way to exercise it is to call readdir(2). 264 // There is an internal glibc function __getdents that will call the 265 // IRT but that cannot be accessed from here as glibc does not export it. 266 int dummy_val; 267 void* void_ptr = &dummy_val; 268 EXPECT_CALL(mock, getdents(kDummyInt, void_ptr, kDummyInt2)) 269 .WillOnce(Return(kDummyInt2)); 270 EXPECT_EQ(kDummyInt2, getdents(kDummyInt, void_ptr, kDummyInt2)); 271#endif 272} 273 274// gcc gives error: getwd is deprecated. 275#if defined(__GNUC__) 276#pragma GCC diagnostic ignored "-Wdeprecated-declarations" 277#endif 278TEST_F(KernelWrapTest, getwd) { 279 char result[] = "getwd_result"; 280 char buffer[] = "getwd"; 281 EXPECT_CALL(mock, getwd(buffer)).WillOnce(Return(result)); 282 EXPECT_EQ(result, getwd(buffer)); 283} 284#if defined(__GNUC__) 285#pragma GCC diagnostic warning "-Wdeprecated-declarations" 286#endif 287 288TEST_F(KernelWrapTest, ioctl) { 289 char buffer[] = "ioctl"; 290 EXPECT_CALL(mock, ioctl(kDummyInt, kDummyInt2, _)) 291 .WillOnce(Return(kDummyInt3)); 292 EXPECT_EQ(kDummyInt3, ioctl(kDummyInt, kDummyInt2, buffer)); 293} 294 295#if !defined(__BIONIC__) 296TEST_F(KernelWrapTest, isatty) { 297 EXPECT_CALL(mock, isatty(kDummyInt)).WillOnce(Return(kDummyInt2)); 298 EXPECT_EQ(kDummyInt2, isatty(kDummyInt)); 299 300 // This test verifies that the IRT interception wrapper for isatty 301 // ignores the value of errno when isatty() returns 1. We had a bug 302 // where returning 1 from ki_isatty resulted in errno being returned 303 // by the IRT interface. 304 errno = kDummyInt3; 305 EXPECT_CALL(mock, isatty(kDummyInt)).WillOnce(Return(1)); 306 EXPECT_EQ(1, isatty(kDummyInt)); 307} 308#endif 309 310TEST_F(KernelWrapTest, kill) { 311 EXPECT_CALL(mock, kill(kDummyInt, kDummyInt2)).WillOnce(Return(kDummyInt3)); 312 EXPECT_EQ(kDummyInt3, kill(kDummyInt, kDummyInt2)); 313} 314 315TEST_F(KernelWrapTest, lchown) { 316 EXPECT_CALL(mock, lchown(kDummyConstChar, kDummyUid, kDummyGid)) 317 .WillOnce(Return(kDummyInt)); 318 EXPECT_EQ(kDummyInt, lchown(kDummyConstChar, kDummyUid, kDummyGid)); 319} 320 321TEST_F(KernelWrapTest, link) { 322 EXPECT_CALL(mock, link(kDummyConstChar, kDummyConstChar2)) 323 .WillOnce(Return(kDummyInt)); 324 EXPECT_EQ(kDummyInt, link(kDummyConstChar, kDummyConstChar2)); 325} 326 327TEST_F(KernelWrapTest, lseek) { 328 EXPECT_CALL(mock, lseek(kDummyInt, kDummyInt2, kDummyInt3)) 329 .WillOnce(Return(kDummyInt4)); 330 EXPECT_EQ(kDummyInt4, lseek(kDummyInt, kDummyInt2, kDummyInt3)); 331} 332 333TEST_F(KernelWrapTest, mkdir) { 334#if defined(WIN32) 335 EXPECT_CALL(mock, mkdir(kDummyConstChar, 0777)).WillOnce(Return(kDummyInt2)); 336 EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar)); 337#else 338 EXPECT_CALL(mock, mkdir(kDummyConstChar, kDummyMode)) 339 .WillOnce(Return(kDummyInt2)); 340 EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar, kDummyMode)); 341#endif 342} 343 344TEST_F(KernelWrapTest, mmap) { 345 // We only wrap mmap if |flags| has the MAP_ANONYMOUS bit unset. 346 int flags = kDummyInt2 & ~MAP_ANONYMOUS; 347 348 const size_t kDummySizeT2 = 0xbadf00d; 349 int dummy1 = 123; 350 int dummy2 = 456; 351 void* kDummyVoidPtr1 = &dummy1; 352 void* kDummyVoidPtr2 = &dummy2; 353 EXPECT_CALL(mock, 354 mmap(kDummyVoidPtr1, 355 kDummySizeT, 356 kDummyInt, 357 flags, 358 kDummyInt3, 359 kDummySizeT2)).WillOnce(Return(kDummyVoidPtr2)); 360 EXPECT_EQ(kDummyVoidPtr2, 361 mmap(kDummyVoidPtr1, 362 kDummySizeT, 363 kDummyInt, 364 flags, 365 kDummyInt3, 366 kDummySizeT2)); 367} 368 369TEST_F(KernelWrapTest, mount) { 370 EXPECT_CALL(mock, 371 mount(kDummyConstChar, 372 kDummyConstChar2, 373 kDummyConstChar3, 374 kDummyInt, 375 kDummyVoidPtr)).WillOnce(Return(kDummyInt2)); 376 EXPECT_EQ(kDummyInt2, 377 mount(kDummyConstChar, 378 kDummyConstChar2, 379 kDummyConstChar3, 380 kDummyInt, 381 kDummyVoidPtr)); 382} 383 384TEST_F(KernelWrapTest, munmap) { 385 // The way we wrap munmap, calls the "real" mmap as well as the intercepted 386 // one. The result returned is from the "real" mmap. 387 int dummy1 = 123; 388 void* kDummyVoidPtr = &dummy1; 389 size_t kDummySizeT = sizeof(kDummyVoidPtr); 390 EXPECT_CALL(mock, munmap(kDummyVoidPtr, kDummySizeT)); 391 munmap(kDummyVoidPtr, kDummySizeT); 392} 393 394 395TEST_F(KernelWrapTest, open) { 396 // We pass O_RDONLY because we do not want an error in flags translation 397 EXPECT_CALL(mock, open(kDummyConstChar, 0)) 398 .WillOnce(Return(kDummyInt2)); 399 EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0)); 400 401 EXPECT_CALL(mock, open(kDummyConstChar, 0)) 402 .WillOnce(Return(kDummyInt2)); 403 EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0)); 404} 405 406TEST_F(KernelWrapTest, pipe) { 407 int fds[] = {1, 2}; 408 EXPECT_CALL(mock, pipe(fds)).WillOnce(Return(kDummyInt)); 409 EXPECT_EQ(kDummyInt, pipe(fds)); 410} 411 412TEST_F(KernelWrapTest, read) { 413 int dummy_value; 414 void* dummy_void_ptr = &dummy_value; 415 EXPECT_CALL(mock, read(kDummyInt, dummy_void_ptr, kDummyInt2)) 416 .WillOnce(Return(kDummyInt3)); 417 EXPECT_EQ(kDummyInt3, read(kDummyInt, dummy_void_ptr, kDummyInt2)); 418} 419 420TEST_F(KernelWrapTest, readlink) { 421 char buf[10]; 422 423 EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10)) 424 .WillOnce(Return(-1)); 425 EXPECT_EQ(-1, readlink(kDummyConstChar, buf, 10)); 426 427 EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10)) 428 .WillOnce(Return(kDummyInt)); 429 EXPECT_EQ(kDummyInt, readlink(kDummyConstChar, buf, 10)); 430} 431 432#ifdef __GLIBC__ 433// Under newlib there is no remove syscall. Instead it is implemented 434// in terms of unlink()/rmdir(). 435TEST_F(KernelWrapTest, remove) { 436 EXPECT_CALL(mock, remove(kDummyConstChar)).WillOnce(Return(-1)); 437 EXPECT_EQ(-1, remove(kDummyConstChar)); 438} 439#endif 440 441TEST_F(KernelWrapTest, rename) { 442 EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2)) 443 .WillOnce(Return(-1)); 444 EXPECT_EQ(-1, rename(kDummyConstChar, kDummyConstChar2)); 445 446 EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2)) 447 .WillOnce(Return(0)); 448 EXPECT_EQ(0, rename(kDummyConstChar, kDummyConstChar2)); 449} 450 451TEST_F(KernelWrapTest, rmdir) { 452 EXPECT_CALL(mock, rmdir(kDummyConstChar)).WillOnce(Return(kDummyInt)); 453 EXPECT_EQ(kDummyInt, rmdir(kDummyConstChar)); 454} 455 456static void new_handler(int) {} 457 458TEST_F(KernelWrapTest, sigaction) { 459 struct sigaction action; 460 struct sigaction oaction; 461 EXPECT_CALL(mock, sigaction(kDummyInt, &action, &oaction)) 462 .WillOnce(Return(0)); 463 EXPECT_EQ(0, sigaction(kDummyInt, &action, &oaction)); 464} 465 466TEST_F(KernelWrapTest, sigset) { 467 EXPECT_CALL(mock, sigaction(kDummyInt, _, _)) 468 .WillOnce(Return(0)); 469 EXPECT_EQ(NULL, sigset(kDummyInt, new_handler)); 470} 471 472TEST_F(KernelWrapTest, signal) { 473 // KernelIntercept forwards calls to signal to KernelProxy::sigset. 474 EXPECT_CALL(mock, sigaction(kDummyInt, _, _)) 475 .WillOnce(Return(0)); 476 EXPECT_EQ(NULL, signal(kDummyInt, new_handler)); 477} 478 479TEST_F(KernelWrapTest, stat) { 480 // The way we wrap stat does not support returning aribtrary values, only 0 481 // or -1. 482 struct stat in_statbuf; 483 MakeDummyStatbuf(&in_statbuf); 484 EXPECT_CALL(mock, stat(StrEq(kDummyConstChar), _)) 485 .WillOnce(DoAll(SetStat(&in_statbuf), Return(0))) 486 .WillOnce(Return(-1)); 487 struct stat out_statbuf; 488 EXPECT_EQ(0, stat(kDummyConstChar, &out_statbuf)); 489 EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf)); 490 EXPECT_EQ(-1, stat(kDummyConstChar, &out_statbuf)); 491} 492 493TEST_F(KernelWrapTest, symlink) { 494 EXPECT_CALL(mock, symlink(kDummyConstChar, kDummyConstChar2)) 495 .WillOnce(Return(kDummyInt)); 496 EXPECT_EQ(kDummyInt, symlink(kDummyConstChar, kDummyConstChar2)); 497} 498 499#ifndef __BIONIC__ 500TEST_F(KernelWrapTest, tcflush) { 501 EXPECT_CALL(mock, tcflush(kDummyInt, kDummyInt2)) 502 .WillOnce(Return(kDummyInt3)); 503 EXPECT_EQ(kDummyInt3, tcflush(kDummyInt, kDummyInt2)); 504} 505 506TEST_F(KernelWrapTest, tcgetattr) { 507 struct termios term; 508 EXPECT_CALL(mock, tcgetattr(kDummyInt, &term)).WillOnce(Return(kDummyInt2)); 509 EXPECT_EQ(kDummyInt2, tcgetattr(kDummyInt, &term)); 510} 511 512TEST_F(KernelWrapTest, tcsetattr) { 513 struct termios term; 514 EXPECT_CALL(mock, tcsetattr(kDummyInt, kDummyInt2, &term)) 515 .WillOnce(Return(kDummyInt3)); 516 EXPECT_EQ(kDummyInt3, tcsetattr(kDummyInt, kDummyInt2, &term)); 517} 518#endif 519 520TEST_F(KernelWrapTest, umount) { 521 EXPECT_CALL(mock, umount(kDummyConstChar)).WillOnce(Return(kDummyInt)); 522 EXPECT_EQ(kDummyInt, umount(kDummyConstChar)); 523} 524 525TEST_F(KernelWrapTest, truncate) { 526 EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(-1)); 527 EXPECT_EQ(-1, truncate(kDummyConstChar, kDummyInt3)); 528 529 EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(0)); 530 EXPECT_EQ(0, truncate(kDummyConstChar, kDummyInt3)); 531} 532 533TEST_F(KernelWrapTest, lstat) { 534 struct stat in_statbuf; 535 MakeDummyStatbuf(&in_statbuf); 536 EXPECT_CALL(mock, lstat(StrEq(kDummyConstChar), _)) 537 .WillOnce(DoAll(SetStat(&in_statbuf), Return(0))) 538 .WillOnce(Return(-1)); 539 struct stat out_statbuf; 540 EXPECT_EQ(0, lstat(kDummyConstChar, &out_statbuf)); 541 EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf)); 542 EXPECT_EQ(-1, lstat(kDummyConstChar, &out_statbuf)); 543} 544 545TEST_F(KernelWrapTest, unlink) { 546 EXPECT_CALL(mock, unlink(kDummyConstChar)).WillOnce(Return(kDummyInt)); 547 EXPECT_EQ(kDummyInt, unlink(kDummyConstChar)); 548} 549 550TEST_F(KernelWrapTest, utime) { 551 const struct utimbuf* times = NULL; 552 EXPECT_CALL(mock, utime(kDummyConstChar, times)).WillOnce(Return(kDummyInt)); 553 EXPECT_EQ(kDummyInt, utime(kDummyConstChar, times)); 554} 555 556TEST_F(KernelWrapTest, utimes) { 557 struct timeval* times = NULL; 558 EXPECT_CALL(mock, utimes(kDummyConstChar, times)).WillOnce(Return(-1)); 559 EXPECT_EQ(-1, utimes(kDummyConstChar, times)); 560} 561 562TEST_F(KernelWrapTest, write) { 563 EXPECT_CALL(mock, write(kDummyInt, kDummyVoidPtr, kDummyInt2)) 564 .WillOnce(Return(kDummyInt3)); 565 EXPECT_EQ(kDummyInt3, write(kDummyInt, kDummyVoidPtr, kDummyInt2)); 566} 567 568#if defined(PROVIDES_SOCKET_API) and !defined(__BIONIC__) 569TEST_F(KernelWrapTest, poll) { 570 struct pollfd fds; 571 EXPECT_CALL(mock, poll(&fds, kDummyInt, kDummyInt2)) 572 .WillOnce(Return(kDummyInt3)); 573 EXPECT_EQ(kDummyInt3, poll(&fds, kDummyInt, kDummyInt2)); 574} 575 576TEST_F(KernelWrapTest, select) { 577 fd_set readfds; 578 fd_set writefds; 579 fd_set exceptfds; 580 EXPECT_CALL(mock, select(kDummyInt, &readfds, &writefds, &exceptfds, NULL)) 581 .WillOnce(Return(kDummyInt2)); 582 EXPECT_EQ(kDummyInt2, 583 select(kDummyInt, &readfds, &writefds, &exceptfds, NULL)); 584} 585 586// Socket Functions 587TEST_F(KernelWrapTest, accept) { 588 struct sockaddr addr; 589 socklen_t len; 590 EXPECT_CALL(mock, accept(kDummyInt, &addr, &len)) 591 .WillOnce(Return(kDummyInt2)); 592 EXPECT_EQ(kDummyInt2, accept(kDummyInt, &addr, &len)); 593} 594 595TEST_F(KernelWrapTest, bind) { 596 struct sockaddr addr; 597 EXPECT_CALL(mock, bind(kDummyInt, &addr, kDummyInt2)) 598 .WillOnce(Return(kDummyInt2)); 599 EXPECT_EQ(kDummyInt2, bind(kDummyInt, &addr, kDummyInt2)); 600} 601 602TEST_F(KernelWrapTest, connect) { 603 struct sockaddr addr; 604 EXPECT_CALL(mock, connect(kDummyInt, &addr, kDummyInt2)) 605 .WillOnce(Return(kDummyInt2)); 606 EXPECT_EQ(kDummyInt2, connect(kDummyInt, &addr, kDummyInt2)); 607} 608 609TEST_F(KernelWrapTest, gethostbyname) { 610 struct hostent result; 611 EXPECT_CALL(mock, gethostbyname(kDummyConstChar)).WillOnce(Return(&result)); 612 EXPECT_EQ(&result, gethostbyname(kDummyConstChar)); 613} 614 615TEST_F(KernelWrapTest, getpeername) { 616 struct sockaddr addr; 617 socklen_t len; 618 EXPECT_CALL(mock, getpeername(kDummyInt, &addr, &len)) 619 .WillOnce(Return(kDummyInt2)); 620 EXPECT_EQ(kDummyInt2, getpeername(kDummyInt, &addr, &len)); 621} 622 623TEST_F(KernelWrapTest, getsockname) { 624 struct sockaddr addr; 625 socklen_t len; 626 EXPECT_CALL(mock, getsockname(kDummyInt, &addr, &len)) 627 .WillOnce(Return(kDummyInt2)); 628 EXPECT_EQ(kDummyInt2, getsockname(kDummyInt, &addr, &len)); 629} 630 631TEST_F(KernelWrapTest, getsockopt) { 632 int dummy_val; 633 void* dummy_void_ptr = &dummy_val; 634 socklen_t len; 635 EXPECT_CALL( 636 mock, getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len)) 637 .WillOnce(Return(kDummyInt4)); 638 EXPECT_EQ( 639 kDummyInt4, 640 getsockopt(kDummyInt, kDummyInt2, kDummyInt3, dummy_void_ptr, &len)); 641} 642 643TEST_F(KernelWrapTest, listen) { 644 EXPECT_CALL(mock, listen(kDummyInt, kDummyInt2)).WillOnce(Return(kDummyInt3)); 645 EXPECT_EQ(kDummyInt3, listen(kDummyInt, kDummyInt2)); 646} 647 648TEST_F(KernelWrapTest, recv) { 649 int dummy_val; 650 void* dummy_void_ptr = &dummy_val; 651 EXPECT_CALL(mock, recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2)) 652 .WillOnce(Return(kDummyInt3)); 653 EXPECT_EQ(kDummyInt3, 654 recv(kDummyInt, dummy_void_ptr, kDummySizeT, kDummyInt2)); 655} 656 657TEST_F(KernelWrapTest, recvfrom) { 658 int dummy_val; 659 void* dummy_void_ptr = &dummy_val; 660 struct sockaddr addr; 661 socklen_t len; 662 EXPECT_CALL( 663 mock, 664 recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len)) 665 .WillOnce(Return(kDummyInt4)); 666 EXPECT_EQ( 667 kDummyInt4, 668 recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len)); 669} 670 671#ifndef __BIONIC__ 672TEST_F(KernelWrapTest, recvmsg) { 673 struct msghdr msg; 674 EXPECT_CALL(mock, recvmsg(kDummyInt, &msg, kDummyInt2)) 675 .WillOnce(Return(kDummyInt3)); 676 EXPECT_EQ(kDummyInt3, recvmsg(kDummyInt, &msg, kDummyInt2)); 677} 678#endif 679 680TEST_F(KernelWrapTest, send) { 681 EXPECT_CALL(mock, send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2)) 682 .WillOnce(Return(kDummyInt3)); 683 EXPECT_EQ(kDummyInt3, 684 send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2)); 685} 686 687TEST_F(KernelWrapTest, sendto) { 688 const socklen_t kDummySockLen = 0x50cc5; 689 struct sockaddr addr; 690 EXPECT_CALL(mock, 691 sendto(kDummyInt, 692 kDummyVoidPtr, 693 kDummyInt2, 694 kDummyInt3, 695 &addr, 696 kDummySockLen)).WillOnce(Return(kDummyInt4)); 697 EXPECT_EQ(kDummyInt4, 698 sendto(kDummyInt, 699 kDummyVoidPtr, 700 kDummyInt2, 701 kDummyInt3, 702 &addr, 703 kDummySockLen)); 704} 705 706TEST_F(KernelWrapTest, sendmsg) { 707 struct msghdr msg; 708 EXPECT_CALL(mock, sendmsg(kDummyInt, &msg, kDummyInt2)) 709 .WillOnce(Return(kDummyInt3)); 710 EXPECT_EQ(kDummyInt3, sendmsg(kDummyInt, &msg, kDummyInt2)); 711} 712 713TEST_F(KernelWrapTest, setsockopt) { 714 const socklen_t kDummySockLen = 0x50cc5; 715 EXPECT_CALL( 716 mock, 717 setsockopt( 718 kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen)) 719 .WillOnce(Return(kDummyInt4)); 720 EXPECT_EQ( 721 kDummyInt4, 722 setsockopt( 723 kDummyInt, kDummyInt2, kDummyInt3, kDummyVoidPtr, kDummySockLen)); 724} 725 726TEST_F(KernelWrapTest, shutdown) { 727 EXPECT_CALL(mock, shutdown(kDummyInt, kDummyInt2)) 728 .WillOnce(Return(kDummyInt3)); 729 EXPECT_EQ(kDummyInt3, shutdown(kDummyInt, kDummyInt2)); 730} 731 732TEST_F(KernelWrapTest, socket) { 733 EXPECT_CALL(mock, socket(kDummyInt, kDummyInt2, kDummyInt3)) 734 .WillOnce(Return(kDummyInt4)); 735 EXPECT_EQ(kDummyInt4, socket(kDummyInt, kDummyInt2, kDummyInt3)); 736} 737 738TEST_F(KernelWrapTest, socketpair) { 739 int dummy_val; 740 EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val)) 741 .WillOnce(Return(kDummyInt4)); 742 EXPECT_EQ(kDummyInt4, 743 socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val)); 744} 745 746#endif // PROVIDES_SOCKET_API 747 748#endif // __linux__ 749