[NaCl SDK] nacl_io: Plumb through {,f}utime{,s}

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>
 
 #include <string>
 #include <vector>
 
 #include "gtest/gtest.h"
 #include "mock_kernel_proxy.h"
 #include "nacl_io/kernel_intercept.h"
 #include "nacl_io/kernel_wrap.h"
 #include "nacl_io/kernel_wrap_real.h"
 #include "nacl_io/osmman.h"
 #include "nacl_io/ossocket.h"
 #include "nacl_io/ostermios.h"
+#include "nacl_io/ostime.h"
 #include "ppapi_simple/ps.h"
 
 #if defined(__native_client__) && !defined(__GLIBC__)
 extern "C" {
-// TODO(sbc): remove once these get added to the newlib toolchain headers.
+// TODO(sbc): remove once this gets added to the newlib toolchain headers.
 int fchdir(int fd);
-int utimes(const char *filename, const struct timeval times[2]);
 }
 #endif
 
 using namespace nacl_io;
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrEq;
 
 namespace {
 
-#define COMPARE_FIELD(f)                                                     \
-  if (arg->f != statbuf->f) {                                                \
-    *result_listener << "mismatch of field \"" #f                            \
-                        "\". "                                               \
-                        "expected: " << statbuf->f << " actual: " << arg->f; \
-    return false;                                                            \
+#define COMPARE_FIELD(actual, expected, f)                                 \
+  if (actual != expected) {                                                \
+    *result_listener << "mismatch of field \"" f                           \
+                        "\". "                                             \
+                        "expected: " << expected << " actual: " << actual; \
+    return false;                                                          \
   }
 
-MATCHER_P(IsEqualToStatbuf, statbuf, "") {
-  COMPARE_FIELD(st_dev);
-  COMPARE_FIELD(st_ino);
-  COMPARE_FIELD(st_mode);
-  COMPARE_FIELD(st_nlink);
-  COMPARE_FIELD(st_uid);
-  COMPARE_FIELD(st_gid);
-  COMPARE_FIELD(st_rdev);
-  COMPARE_FIELD(st_size);
-  COMPARE_FIELD(st_atime);
-  COMPARE_FIELD(st_mtime);
-  COMPARE_FIELD(st_ctime);
+#define COMPARE_FIELD_SIMPLE(f) COMPARE_FIELD(arg->f, other->f, #f)
+
+MATCHER_P(IsEqualToStatbuf, other, "") {
+  COMPARE_FIELD_SIMPLE(st_dev);
+  COMPARE_FIELD_SIMPLE(st_ino);
+  COMPARE_FIELD_SIMPLE(st_mode);
+  COMPARE_FIELD_SIMPLE(st_nlink);
+  COMPARE_FIELD_SIMPLE(st_uid);
+  COMPARE_FIELD_SIMPLE(st_gid);
+  COMPARE_FIELD_SIMPLE(st_rdev);
+  COMPARE_FIELD_SIMPLE(st_size);
+  COMPARE_FIELD_SIMPLE(st_atime);
+  COMPARE_FIELD_SIMPLE(st_mtime);
+  COMPARE_FIELD_SIMPLE(st_ctime);
+  return true;
+}
+
+MATCHER_P(IsEqualToUtimbuf, other, "") {
+  COMPARE_FIELD(arg[0].tv_sec, other->actime, "actime");
+  COMPARE_FIELD(arg[1].tv_sec, other->modtime, "modtime");
+  return true;
+}
+
+MATCHER_P(IsEqualToTimeval, other, "") {
+  COMPARE_FIELD(arg[0].tv_sec, other[0].tv_sec, "[0].tv_sec");
+  COMPARE_FIELD(arg[0].tv_nsec, other[0].tv_usec * 1000, "[0].tv_usec");
+  COMPARE_FIELD(arg[1].tv_sec, other[1].tv_sec, "[1].tv_sec");
+  COMPARE_FIELD(arg[1].tv_nsec, other[1].tv_usec * 1000, "[1].tv_usec");
   return true;
 }
 
 #undef COMPARE_FIELD
+#undef COMPARE_FIELD_SIMPLE
+
 
 ACTION_P(SetErrno, value) {
   errno = value;
 }
 
 ACTION_P2(SetString, target, source) {
   strcpy(target, source);
 }
 
 ACTION_P(SetStat, statbuf) {
@@ skipping 218 matching lines @@
   EXPECT_EQ(kDummyInt3, ftruncate(kDummyInt, kDummyInt2));
 }
 
 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, futimes) {
+  struct timeval times[2] = {{123, 234}, {345, 456}};
+  EXPECT_CALL(mock, futimens(kDummyInt, IsEqualToTimeval(times)))
+      .WillOnce(DoAll(SetErrno(kDummyErrno), Return(-1)));
+  EXPECT_EQ(-1, futimes(kDummyInt, times));
+  ASSERT_EQ(kDummyErrno, errno);
+}
+
 TEST_F(KernelWrapTest, getcwd) {
   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));
 }
 
@@ skipping 293 matching lines @@
 }
 
 TEST_F(KernelWrapTest, unlink) {
   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));
+  const struct utimbuf times = {123, 456};
+  EXPECT_CALL(mock, utimens(kDummyConstChar, IsEqualToUtimbuf(&times)))
+      .WillOnce(Return(kDummyInt));
+  EXPECT_EQ(kDummyInt, utime(kDummyConstChar, &times));
 }
 
 TEST_F(KernelWrapTest, utimes) {
-  struct timeval* times = NULL;
-  EXPECT_CALL(mock, utimes(kDummyConstChar, times))
+  struct timeval times[2] = {{123, 234}, {345, 456}};
+  EXPECT_CALL(mock, utimens(kDummyConstChar, IsEqualToTimeval(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));
 }
@@ skipping 257 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__