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

native_client_sdk/src/tests/nacl_io_test/fuse_fs_test.cc

 // Copyright 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.
 
 #include <fcntl.h>
 
 #include <gtest/gtest.h>
 
 #include <string>
 #include <vector>
 
 #include "nacl_io/fuse.h"
 #include "nacl_io/fusefs/fuse_fs.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/kernel_intercept.h"
 #include "nacl_io/kernel_proxy.h"
+#include "nacl_io/ostime.h"
 
 using namespace nacl_io;
 
 namespace {
 
 class FuseFsForTesting : public FuseFs {
  public:
   explicit FuseFsForTesting(fuse_operations* fuse_ops) {
     FsInitArgs args;
     args.fuse_ops = fuse_ops;
     EXPECT_EQ(0, Init(args));
   }
 };
 
 // Implementation of a simple flat memory filesystem.
 struct File {
+  File() {
+    memset(&times, 0, sizeof(times));
+  }
+
   std::string name;
   std::vector<uint8_t> data;
+  timespec times[2];
 };
 
 typedef std::vector<File> Files;
 Files g_files;
 mode_t last_create_mode = 0666;
 
 bool IsValidPath(const char* path) {
   if (path == NULL)
     return false;
 
@@ skipping 25 matching lines @@
     stbuf->st_mode = S_IFDIR | 0755;
     return 0;
   }
 
   File* file = FindFile(path);
   if (file == NULL)
     return -ENOENT;
 
   stbuf->st_mode = S_IFREG | last_create_mode;
   stbuf->st_size = file->data.size();
+  stbuf->st_atime = file->times[0].tv_sec;
+  stbuf->st_atimensec = file->times[0].tv_nsec;
+  stbuf->st_mtime = file->times[1].tv_sec;
+  stbuf->st_mtimensec = file->times[1].tv_nsec;
   return 0;
 }
 
 int testfs_readdir(const char* path,
                    void* buf,
                    fuse_fill_dir_t filler,
                    off_t offset,
                    struct fuse_file_info*) {
   if (strcmp(path, "/") != 0)
     return -ENOENT;
@@ skipping 63 matching lines @@
 
   size_t filesize = file->data.size();
 
   if (offset + size > filesize)
     file->data.resize(offset + size);
 
   memcpy(file->data.data() + offset, buf, size);
   return size;
 }
 
+int testfs_utimens(const char* path, const struct timespec times[2]) {
+  File* file = FindFile(path);
+  if (file == NULL)
+    return -ENOENT;
+
+  file->times[0] = times[0];
+  file->times[1] = times[1];
+  return 0;
+}
+
 const char hello_world[] = "Hello, World!\n";
 
 fuse_operations g_fuse_operations = {
-  0,  // flag_nopath
-  0,  // flag_reserved
-  NULL,  // init
-  NULL,  // destroy
-  NULL,  // access
-  testfs_create,  // create
-  NULL,  // fgetattr
-  NULL,  // fsync
-  NULL,  // ftruncate
-  testfs_getattr,  // getattr
-  NULL,  // mkdir
-  NULL,  // mknod
-  testfs_open,  // open
-  NULL,  // opendir
-  testfs_read,  // read
-  testfs_readdir,  // readdir
-  NULL,  // release
-  NULL,  // releasedir
-  NULL,  // rename
-  NULL,  // rmdir
-  NULL,  // truncate
-  NULL,  // unlink
-  testfs_write,  // write
+    0,               // flag_nopath
+    0,               // flag_reserved
+    NULL,            // init
+    NULL,            // destroy
+    NULL,            // access
+    testfs_create,   // create
+    NULL,            // fgetattr
+    NULL,            // fsync
+    NULL,            // ftruncate
+    testfs_getattr,  // getattr
+    NULL,            // mkdir
+    NULL,            // mknod
+    testfs_open,     // open
+    NULL,            // opendir
+    testfs_read,     // read
+    testfs_readdir,  // readdir
+    NULL,            // release
+    NULL,            // releasedir
+    NULL,            // rename
+    NULL,            // rmdir
+    NULL,            // truncate
+    NULL,            // unlink
+    testfs_write,    // write
+    testfs_utimens,  // utimens
 };
 
 class FuseFsTest : public ::testing::Test {
  public:
   FuseFsTest();
 
   void SetUp();
 
  protected:
   FuseFsForTesting fs_;
@@ skipping 114 matching lines @@
   ScopedNode node;
   ASSERT_EQ(0, fs_.Open(Path("/foobar"), O_RDWR | O_CREAT, &node));
   ASSERT_EQ(0, root->GetDents(0, &entries[0], sizeof(entries), &bytes_read));
   ASSERT_EQ(4 * sizeof(dirent), bytes_read);
   EXPECT_STREQ(".", entries[0].d_name);
   EXPECT_STREQ("..", entries[1].d_name);
   EXPECT_STREQ("hello", entries[2].d_name);
   EXPECT_STREQ("foobar", entries[3].d_name);
 }
 
+TEST_F(FuseFsTest, Utimens) {
+  struct stat statbuf;
+  ScopedNode node;
+
+  struct timespec times[2];
+  times[0].tv_sec = 1000;
+  times[0].tv_nsec = 2000;
+  times[1].tv_sec = 3000;
+  times[1].tv_nsec = 4000;
+
+  ASSERT_EQ(0, fs_.Open(Path("/hello"), O_RDONLY, &node));
+  EXPECT_EQ(0, node->Futimens(times));
+
+  EXPECT_EQ(0, node->GetStat(&statbuf));
+  EXPECT_EQ(times[0].tv_sec, statbuf.st_atime);
+  EXPECT_EQ(times[0].tv_nsec, statbuf.st_atimensec);
+  EXPECT_EQ(times[1].tv_sec, statbuf.st_mtime);
+  EXPECT_EQ(times[1].tv_nsec, statbuf.st_mtimensec);
+}
+
 namespace {
 
 class KernelProxyFuseTest : public ::testing::Test {
  public:
   KernelProxyFuseTest() {}
 
   void SetUp();
   void TearDown();
 
  private:
@@ skipping 30 matching lines @@
   // Then read it back in.
   fd = ki_open("/hello", O_RDONLY, 0);
   ASSERT_GT(fd, -1);
 
   char buffer[30];
   memset(buffer, 0, sizeof(buffer));
   ASSERT_EQ(sizeof(hello_world), ki_read(fd, buffer, sizeof(buffer)));
   EXPECT_STREQ(hello_world, buffer);
   EXPECT_EQ(0, ki_close(fd));
 }