[NaCl SDK] nacl_io: Make IRT intercepts (and their test code) more robust.

native_client_sdk/src/tests/nacl_io_test/kernel_wrap_test.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The linux host build of nacl_io can't do wrapping of syscalls so all
 // these tests must be disabled.
 #if !defined(__linux__)
 
 #include <unistd.h>
 
@@ skipping 43 matching lines @@
   COMPARE_FIELD(st_rdev);
   COMPARE_FIELD(st_size);
   COMPARE_FIELD(st_atime);
   COMPARE_FIELD(st_mtime);
   COMPARE_FIELD(st_ctime);
   return true;
 }
 
 #undef COMPARE_FIELD
 
+ACTION_P(SetErrno, value) {
+  errno = value;
+}
+
 ACTION_P(SetStat, statbuf) {
   memset(arg1, 0, sizeof(struct stat));
   arg1->st_dev = statbuf->st_dev;
   arg1->st_ino = statbuf->st_ino;
   arg1->st_mode = statbuf->st_mode;
   arg1->st_nlink = statbuf->st_nlink;
   arg1->st_uid = statbuf->st_uid;
   arg1->st_gid = statbuf->st_gid;
   arg1->st_rdev = statbuf->st_rdev;
   arg1->st_size = statbuf->st_size;
@@ skipping 11 matching lines @@
   statbuf->st_uid = 5;
   statbuf->st_gid = 6;
   statbuf->st_rdev = 7;
   statbuf->st_size = 8;
   statbuf->st_atime = 9;
   statbuf->st_mtime = 10;
   statbuf->st_ctime = 11;
 }
 
 const mode_t kDummyMode = 0xbeef;
+const int kDummyErrno = 0xfeeb;
 const int kDummyInt = 0xdedbeef;
 const int kDummyInt2 = 0xcabba6e;
 const int kDummyInt3 = 0xf00ba4;
 const int kDummyInt4 = 0xabacdba;
 const size_t kDummySizeT = 0x60067e;
 const char* kDummyConstChar = "foobar";
 const char* kDummyConstChar2 = "g00gl3";
 const char* kDummyConstChar3 = "fr00gl3";
 const void* kDummyVoidPtr = "blahblah";
 const uid_t kDummyUid = 1001;
 const gid_t kDummyGid = 1002;
 
 class KernelWrapTest : public ::testing::Test {
  public:
   KernelWrapTest() {}
 
   virtual void SetUp() {
+    // Initialize the global errno value to a consistent value rather than
+    // relying on its value from previous test runs.
+    errno = 0;
+
     // Initializing the KernelProxy opens stdin/stdout/stderr.
     EXPECT_CALL(mock, open(_, _))
         .WillOnce(Return(0))
         .WillOnce(Return(1))
         .WillOnce(Return(2));
     // And will call mount / and /dev.
     EXPECT_CALL(mock, mount(_, _, _, _, _))
         .WillOnce(Return(0))
         .WillOnce(Return(0));
 
     ASSERT_EQ(0, ki_push_state_for_testing());
     ASSERT_EQ(0, ki_init(&mock));
   }
 
   void TearDown() {
     // Uninitialize the kernel proxy so wrapped functions passthrough to their
     // unwrapped versions.
     ki_uninit();
   }
 
-
   MockKernelProxy mock;
 };
 
 }  // namespace
 
 TEST_F(KernelWrapTest, access) {
-  EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(-1));
-  EXPECT_EQ(-1, access(kDummyConstChar, kDummyInt));
-
   EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt)) .WillOnce(Return(0));
   EXPECT_EQ(0, access(kDummyConstChar, kDummyInt));
+
+  EXPECT_CALL(mock, access(kDummyConstChar, kDummyInt))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, access(kDummyConstChar, kDummyInt));
+  EXPECT_EQ(kDummyErrno, errno);
+
 }
 
 TEST_F(KernelWrapTest, chdir) {
-  EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(-1));
-  EXPECT_EQ(-1, chdir(kDummyConstChar));
-
   EXPECT_CALL(mock, chdir(kDummyConstChar)).WillOnce(Return(0));
   EXPECT_EQ(0, chdir(kDummyConstChar));
+
+  EXPECT_CALL(mock, chdir(kDummyConstChar))
+    .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, chdir(kDummyConstChar));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, chmod) {
   EXPECT_CALL(mock, chmod(kDummyConstChar, kDummyMode))
       .WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2,chmod(kDummyConstChar, kDummyMode));
 }
 
 TEST_F(KernelWrapTest, chown) {
   EXPECT_CALL(mock, chown(kDummyConstChar, kDummyUid, kDummyGid))
       .WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, chown(kDummyConstChar, kDummyUid, kDummyGid));
 }
 
 TEST_F(KernelWrapTest, close) {
   // The way we wrap close does not support returning arbitrary values, so we
   // test 0 and -1.
   EXPECT_CALL(mock, close(kDummyInt))
-      .WillOnce(Return(0))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0));
 
   EXPECT_EQ(0, close(kDummyInt));
+
+  EXPECT_CALL(mock, close(kDummyInt))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, close(kDummyInt));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, dup) {
   EXPECT_CALL(mock, dup(kDummyInt)).WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, dup(kDummyInt));
 }
 
 TEST_F(KernelWrapTest, dup2) {
   // The way we wrap dup2 does not support returning aribtrary values, only -1
   // or the value of the new fd.
   EXPECT_CALL(mock, dup2(kDummyInt, kDummyInt2))
       .WillOnce(Return(kDummyInt2))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
   EXPECT_EQ(kDummyInt2, dup2(kDummyInt, kDummyInt2));
   EXPECT_EQ(-1, dup2(kDummyInt, kDummyInt2));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, fchdir) {
   EXPECT_CALL(mock, fchdir(kDummyInt))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
   EXPECT_EQ(-1, fchdir(kDummyInt));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, fchmod) {
   EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
+  EXPECT_EQ(0, fchmod(kDummyInt, kDummyMode));
   EXPECT_EQ(-1, fchmod(kDummyInt, kDummyMode));
-
-  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode)) .WillOnce(Return(0));
-  EXPECT_EQ(0, fchmod(kDummyInt, kDummyMode));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, fchown) {
   EXPECT_CALL(mock, fchown(kDummyInt, kDummyUid, kDummyGid))
       .WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, fchown(kDummyInt, kDummyUid, kDummyGid));
 }
 
 TEST_F(KernelWrapTest, fcntl) {
   char buffer[] = "fcntl";
   EXPECT_CALL(mock, fcntl(kDummyInt, kDummyInt2, _))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, fcntl(kDummyInt, kDummyInt2, buffer));
 }
 
 TEST_F(KernelWrapTest, fdatasync) {
-  EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(-1));
+  EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(0))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
+  EXPECT_EQ(0, fdatasync(kDummyInt));
   EXPECT_EQ(-1, fdatasync(kDummyInt));
-
-  EXPECT_CALL(mock, fdatasync(kDummyInt)).WillOnce(Return(0));
-  EXPECT_EQ(0, fdatasync(kDummyInt));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, fstat) {
   // The way we wrap fstat does not support returning aribtrary values, only 0
   // or -1.
   struct stat in_statbuf;
   MakeDummyStatbuf(&in_statbuf);
   EXPECT_CALL(mock, fstat(kDummyInt, _))
       .WillOnce(DoAll(SetStat(&in_statbuf), Return(0)))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   struct stat out_statbuf;
+
   EXPECT_EQ(0, fstat(kDummyInt, &out_statbuf));
   EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
+
   EXPECT_EQ(-1, fstat(kDummyInt, &out_statbuf));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, ftruncate) {
   EXPECT_CALL(mock, ftruncate(kDummyInt, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, ftruncate(kDummyInt, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, fsync) {
-  EXPECT_CALL(mock, fsync(kDummyInt)).WillOnce(Return(-1));
+  EXPECT_CALL(mock, fsync(kDummyInt))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, fsync(kDummyInt));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, getcwd) {
   char result[] = "getcwd_result";
   char buffer[] = "getcwd";
   EXPECT_CALL(mock, getcwd(buffer, kDummySizeT)).WillOnce(Return(result));
   EXPECT_EQ(result, getcwd(buffer, kDummySizeT));
 }
 
 TEST_F(KernelWrapTest, getdents) {
@@ skipping 123 matching lines @@
 TEST_F(KernelWrapTest, munmap) {
   // The way we wrap munmap, calls the "real" mmap as well as the intercepted
   // one. The result returned is from the "real" mmap.
   int dummy1 = 123;
   void* kDummyVoidPtr = &dummy1;
   size_t kDummySizeT = sizeof(kDummyVoidPtr);
   EXPECT_CALL(mock, munmap(kDummyVoidPtr, kDummySizeT));
   munmap(kDummyVoidPtr, kDummySizeT);
 }
 
-
 TEST_F(KernelWrapTest, open) {
   // We pass O_RDONLY because we do not want an error in flags translation
   EXPECT_CALL(mock, open(kDummyConstChar, 0))
+      .WillOnce(Return(kDummyInt2))
       .WillOnce(Return(kDummyInt2));
+
   EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
-
-  EXPECT_CALL(mock, open(kDummyConstChar, 0))
-      .WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
 }
 
 TEST_F(KernelWrapTest, pipe) {
   int fds[] = {1, 2};
   EXPECT_CALL(mock, pipe(fds)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, pipe(fds));
 }
 
 TEST_F(KernelWrapTest, read) {
   int dummy_value;
   void* dummy_void_ptr = &dummy_value;
   EXPECT_CALL(mock, read(kDummyInt, dummy_void_ptr, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, read(kDummyInt, dummy_void_ptr, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, readlink) {
   char buf[10];
 
   EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(kDummyInt))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
+  EXPECT_EQ(kDummyInt, readlink(kDummyConstChar, buf, 10));
   EXPECT_EQ(-1, readlink(kDummyConstChar, buf, 10));
-
-  EXPECT_CALL(mock, readlink(kDummyConstChar, buf, 10))
-      .WillOnce(Return(kDummyInt));
-  EXPECT_EQ(kDummyInt, readlink(kDummyConstChar, buf, 10));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 #ifdef __GLIBC__
 // Under newlib there is no remove syscall.  Instead it is implemented
 // in terms of unlink()/rmdir().
 TEST_F(KernelWrapTest, remove) {
   EXPECT_CALL(mock, remove(kDummyConstChar)).WillOnce(Return(-1));
   EXPECT_EQ(-1, remove(kDummyConstChar));
 }
 #endif
 
 TEST_F(KernelWrapTest, rename) {
   EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2))
-      .WillOnce(Return(-1));
+      .WillOnce(Return(0))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
+  EXPECT_EQ(0, rename(kDummyConstChar, kDummyConstChar2));
   EXPECT_EQ(-1, rename(kDummyConstChar, kDummyConstChar2));
-
-  EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2))
-      .WillOnce(Return(0));
-  EXPECT_EQ(0, rename(kDummyConstChar, kDummyConstChar2));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, rmdir) {
   EXPECT_CALL(mock, rmdir(kDummyConstChar)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, rmdir(kDummyConstChar));
 }
 
 static void new_handler(int) {}
 
 TEST_F(KernelWrapTest, sigaction) {
@@ skipping 17 matching lines @@
   EXPECT_EQ(NULL, signal(kDummyInt, new_handler));
 }
 
 TEST_F(KernelWrapTest, stat) {
   // The way we wrap stat does not support returning aribtrary values, only 0
   // or -1.
   struct stat in_statbuf;
   MakeDummyStatbuf(&in_statbuf);
   EXPECT_CALL(mock, stat(StrEq(kDummyConstChar), _))
       .WillOnce(DoAll(SetStat(&in_statbuf), Return(0)))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   struct stat out_statbuf;
+
   EXPECT_EQ(0, stat(kDummyConstChar, &out_statbuf));
   EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
+
   EXPECT_EQ(-1, stat(kDummyConstChar, &out_statbuf));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, symlink) {
   EXPECT_CALL(mock, symlink(kDummyConstChar, kDummyConstChar2))
       .WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, symlink(kDummyConstChar, kDummyConstChar2));
 }
 
 #ifndef __BIONIC__
 TEST_F(KernelWrapTest, tcflush) {
@@ skipping 15 matching lines @@
   EXPECT_EQ(kDummyInt3, tcsetattr(kDummyInt, kDummyInt2, &term));
 }
 #endif
 
 TEST_F(KernelWrapTest, umount) {
   EXPECT_CALL(mock, umount(kDummyConstChar)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, umount(kDummyConstChar));
 }
 
 TEST_F(KernelWrapTest, truncate) {
-  EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(-1));
+  EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3))
+      .WillOnce(Return(0))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+
+  EXPECT_EQ(0, truncate(kDummyConstChar, kDummyInt3));
+
   EXPECT_EQ(-1, truncate(kDummyConstChar, kDummyInt3));
-
-  EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(0));
-  EXPECT_EQ(0, truncate(kDummyConstChar, kDummyInt3));
 }
 
 TEST_F(KernelWrapTest, lstat) {
   struct stat in_statbuf;
   MakeDummyStatbuf(&in_statbuf);
   EXPECT_CALL(mock, lstat(StrEq(kDummyConstChar), _))
       .WillOnce(DoAll(SetStat(&in_statbuf), Return(0)))
-      .WillOnce(Return(-1));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   struct stat out_statbuf;
+
   EXPECT_EQ(0, lstat(kDummyConstChar, &out_statbuf));
   EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
+
   EXPECT_EQ(-1, lstat(kDummyConstChar, &out_statbuf));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, unlink) {
   EXPECT_CALL(mock, unlink(kDummyConstChar)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, unlink(kDummyConstChar));
 }
 
 TEST_F(KernelWrapTest, utime) {
   const struct utimbuf* times = NULL;
   EXPECT_CALL(mock, utime(kDummyConstChar, times)).WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, utime(kDummyConstChar, times));
 }
 
 TEST_F(KernelWrapTest, utimes) {
   struct timeval* times = NULL;
-  EXPECT_CALL(mock, utimes(kDummyConstChar, times)).WillOnce(Return(-1));
+  EXPECT_CALL(mock, utimes(kDummyConstChar, times))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(-1, utimes(kDummyConstChar, times));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, write) {
   EXPECT_CALL(mock, write(kDummyInt, kDummyVoidPtr, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, write(kDummyInt, kDummyVoidPtr, kDummyInt2));
 }
 
 #if defined(PROVIDES_SOCKET_API) and !defined(__BIONIC__)
 TEST_F(KernelWrapTest, poll) {
@@ skipping 169 matching lines @@
   int dummy_val;
   EXPECT_CALL(mock, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val))
       .WillOnce(Return(kDummyInt4));
   EXPECT_EQ(kDummyInt4,
             socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 #endif  // __linux__