[NaCl SDK] nacl_io: Remove unneeded glibc syscall entry points.

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 50 matching lines @@
   COMPARE_FIELD(st_ctime);
   return true;
 }
 
 #undef COMPARE_FIELD
 
 ACTION_P(SetErrno, value) {
   errno = value;
 }
 
+ACTION_P2(SetString, target, source) {
+  strcpy(target, source);
+}
+
 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 208 matching lines @@
 }
 
 TEST_F(KernelWrapTest, fsync) {
   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));
+  char buffer[PATH_MAX];
+  char result[PATH_MAX];
+  memset(buffer, 0, PATH_MAX);
+  strcpy(result, "getcwd_result");
+  EXPECT_CALL(mock, getcwd(buffer, kDummySizeT))
+       .WillOnce(DoAll(SetString(buffer, result), Return(buffer)));
+  EXPECT_STREQ(result, getcwd(buffer, kDummySizeT));
 }
 
 TEST_F(KernelWrapTest, getdents) {
 #if !defined( __GLIBC__) && !defined(__BIONIC__)
   // TODO(sbc): Find a way to test the getdents wrapper under glibc.
   // It looks like the only way to exercise it is to call readdir(2).
   // There is an internal glibc function __getdents that will call the
   // IRT but that cannot be accessed from here as glibc does not export it.
   int dummy_val;
   void* void_ptr = &dummy_val;
@@ skipping 61 matching lines @@
       .WillOnce(Return(kDummyInt4));
   EXPECT_EQ(kDummyInt4, lseek(kDummyInt, kDummyInt2, kDummyInt3));
 }
 
 TEST_F(KernelWrapTest, mkdir) {
 #if defined(WIN32)
   EXPECT_CALL(mock, mkdir(kDummyConstChar, 0777)).WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar));
 #else
   EXPECT_CALL(mock, mkdir(kDummyConstChar, kDummyMode))
-      .WillOnce(Return(kDummyInt2));
-  EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar, kDummyMode));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, mkdir(kDummyConstChar, kDummyMode));
+  ASSERT_EQ(kDummyErrno, errno);
 #endif
 }
 
 TEST_F(KernelWrapTest, mmap) {
   // We only wrap mmap if |flags| has the MAP_ANONYMOUS bit unset.
   int flags = kDummyInt2 & ~MAP_ANONYMOUS;
 
   const size_t kDummySizeT2 = 0xbadf00d;
   int dummy1 = 123;
   int dummy2 = 456;
@@ skipping 89 matching lines @@
   EXPECT_CALL(mock, rename(kDummyConstChar, kDummyConstChar2))
       .WillOnce(Return(0))
       .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
 
   EXPECT_EQ(0, rename(kDummyConstChar, kDummyConstChar2));
   EXPECT_EQ(-1, rename(kDummyConstChar, kDummyConstChar2));
   ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, rmdir) {
-  EXPECT_CALL(mock, rmdir(kDummyConstChar)).WillOnce(Return(kDummyInt));
-  EXPECT_EQ(kDummyInt, rmdir(kDummyConstChar));
+  EXPECT_CALL(mock, rmdir(kDummyConstChar))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, rmdir(kDummyConstChar));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 static void new_handler(int) {}
 
 TEST_F(KernelWrapTest, sigaction) {
   struct sigaction action;
   struct sigaction oaction;
   EXPECT_CALL(mock, sigaction(kDummyInt, &action, &oaction))
       .WillOnce(Return(0));
   EXPECT_EQ(0, sigaction(kDummyInt, &action, &oaction));
@@ skipping 80 matching lines @@
   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));
+  EXPECT_CALL(mock, unlink(kDummyConstChar))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, unlink(kDummyConstChar));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 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;
@@ skipping 234 matching lines @@
       .WillOnce(Return(0))
       .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
   EXPECT_EQ(0, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
   EXPECT_EQ(-1, socketpair(kDummyInt, kDummyInt2, kDummyInt3, &dummy_val));
   EXPECT_EQ(kDummyErrno, errno);
 }
 
 #endif  // PROVIDES_SOCKET_API
 
 #endif  // __linux__