[NaCl SDK] Remove syscalls wrappers for chmod and unlink.

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 170 matching lines @@
   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));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, chmod(kDummyConstChar, kDummyMode));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 TEST_F(KernelWrapTest, chown) {
   EXPECT_CALL(mock, chown(kDummyConstChar, kDummyUid, kDummyGid))
-      .WillOnce(Return(kDummyInt));
-  EXPECT_EQ(kDummyInt, chown(kDummyConstChar, kDummyUid, kDummyGid));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, chown(kDummyConstChar, kDummyUid, kDummyGid));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 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));
 
   EXPECT_EQ(0, close(kDummyInt));
 
@@ skipping 156 matching lines @@
 }
 
 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));
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, link(kDummyConstChar, kDummyConstChar2));
+  ASSERT_EQ(kDummyErrno, errno);
 }
 
 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)
@@ skipping 236 matching lines @@
   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 SEL_LDR
+class KernelWrapTestUninit : public ::testing::Test {
+  void SetUp() {
+    ASSERT_EQ(0, ki_push_state_for_testing());
+  }
+
+  void TearDown() {
+    ki_pop_state_for_testing();
+  }
+};
+
+TEST_F(KernelWrapTestUninit, Mkdir_Uninitialised) {
+  // If we are running within chrome we can't use these calls without
+  // nacl_io initialized.
+  EXPECT_EQ(0, mkdir("./foo", S_IREAD | S_IWRITE));
+  EXPECT_EQ(0, rmdir("./foo"));
+}
+
+TEST_F(KernelWrapTestUninit, Getcwd_Uninitialised) {
+  // If we are running within chrome we can't use these calls without
+  // nacl_io initialized.
+  char dir[PATH_MAX];
+  ASSERT_NE((char*)NULL, getcwd(dir, 1024));

[binji, 2014/08/20 18:13:35]

PATH_MAX?

[Sam Clegg, 2014/08/21 10:19:34]

Done.

+  // Verify that the CWD ends with 'nacl_io_test'
+  const char* suffix = "nacl_io_test";

[binji, 2014/08/20 18:13:35]

hm, seems like a fragile test. There's no reason we couldn't run this test from
another directory.

[Sam Clegg, 2014/08/21 10:19:34]

Got any better ideas?  My goal here is to check that the real getcwd is being
used ..  Maybe I should just skip this test.  Its testing something that will
most likely cause gtest itself to crash on startup if it fails anyway.

+  ASSERT_GT(strlen(dir), strlen(suffix));
+  ASSERT_EQ(0, strcmp(dir+strlen(dir)-strlen(suffix), suffix));
+}
+#endif
+
 #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;
@@ skipping 212 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__