/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

#include "uv.h"

#include "task.h"

#include <errno.h>

#include <string.h> /* memset */

#include <fcntl.h>

#include <sys/stat.h>

/* FIXME we shouldn't need to branch in this file */

#if defined(__unix__) || defined(__POSIX__) || \

    defined(__APPLE__) || defined(_AIX) || defined(__MVS__)

#include <unistd.h> /* unlink, rmdir, etc. */

#else

# include <winioctl.h>

# include <direct.h>

# include <io.h>

# ifndef ERROR_SYMLINK_NOT_SUPPORTED

#  define ERROR_SYMLINK_NOT_SUPPORTED 1464

# endif

# define unlink _unlink

# define rmdir _rmdir

# define open _open

# define write _write

# define close _close

# ifndef stat

#  define stat _stati64

# endif

# ifndef lseek

#   define lseek _lseek

# endif

#endif

#define TOO_LONG_NAME_LENGTH 65536

#define PATHMAX 1024

typedef struct {

  const char* path;

  double atime;

  double mtime;

} utime_check_t;

static int dummy_cb_count;

static int close_cb_count;

static int create_cb_count;

static int open_cb_count;

static int read_cb_count;

static int write_cb_count;

static int unlink_cb_count;

static int mkdir_cb_count;

static int mkdtemp_cb_count;

static int rmdir_cb_count;

static int scandir_cb_count;

static int stat_cb_count;

static int rename_cb_count;

static int fsync_cb_count;

static int fdatasync_cb_count;

static int ftruncate_cb_count;

static int sendfile_cb_count;

static int fstat_cb_count;

static int access_cb_count;

static int chmod_cb_count;

static int fchmod_cb_count;

static int chown_cb_count;

static int fchown_cb_count;

static int lchown_cb_count;

static int link_cb_count;

static int symlink_cb_count;

static int readlink_cb_count;

static int realpath_cb_count;

static int utime_cb_count;

static int futime_cb_count;

static uv_loop_t* loop;

static uv_fs_t open_req1;

static uv_fs_t open_req2;

static uv_fs_t read_req;

static uv_fs_t write_req;

static uv_fs_t unlink_req;

static uv_fs_t close_req;

static uv_fs_t mkdir_req;

static uv_fs_t mkdtemp_req1;

static uv_fs_t mkdtemp_req2;

static uv_fs_t rmdir_req;

static uv_fs_t scandir_req;

static uv_fs_t stat_req;

static uv_fs_t rename_req;

static uv_fs_t fsync_req;

static uv_fs_t fdatasync_req;

static uv_fs_t ftruncate_req;

static uv_fs_t sendfile_req;

static uv_fs_t utime_req;

static uv_fs_t futime_req;

static char buf[32];

static char buf2[32];

static char test_buf[] = "test-buffer\n";

static char test_buf2[] = "second-buffer\n";

static uv_buf_t iov;

#ifdef _WIN32

/*

 * This tag and guid have no special meaning, and don't conflict with

 * reserved ids.

*/

static unsigned REPARSE_TAG = 0x9913;

static GUID REPARSE_GUID = {

  0x1bf6205f, 0x46ae, 0x4527,

  0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 };

#endif

static void check_permission(const char* filename, unsigned int mode) {

  int r;

  uv_fs_t req;

  uv_stat_t* s;

  r = uv_fs_stat(NULL, &req, filename, NULL);

  ASSERT(r == 0);

  ASSERT(req.result == 0);

  s = &req.statbuf;

#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)

  /*

   * On Windows, chmod can only modify S_IWUSR (_S_IWRITE) bit,

   * so only testing for the specified flags.

   */

  ASSERT((s->st_mode & 0777) & mode);

#else

  ASSERT((s->st_mode & 0777) == mode);

#endif

  uv_fs_req_cleanup(&req;;

}

static void dummy_cb(uv_fs_t* req) {

  (void) req;

  dummy_cb_count++;

}

static void link_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_LINK);

  ASSERT(req->result == 0);

  link_cb_count++;

  uv_fs_req_cleanup(req);

}

static void symlink_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_SYMLINK);

  ASSERT(req->result == 0);

  symlink_cb_count++;

  uv_fs_req_cleanup(req);

}

static void readlink_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_READLINK);

  ASSERT(req->result == 0);

  ASSERT(strcmp(req->ptr, "test_file_symlink2") == 0);

  readlink_cb_count++;

  uv_fs_req_cleanup(req);

}

static void realpath_cb(uv_fs_t* req) {

  char test_file_abs_buf[PATHMAX];

  size_t test_file_abs_size = sizeof(test_file_abs_buf);

  ASSERT(req->fs_type == UV_FS_REALPATH);

#ifdef _WIN32

  /*

   * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW()

   */

  if (req->result == UV_ENOSYS) {

    realpath_cb_count++;

    uv_fs_req_cleanup(req);

    return;

  }

#endif

  ASSERT(req->result == 0);

  uv_cwd(test_file_abs_buf, &test_file_abs_size);

#ifdef _WIN32

  strcat(test_file_abs_buf, "\\test_file");

  ASSERT(stricmp(req->ptr, test_file_abs_buf) == 0);

#else

  strcat(test_file_abs_buf, "/test_file");

  ASSERT(strcmp(req->ptr, test_file_abs_buf) == 0);

#endif

  realpath_cb_count++;

  uv_fs_req_cleanup(req);

}

static void access_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_ACCESS);

  access_cb_count++;

  uv_fs_req_cleanup(req);

}

static void fchmod_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_FCHMOD);

  ASSERT(req->result == 0);

  fchmod_cb_count++;

  uv_fs_req_cleanup(req);

  check_permission("test_file", *(int*)req->data);

}

static void chmod_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_CHMOD);

  ASSERT(req->result == 0);

  chmod_cb_count++;

  uv_fs_req_cleanup(req);

  check_permission("test_file", *(int*)req->data);

}

static void fchown_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_FCHOWN);

  ASSERT(req->result == 0);

  fchown_cb_count++;

  uv_fs_req_cleanup(req);

}

static void chown_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_CHOWN);

  ASSERT(req->result == 0);

  chown_cb_count++;

  uv_fs_req_cleanup(req);

}

static void lchown_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_LCHOWN);

  ASSERT(req->result == 0);

  lchown_cb_count++;

  uv_fs_req_cleanup(req);

}

static void chown_root_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_CHOWN);

#if defined(_WIN32) || defined(__MSYS__)

  /* On windows, chown is a no-op and always succeeds. */

  ASSERT(req->result == 0);

#else

  /* On unix, chown'ing the root directory is not allowed -

   * unless you're root, of course.

   */

  if (geteuid() == 0)

    ASSERT(req->result == 0);

  else

#   if defined(__CYGWIN__)

    /* On Cygwin, uid 0 is invalid (no root). */

    ASSERT(req->result == UV_EINVAL);

#   else

    ASSERT(req->result == UV_EPERM);

#   endif

#endif

  chown_cb_count++;

  uv_fs_req_cleanup(req);

}

static void unlink_cb(uv_fs_t* req) {

  ASSERT(req == &unlink_req);

  ASSERT(req->fs_type == UV_FS_UNLINK);

  ASSERT(req->result == 0);

  unlink_cb_count++;

  uv_fs_req_cleanup(req);

}

static void fstat_cb(uv_fs_t* req) {

  uv_stat_t* s = req->ptr;

  ASSERT(req->fs_type == UV_FS_FSTAT);

  ASSERT(req->result == 0);

  ASSERT(s->st_size == sizeof(test_buf));

  uv_fs_req_cleanup(req);

  fstat_cb_count++;

}

static void close_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &close_req);

  ASSERT(req->fs_type == UV_FS_CLOSE);

  ASSERT(req->result == 0);

  close_cb_count++;

  uv_fs_req_cleanup(req);

  if (close_cb_count == 3) {

    r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);

    ASSERT(r == 0);

  }

}

static void ftruncate_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &ftruncate_req);

  ASSERT(req->fs_type == UV_FS_FTRUNCATE);

  ASSERT(req->result == 0);

  ftruncate_cb_count++;

  uv_fs_req_cleanup(req);

  r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

  ASSERT(r == 0);

}

static void fail_cb(uv_fs_t* req) {

  FATAL("fail_cb should not have been called");

}

static void read_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &read_req);

  ASSERT(req->fs_type == UV_FS_READ);

  ASSERT(req->result >= 0);  /* FIXME(bnoordhuis) Check if requested size? */

  read_cb_count++;

  uv_fs_req_cleanup(req);

  if (read_cb_count == 1) {

    ASSERT(strcmp(buf, test_buf) == 0);

    r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7,

        ftruncate_cb);

  } else {

    ASSERT(strcmp(buf, "test-bu") == 0);

    r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

  }

  ASSERT(r == 0);

}

static void open_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &open_req1);

  ASSERT(req->fs_type == UV_FS_OPEN);

  if (req->result < 0) {

    fprintf(stderr, "async open error: %d\n", (int) req->result);

    ASSERT(0);

  }

  open_cb_count++;

  ASSERT(req->path);

  ASSERT(memcmp(req->path, "test_file2\0", 11) == 0);

  uv_fs_req_cleanup(req);

  memset(buf, 0, sizeof(buf));

  iov = uv_buf_init(buf, sizeof(buf));

  r = uv_fs_read(loop, &read_req, open_req1.result, &iov, 1, -1,

      read_cb);

  ASSERT(r == 0);

}

static void open_cb_simple(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_OPEN);

  if (req->result < 0) {

    fprintf(stderr, "async open error: %d\n", (int) req->result);

    ASSERT(0);

  }

  open_cb_count++;

  ASSERT(req->path);

  uv_fs_req_cleanup(req);

}

static void fsync_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &fsync_req);

  ASSERT(req->fs_type == UV_FS_FSYNC);

  ASSERT(req->result == 0);

  fsync_cb_count++;

  uv_fs_req_cleanup(req);

  r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

  ASSERT(r == 0);

}

static void fdatasync_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &fdatasync_req);

  ASSERT(req->fs_type == UV_FS_FDATASYNC);

  ASSERT(req->result == 0);

  fdatasync_cb_count++;

  uv_fs_req_cleanup(req);

  r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb);

  ASSERT(r == 0);

}

static void write_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &write_req);

  ASSERT(req->fs_type == UV_FS_WRITE);

  ASSERT(req->result >= 0);  /* FIXME(bnoordhuis) Check if requested size? */

  write_cb_count++;

  uv_fs_req_cleanup(req);

  r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb);

  ASSERT(r == 0);

}

static void create_cb(uv_fs_t* req) {

  int r;

  ASSERT(req == &open_req1);

  ASSERT(req->fs_type == UV_FS_OPEN);

  ASSERT(req->result >= 0);

  create_cb_count++;

  uv_fs_req_cleanup(req);

  iov = uv_buf_init(test_buf, sizeof(test_buf));

  r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb);

  ASSERT(r == 0);

}

static void rename_cb(uv_fs_t* req) {

  ASSERT(req == &rename_req);

  ASSERT(req->fs_type == UV_FS_RENAME);

  ASSERT(req->result == 0);

  rename_cb_count++;

  uv_fs_req_cleanup(req);

}

static void mkdir_cb(uv_fs_t* req) {

  ASSERT(req == &mkdir_req);

  ASSERT(req->fs_type == UV_FS_MKDIR);

  ASSERT(req->result == 0);

  mkdir_cb_count++;

  ASSERT(req->path);

  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

  uv_fs_req_cleanup(req);

}

static void check_mkdtemp_result(uv_fs_t* req) {

  int r;

  ASSERT(req->fs_type == UV_FS_MKDTEMP);

  ASSERT(req->result == 0);

  ASSERT(req->path);

  ASSERT(strlen(req->path) == 15);

  ASSERT(memcmp(req->path, "test_dir_", 9) == 0);

  ASSERT(memcmp(req->path + 9, "XXXXXX", 6) != 0);

  check_permission(req->path, 0700);

  /* Check if req->path is actually a directory */

  r = uv_fs_stat(NULL, &stat_req, req->path, NULL);

  ASSERT(r == 0);

  ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR);

  uv_fs_req_cleanup(&stat_req);

}

static void mkdtemp_cb(uv_fs_t* req) {

  ASSERT(req == &mkdtemp_req1);

  check_mkdtemp_result(req);

  mkdtemp_cb_count++;

}

static void rmdir_cb(uv_fs_t* req) {

  ASSERT(req == &rmdir_req);

  ASSERT(req->fs_type == UV_FS_RMDIR);

  ASSERT(req->result == 0);

  rmdir_cb_count++;

  ASSERT(req->path);

  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

  uv_fs_req_cleanup(req);

}

static void assert_is_file_type(uv_dirent_t dent) {

#ifdef HAVE_DIRENT_TYPES

  /*

   * For Apple and Windows, we know getdents is expected to work but for other

   * environments, the filesystem dictates whether or not getdents supports

   * returning the file type.

   *

   *   See:

   *     http://man7.org/linux/man-pages/man2/getdents.2.html

   *     https://github.com/libuv/libuv/issues/501

   */

  #if defined(__APPLE__) || defined(_WIN32)

    ASSERT(dent.type == UV_DIRENT_FILE);

  #else

    ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);

  #endif

#else

  ASSERT(dent.type == UV_DIRENT_UNKNOWN);

#endif

}

static void scandir_cb(uv_fs_t* req) {

  uv_dirent_t dent;

  ASSERT(req == &scandir_req);

  ASSERT(req->fs_type == UV_FS_SCANDIR);

  ASSERT(req->result == 2);

  ASSERT(req->ptr);

  while (UV_EOF != uv_fs_scandir_next(req, &dent)) {

    ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);

    assert_is_file_type(dent);

  }

  scandir_cb_count++;

  ASSERT(req->path);

  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

  uv_fs_req_cleanup(req);

  ASSERT(!req->ptr);

}

static void empty_scandir_cb(uv_fs_t* req) {

  uv_dirent_t dent;

  ASSERT(req == &scandir_req);

  ASSERT(req->fs_type == UV_FS_SCANDIR);

  ASSERT(req->result == 0);

  ASSERT(req->ptr == NULL);

  ASSERT(UV_EOF == uv_fs_scandir_next(req, &dent));

  uv_fs_req_cleanup(req);

  scandir_cb_count++;

}

static void non_existent_scandir_cb(uv_fs_t* req) {

  uv_dirent_t dent;

  ASSERT(req == &scandir_req);

  ASSERT(req->fs_type == UV_FS_SCANDIR);

  ASSERT(req->result == UV_ENOENT);

  ASSERT(req->ptr == NULL);

  ASSERT(UV_ENOENT == uv_fs_scandir_next(req, &dent));

  uv_fs_req_cleanup(req);

  scandir_cb_count++;

}

static void file_scandir_cb(uv_fs_t* req) {

  ASSERT(req == &scandir_req);

  ASSERT(req->fs_type == UV_FS_SCANDIR);

  ASSERT(req->result == UV_ENOTDIR);

  ASSERT(req->ptr == NULL);

  uv_fs_req_cleanup(req);

  scandir_cb_count++;

}

static void stat_cb(uv_fs_t* req) {

  ASSERT(req == &stat_req);

  ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT);

  ASSERT(req->result == 0);

  ASSERT(req->ptr);

  stat_cb_count++;

  uv_fs_req_cleanup(req);

  ASSERT(!req->ptr);

}

static void sendfile_cb(uv_fs_t* req) {

  ASSERT(req == &sendfile_req);

  ASSERT(req->fs_type == UV_FS_SENDFILE);

  ASSERT(req->result == 65546);

  sendfile_cb_count++;

  uv_fs_req_cleanup(req);

}

static void open_noent_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_OPEN);

  ASSERT(req->result == UV_ENOENT);

  open_cb_count++;

  uv_fs_req_cleanup(req);

}

static void open_nametoolong_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_OPEN);

  ASSERT(req->result == UV_ENAMETOOLONG);

  open_cb_count++;

  uv_fs_req_cleanup(req);

}

static void open_loop_cb(uv_fs_t* req) {

  ASSERT(req->fs_type == UV_FS_OPEN);

  ASSERT(req->result == UV_ELOOP);

  open_cb_count++;

  uv_fs_req_cleanup(req);

}

TEST_IMPL(fs_file_noent) {

  uv_fs_t req;

  int r;

  loop = uv_default_loop();

  r = uv_fs_open(NULL, &req, "does_not_exist", O_RDONLY, 0, NULL);

  ASSERT(r == UV_ENOENT);

  ASSERT(req.result == UV_ENOENT);

  uv_fs_req_cleanup(&req;;

  r = uv_fs_open(loop, &req, "does_not_exist", O_RDONLY, 0, open_noent_cb);

  ASSERT(r == 0);

  ASSERT(open_cb_count == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(open_cb_count == 1);

  /* TODO add EACCES test */

  MAKE_VALGRIND_HAPPY();

  return 0;

}

TEST_IMPL(fs_file_nametoolong) {

  uv_fs_t req;

  int r;

  char name[TOO_LONG_NAME_LENGTH + 1];

  loop = uv_default_loop();

  memset(name, 'a', TOO_LONG_NAME_LENGTH);

  name[TOO_LONG_NAME_LENGTH] = 0;

  r = uv_fs_open(NULL, &req, name, O_RDONLY, 0, NULL);

  ASSERT(r == UV_ENAMETOOLONG);

  ASSERT(req.result == UV_ENAMETOOLONG);

  uv_fs_req_cleanup(&req;;

  r = uv_fs_open(loop, &req, name, O_RDONLY, 0, open_nametoolong_cb);

  ASSERT(r == 0);

  ASSERT(open_cb_count == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(open_cb_count == 1);

  MAKE_VALGRIND_HAPPY();

  return 0;

}

TEST_IMPL(fs_file_loop) {

  uv_fs_t req;

  int r;

  loop = uv_default_loop();

  unlink("test_symlink");

  r = uv_fs_symlink(NULL, &req, "test_symlink", "test_symlink", 0, NULL);

#ifdef _WIN32

  /*

   * Windows XP and Server 2003 don't support symlinks; we'll get UV_ENOTSUP.

   * Starting with vista they are supported, but only when elevated, otherwise

   * we'll see UV_EPERM.

   */

  if (r == UV_ENOTSUP || r == UV_EPERM)

    return 0;

#elif defined(__MSYS__)

  /* MSYS2's approximation of symlinks with copies does not work for broken

     links.  */

  if (r == UV_ENOENT)

    return 0;

#endif

  ASSERT(r == 0);

  uv_fs_req_cleanup(&req;;

  r = uv_fs_open(NULL, &req, "test_symlink", O_RDONLY, 0, NULL);

  ASSERT(r == UV_ELOOP);

  ASSERT(req.result == UV_ELOOP);

  uv_fs_req_cleanup(&req;;

  r = uv_fs_open(loop, &req, "test_symlink", O_RDONLY, 0, open_loop_cb);

  ASSERT(r == 0);

  ASSERT(open_cb_count == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(open_cb_count == 1);

  unlink("test_symlink");

  MAKE_VALGRIND_HAPPY();

  return 0;

}

static void check_utime(const char* path, double atime, double mtime) {

  uv_stat_t* s;

  uv_fs_t req;

  int r;

  r = uv_fs_stat(loop, &req, path, NULL);

  ASSERT(r == 0);

  ASSERT(req.result == 0);

  s = &req.statbuf;

  ASSERT(s->st_atim.tv_sec + (s->st_atim.tv_nsec / 1000000000.0) == atime);

  ASSERT(s->st_mtim.tv_sec + (s->st_mtim.tv_nsec / 1000000000.0) == mtime);

  uv_fs_req_cleanup(&req;;

}

static void utime_cb(uv_fs_t* req) {

  utime_check_t* c;

  ASSERT(req == &utime_req);

  ASSERT(req->result == 0);

  ASSERT(req->fs_type == UV_FS_UTIME);

  c = req->data;

  check_utime(c->path, c->atime, c->mtime);

  uv_fs_req_cleanup(req);

  utime_cb_count++;

}

static void futime_cb(uv_fs_t* req) {

  utime_check_t* c;

  ASSERT(req == &futime_req);

  ASSERT(req->result == 0);

  ASSERT(req->fs_type == UV_FS_FUTIME);

  c = req->data;

  check_utime(c->path, c->atime, c->mtime);

  uv_fs_req_cleanup(req);

  futime_cb_count++;

}

TEST_IMPL(fs_file_async) {

  int r;

  /* Setup. */

  unlink("test_file");

  unlink("test_file2");

  loop = uv_default_loop();

  r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,

      S_IRUSR | S_IWUSR, create_cb);

  ASSERT(r == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(create_cb_count == 1);

  ASSERT(write_cb_count == 1);

  ASSERT(fsync_cb_count == 1);

  ASSERT(fdatasync_cb_count == 1);

  ASSERT(close_cb_count == 1);

  r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb);

  ASSERT(r == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(create_cb_count == 1);

  ASSERT(write_cb_count == 1);

  ASSERT(close_cb_count == 1);

  ASSERT(rename_cb_count == 1);

  r = uv_fs_open(loop, &open_req1, "test_file2", O_RDWR, 0, open_cb);

  ASSERT(r == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(open_cb_count == 1);

  ASSERT(read_cb_count == 1);

  ASSERT(close_cb_count == 2);

  ASSERT(rename_cb_count == 1);

  ASSERT(create_cb_count == 1);

  ASSERT(write_cb_count == 1);

  ASSERT(ftruncate_cb_count == 1);

  r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, open_cb);

  ASSERT(r == 0);

  uv_run(loop, UV_RUN_DEFAULT);

  ASSERT(open_cb_count == 2);

  ASSERT(read_cb_count == 2);

  ASSERT(close_cb_count == 3);

  ASSERT(rename_cb_count == 1);

  ASSERT(unlink_cb_count == 1);

  ASSERT(create_cb_count == 1);

  ASSERT(write_cb_count == 1);

  ASSERT(ftruncate_cb_count == 1);

  /* Cleanup. */

  unlink("test_file");

  unlink("test_file2");

  MAKE_VALGRIND_HAPPY();

  return 0;

}

TEST_IMPL(fs_file_sync) {

  int r;

  /* Setup. */

  unlink("test_file");

  unlink("test_file2");

  loop = uv_default_loop();

  r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,

      S_IWUSR | S_IRUSR, NULL);

  ASSERT(r >= 0);

  ASSERT(open_req1.result >= 0);

  uv_fs_req_cleanup(&open_req1);

  iov = uv_buf_init(test_buf, sizeof(test_buf));

  r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);

  ASSERT(r >= 0);

  ASSERT(write_req.result >= 0);

  uv_fs_req_cleanup(&write_req);

  r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);

  ASSERT(r == 0);

  ASSERT(close_req.result == 0);

  uv_fs_req_cleanup(&close_req);

  r = uv_fs_open(NULL, &open_req1, "test_file", O_RDWR, 0, NULL);

  ASSERT(r >= 0);

  ASSERT(open_req1.result >= 0);

  uv_fs_req_cleanup(&open_req1);

  iov = uv_buf_init(buf, sizeof(buf));

  r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);

  ASSERT(r >= 0);

  ASSERT(read_req.result >= 0);

  ASSERT(strcmp(buf, test_buf) == 0);

  uv_fs_req_cleanup(&read_req);

  r = uv_fs_ftruncate(NULL, &ftruncate_req, open_req1.result, 7, NULL);

  ASSERT(r == 0);

  ASSERT(ftruncate_req.result == 0);

  uv_fs_req_cleanup(&ftruncate_req);

  r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);

  ASSERT(r == 0);

  ASSERT(close_req.result == 0);

  uv_fs_req_cleanup(&close_req);

  r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL);

  ASSERT(r == 0);

  ASSERT(rename_req.result == 0);

  uv_fs_req_cleanup(&rename_req);

  r = uv_fs_open(NULL, &open_req1, "test_file2", O_RDONLY, 0, NULL);

  ASSERT(r >= 0);

  ASSERT(open_req1.result >= 0);

  uv_fs_req_cleanup(&open_req1);

  memset(buf, 0, sizeof(buf));

  iov = uv_buf_init(buf, sizeof(buf));

  r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL);

  ASSERT(r >= 0);

  ASSERT(read_req.result >= 0);

  ASSERT(strcmp(buf, "test-bu") == 0);

  uv_fs_req_cleanup(&read_req);

  r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);

  ASSERT(r == 0);