src/native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc

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