/* 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 <direct.h>

# include <io.h>

# 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 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;

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 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 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);

ASSERT(close_req.result == 0);

uv_fs_req_cleanup(&close_req);

r = uv_fs_unlink(NULL, &unlink_req, "test_file2", NULL);

ASSERT(r == 0);

ASSERT(unlink_req.result == 0);

uv_fs_req_cleanup(&unlink_req);

/* Cleanup */

unlink("test_file");

unlink("test_file2");

MAKE_VALGRIND_HAPPY();

return 0;

}

TEST_IMPL(fs_file_write_null_buffer) {

int r;

/* Setup. */

unlink("test_file");

loop = uv_default_loop();

r = uv_fs_open(NULL, &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(NULL, 0);

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);

unlink("test_file");

MAKE_VALGRIND_HAPPY();

return 0;

}

TEST_IMPL(fs_async_dir) {

int r;

uv_dirent_t dent;

/* Setup */

unlink("test_dir/file1");

unlink("test_dir/file2");

rmdir("test_dir");

loop = uv_default_loop();

r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(mkdir_cb_count == 1);

/* Create 2 files synchronously. */

r = uv_fs_open(NULL, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT,

S_IWUSR | S_IRUSR, NULL);

ASSERT(r >= 0);

uv_fs_req_cleanup(&open_req1);

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

ASSERT(r == 0);

uv_fs_req_cleanup(&close_req);

r = uv_fs_open(NULL, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT,

S_IWUSR | S_IRUSR, NULL);

ASSERT(r >= 0);

uv_fs_req_cleanup(&open_req1);

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

ASSERT(r == 0);

uv_fs_req_cleanup(&close_req);

r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, scandir_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(scandir_cb_count == 1);

/* sync uv_fs_scandir */

r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL);

ASSERT(r == 2);

ASSERT(scandir_req.result == 2);

ASSERT(scandir_req.ptr);

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

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

assert_is_file_type(dent);

}

uv_fs_req_cleanup(&scandir_req);

ASSERT(!scandir_req.ptr);

r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

r = uv_fs_stat(loop, &stat_req, "test_dir/", stat_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

r = uv_fs_lstat(loop, &stat_req, "test_dir", stat_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

r = uv_fs_lstat(loop, &stat_req, "test_dir/", stat_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(stat_cb_count == 4);

r = uv_fs_unlink(loop, &unlink_req, "test_dir/file1", unlink_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(unlink_cb_count == 1);

r = uv_fs_unlink(loop, &unlink_req, "test_dir/file2", unlink_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(unlink_cb_count == 2);

r = uv_fs_rmdir(loop, &rmdir_req, "test_dir", rmdir_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(rmdir_cb_count == 1);

/* Cleanup */

unlink("test_dir/file1");

unlink("test_dir/file2");

rmdir("test_dir");

MAKE_VALGRIND_HAPPY();

return 0;

}

TEST_IMPL(fs_async_sendfile) {

int f, r;