[NaCl SDK] Compile for naclio for Bionic

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 73 matching lines @@
   statbuf->st_nlink = 4;
   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 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;
@@ skipping 40 matching lines @@
 
 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));
 }
 
 TEST_F(KernelWrapTest, chmod) {
-  EXPECT_CALL(mock, chmod(kDummyConstChar, kDummyInt))
+  EXPECT_CALL(mock, chmod(kDummyConstChar, kDummyMode))
       .WillOnce(Return(kDummyInt2));
-  EXPECT_EQ(kDummyInt2, chmod(kDummyConstChar, kDummyInt));
+  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
@@ skipping 21 matching lines @@
   EXPECT_EQ(-1, dup2(kDummyInt, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, fchdir) {
   EXPECT_CALL(mock, fchdir(kDummyInt))
       .WillOnce(Return(-1));
   EXPECT_EQ(-1, fchdir(kDummyInt));
 }
 
 TEST_F(KernelWrapTest, fchmod) {
-  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyInt2)) .WillOnce(Return(-1));
-  EXPECT_EQ(-1, fchmod(kDummyInt, kDummyInt2));
+  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode))
+      .WillOnce(Return(-1));
+  EXPECT_EQ(-1, fchmod(kDummyInt, kDummyMode));
 
-  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyInt2)) .WillOnce(Return(0));
-  EXPECT_EQ(0, fchmod(kDummyInt, kDummyInt2));
+  EXPECT_CALL(mock, fchmod(kDummyInt, kDummyMode)) .WillOnce(Return(0));
+  EXPECT_EQ(0, fchmod(kDummyInt, kDummyMode));
 }
 
 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";
@@ skipping 36 matching lines @@
 }
 
 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) {
-#ifndef __GLIBC__
+#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;
   EXPECT_CALL(mock, getdents(kDummyInt, void_ptr, kDummyInt2))
       .WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, getdents(kDummyInt, void_ptr, kDummyInt2));
 #endif
@@ skipping 13 matching lines @@
 #pragma GCC diagnostic warning "-Wdeprecated-declarations"
 #endif
 
 TEST_F(KernelWrapTest, ioctl) {
   char buffer[] = "ioctl";
   EXPECT_CALL(mock, ioctl(kDummyInt, kDummyInt2, _))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, ioctl(kDummyInt, kDummyInt2, buffer));
 }
 
+#if !defined(__BIONIC__)
 TEST_F(KernelWrapTest, isatty) {
   EXPECT_CALL(mock, isatty(kDummyInt)).WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, isatty(kDummyInt));
 }
+#endif
 
 TEST_F(KernelWrapTest, kill) {
   EXPECT_CALL(mock, kill(kDummyInt, kDummyInt2)).WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, kill(kDummyInt, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, lchown) {
   EXPECT_CALL(mock, lchown(kDummyConstChar, kDummyUid, kDummyGid))
       .WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, lchown(kDummyConstChar, kDummyUid, kDummyGid));
 }
 
 TEST_F(KernelWrapTest, link) {
   EXPECT_CALL(mock, link(kDummyConstChar, kDummyConstChar2))
       .WillOnce(Return(kDummyInt));
   EXPECT_EQ(kDummyInt, link(kDummyConstChar, kDummyConstChar2));
 }
 
 TEST_F(KernelWrapTest, lseek) {
   EXPECT_CALL(mock, lseek(kDummyInt, kDummyInt2, kDummyInt3))
       .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, kDummyInt))
+  EXPECT_CALL(mock, mkdir(kDummyConstChar, kDummyMode))
       .WillOnce(Return(kDummyInt2));
-  EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar, kDummyInt));
+  EXPECT_EQ(kDummyInt2, mkdir(kDummyConstChar, kDummyMode));
 #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 35 matching lines @@
   // 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) {
-  EXPECT_CALL(mock, open(kDummyConstChar, kDummyInt))
+  // We pass O_RDONLY because we do not want an error in flags translation
+  EXPECT_CALL(mock, open(kDummyConstChar, 0))
       .WillOnce(Return(kDummyInt2));
-  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, kDummyInt));
+  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, 0));
 
-  EXPECT_CALL(mock, open(kDummyConstChar, kDummyInt))
+  EXPECT_CALL(mock, open(kDummyConstChar, 0))
       .WillOnce(Return(kDummyInt2));
-  EXPECT_EQ(kDummyInt2, open(kDummyConstChar, kDummyInt));
+  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;
@@ skipping 75 matching lines @@
   EXPECT_THAT(&in_statbuf, IsEqualToStatbuf(&out_statbuf));
   EXPECT_EQ(-1, stat(kDummyConstChar, &out_statbuf));
 }
 
 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) {
   EXPECT_CALL(mock, tcflush(kDummyInt, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, tcflush(kDummyInt, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, tcgetattr) {
   struct termios term;
   EXPECT_CALL(mock, tcgetattr(kDummyInt, &term)).WillOnce(Return(kDummyInt2));
   EXPECT_EQ(kDummyInt2, tcgetattr(kDummyInt, &term));
 }
 
 TEST_F(KernelWrapTest, tcsetattr) {
   struct termios term;
   EXPECT_CALL(mock, tcsetattr(kDummyInt, kDummyInt2, &term))
       .WillOnce(Return(kDummyInt3));
   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_EQ(-1, truncate(kDummyConstChar, kDummyInt3));
 
   EXPECT_CALL(mock, truncate(kDummyConstChar, kDummyInt3)).WillOnce(Return(0));
   EXPECT_EQ(0, truncate(kDummyConstChar, kDummyInt3));
 }
 
+#ifndef __BIONIC__
 TEST_F(KernelWrapTest, lstat) {
   struct stat buf;
   EXPECT_CALL(mock, lstat(kDummyConstChar, &buf)).WillOnce(Return(-1));
   EXPECT_EQ(-1, lstat(kDummyConstChar, &buf));
 
   EXPECT_CALL(mock, lstat(kDummyConstChar, &buf)).WillOnce(Return(0));
   EXPECT_EQ(0, lstat(kDummyConstChar, &buf));
 }
+#endif
 
 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_EQ(-1, utimes(kDummyConstChar, times));
 }
 
 TEST_F(KernelWrapTest, write) {
   EXPECT_CALL(mock, write(kDummyInt, kDummyVoidPtr, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, write(kDummyInt, kDummyVoidPtr, kDummyInt2));
 }
 
-#ifdef PROVIDES_SOCKET_API
+#if defined(PROVIDES_SOCKET_API) and !defined(__BIONIC__)
 TEST_F(KernelWrapTest, poll) {
   struct pollfd fds;
   EXPECT_CALL(mock, poll(&fds, kDummyInt, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, poll(&fds, kDummyInt, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, select) {
   fd_set readfds;
   fd_set writefds;
@@ skipping 82 matching lines @@
   socklen_t len;
   EXPECT_CALL(
       mock,
       recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len))
       .WillOnce(Return(kDummyInt4));
   EXPECT_EQ(
       kDummyInt4,
       recvfrom(kDummyInt, dummy_void_ptr, kDummyInt2, kDummyInt3, &addr, &len));
 }
 
+#ifndef __BIONIC__
 TEST_F(KernelWrapTest, recvmsg) {
   struct msghdr msg;
   EXPECT_CALL(mock, recvmsg(kDummyInt, &msg, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3, recvmsg(kDummyInt, &msg, kDummyInt2));
 }
+#endif
 
 TEST_F(KernelWrapTest, send) {
   EXPECT_CALL(mock, send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2))
       .WillOnce(Return(kDummyInt3));
   EXPECT_EQ(kDummyInt3,
             send(kDummyInt, kDummyVoidPtr, kDummySizeT, kDummyInt2));
 }
 
 TEST_F(KernelWrapTest, sendto) {
   const socklen_t kDummySockLen = 0x50cc5;
@@ skipping 50 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__