noderb 0.0.8 → 0.0.9

data/ext/noderb_extension/libuv/test/benchmark-ares.c

@@ -86,7 +86,6 @@ BENCHMARK_IMPL(gethostbyname) {
     return 1;
   }
 
-  uv_init();
   loop = uv_default_loop();
 
   ares_callbacks = 0;

data/ext/noderb_extension/libuv/test/benchmark-getaddrinfo.c

@@ -68,7 +68,6 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) {
 BENCHMARK_IMPL(getaddrinfo) {
   int i;
 
-  uv_init(loop);
   loop = uv_default_loop();
 
   uv_update_time(loop);

data/ext/noderb_extension/libuv/test/benchmark-ping-pongs.c

@@ -200,7 +200,6 @@ static void pinger_new() {
 
 
 BENCHMARK_IMPL(ping_pongs) {
-  uv_init();
   loop = uv_default_loop();
 
   start_time = uv_now(loop);

data/ext/noderb_extension/libuv/test/benchmark-pound.c

@@ -277,7 +277,6 @@ static int pound_it(int concurrency,
   uint64_t start_time; /* in ns */
   uint64_t end_time;
 
-  uv_init();
   loop = uv_default_loop();
 
   uv_update_time(loop);

data/ext/noderb_extension/libuv/test/benchmark-pump.c

@@ -273,10 +273,12 @@ static void connection_cb(uv_stream_t* s, int status) {
 
   if (type == TCP) {
     stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t));
-    uv_tcp_init(loop, (uv_tcp_t*)stream);
+    r = uv_tcp_init(loop, (uv_tcp_t*)stream);
+    ASSERT(r == 0);
   } else {
     stream = (uv_stream_t*)malloc(sizeof(uv_pipe_t));
-    uv_pipe_init(loop, (uv_pipe_t*)stream);
+    r = uv_pipe_init(loop, (uv_pipe_t*)stream);
+    ASSERT(r == 0);
   }
 
   r = uv_accept(s, stream);
@@ -367,7 +369,6 @@ HELPER_IMPL(tcp_pump_server) {
   int r;
 
   type = TCP;
-  uv_init();
   loop = uv_default_loop();
 
   listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
@@ -391,7 +392,6 @@ HELPER_IMPL(pipe_pump_server) {
   int r;
   type = PIPE;
 
-  uv_init();
   loop = uv_default_loop();
 
   /* Server */
@@ -414,7 +414,6 @@ void tcp_pump(int n) {
   TARGET_CONNECTIONS = n;
   type = TCP;
 
-  uv_init();
   loop = uv_default_loop();
 
   connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
@@ -431,7 +430,6 @@ void pipe_pump(int n) {
   TARGET_CONNECTIONS = n;
   type = PIPE;
 
-  uv_init();
   loop = uv_default_loop();
 
   /* Start making connections */

data/ext/noderb_extension/libuv/test/benchmark-spawn.c

@@ -132,7 +132,6 @@ BENCHMARK_IMPL(spawn) {
   int r;
   static int64_t start_time, end_time;
 
-  uv_init();
   loop = uv_default_loop();
 
   r = uv_exepath(exepath, &exepath_size);

data/ext/noderb_extension/libuv/test/benchmark-udp-packet-storm.c

@@ -134,7 +134,6 @@ static int do_packet_storm(int n_senders, int n_receivers) {
   ASSERT(n_senders <= MAX_SENDERS);
   ASSERT(n_receivers <= MAX_RECEIVERS);
 
-  uv_init();
   loop = uv_default_loop();
 
   n_senders_ = n_senders;

data/ext/noderb_extension/libuv/test/dns-server.c

@@ -272,7 +272,8 @@ static void on_connection(uv_stream_t* server, int status) {
   handle->state.prevbuf_pos = 0;
   handle->state.prevbuf_rem = 0;
 
-  uv_tcp_init(loop, (uv_tcp_t*)handle);
+  r = uv_tcp_init(loop, (uv_tcp_t*)handle);
+  ASSERT(r == 0);
 
   r = uv_accept(server, (uv_stream_t*)handle);
   ASSERT(r == 0);
@@ -317,7 +318,6 @@ static int dns_start(int port) {
 
 
 HELPER_IMPL(dns_server) {
-  uv_init();
   loop = uv_default_loop();
 
   if (dns_start(TEST_PORT_2))

data/ext/noderb_extension/libuv/test/echo-server.c

@@ -144,13 +144,15 @@ static void on_connection(uv_stream_t* server, int status) {
   case TCP:
     stream = malloc(sizeof(uv_tcp_t));
     ASSERT(stream != NULL);
-    uv_tcp_init(loop, (uv_tcp_t*)stream);
+    r = uv_tcp_init(loop, (uv_tcp_t*)stream);
+    ASSERT(r == 0);
     break;
 
   case PIPE:
     stream = malloc(sizeof(uv_pipe_t));
     ASSERT(stream != NULL);
-    uv_pipe_init(loop, (uv_pipe_t*)stream);
+    r = uv_pipe_init(loop, (uv_pipe_t*)stream);
+    ASSERT(r == 0);
     break;
 
   default:
@@ -272,7 +274,6 @@ static int pipe_echo_start(char* pipeName) {
 
 
 HELPER_IMPL(tcp4_echo_server) {
-  uv_init();
   loop = uv_default_loop();
 
   if (tcp4_echo_start(TEST_PORT))
@@ -284,7 +285,6 @@ HELPER_IMPL(tcp4_echo_server) {
 
 
 HELPER_IMPL(tcp6_echo_server) {
-  uv_init();
   loop = uv_default_loop();
 
   if (tcp6_echo_start(TEST_PORT))
@@ -296,7 +296,6 @@ HELPER_IMPL(tcp6_echo_server) {
 
 
 HELPER_IMPL(pipe_echo_server) {
-  uv_init();
   loop = uv_default_loop();
 
   if (pipe_echo_start(TEST_PIPENAME))

data/ext/noderb_extension/libuv/test/run-tests.c

@@ -28,12 +28,10 @@
 /* Actual tests and helpers are defined in test-list.h */
 #include "test-list.h"
 
-
 /* The time in milliseconds after which a single test times out. */
 #define TEST_TIMEOUT  5000
 
 static int maybe_run_test(int argc, char **argv);
-static void list_all_tests(void);
 
 
 int main(int argc, char **argv) {

data/ext/noderb_extension/libuv/test/test-async.c

@@ -182,8 +182,6 @@ static void prepare_cb(uv_prepare_t* handle, int status) {
 TEST_IMPL(async) {
   int r;
 
-  uv_init();
-
   r = uv_prepare_init(uv_default_loop(), &prepare_handle);
   ASSERT(r == 0);
   r = uv_prepare_start(&prepare_handle, prepare_cb);

data/ext/noderb_extension/libuv/test/test-callback-stack.c

@@ -176,8 +176,6 @@ static void connect_cb(uv_connect_t* req, int status) {
 TEST_IMPL(callback_stack) {
   struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
 
-  uv_init();
-
   if (uv_tcp_init(uv_default_loop(), &client)) {
     FATAL("uv_tcp_init failed");
   }

data/ext/noderb_extension/libuv/test/test-connection-fail.c

@@ -119,8 +119,6 @@ void connection_fail(uv_connect_cb connect_cb) {
  * expect an error.
  */
 TEST_IMPL(connection_fail) {
-  uv_init();
-
   connection_fail(on_connect_with_close);
 
   ASSERT(timer_close_cb_calls == 0);
@@ -136,10 +134,10 @@ TEST_IMPL(connection_fail) {
  * attempt.
  */
 TEST_IMPL(connection_fail_doesnt_auto_close) {
-  uv_init();
-
+  int r;
 
-  uv_timer_init(uv_default_loop(), &timer);
+  r = uv_timer_init(uv_default_loop(), &timer);
+  ASSERT(r == 0);
 
   connection_fail(on_connect_without_close);
 

data/ext/noderb_extension/libuv/test/test-delayed-accept.c

@@ -57,7 +57,8 @@ static void do_accept(uv_timer_t* timer_handle, int status) {
   ASSERT(status == 0);
   ASSERT(accepted_handle != NULL);
 
-  uv_tcp_init(uv_default_loop(), accepted_handle);
+  r = uv_tcp_init(uv_default_loop(), accepted_handle);
+  ASSERT(r == 0);
 
   /* Test to that uv_default_loop()->counters.tcp_init does not increase across the uv_accept. */
   tcpcnt = uv_default_loop()->counters.tcp_init;
@@ -180,8 +181,6 @@ static void client_connect() {
 
 
 TEST_IMPL(delayed_accept) {
-  uv_init();
-
   start_server();
 
   client_connect();

data/ext/noderb_extension/libuv/test/test-fs.c

@@ -25,23 +25,34 @@
 #include "uv.h"
 #include "task.h"
 
+#include <errno.h>
 #include <string.h> /* memset */
 #include <fcntl.h>
 #include <sys/stat.h>
 
 
-#if !UNIX
+#if UNIX
+#include <unistd.h> /* unlink, rmdir, etc. */
+#else
 # include <direct.h>
 # include <io.h>
 # define unlink _unlink
 # define rmdir _rmdir
-# define stat _stat
+# define stat _stati64
 # define open _open
 # define write _write
 # define lseek _lseek
 # define close _close
 #endif
 
+
+typedef struct {
+  const char* path;
+  double atime;
+  double mtime;
+} utime_check_t;
+
+
 static int close_cb_count;
 static int create_cb_count;
 static int open_cb_count;
@@ -60,6 +71,13 @@ static int sendfile_cb_count;
 static int fstat_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 utime_cb_count;
+static int futime_cb_count;
 
 static uv_loop_t* loop;
 
@@ -78,6 +96,8 @@ 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 test_buf[] = "test-buffer\n";
@@ -93,18 +113,49 @@ void check_permission(const char* filename, int mode) {
   ASSERT(req.result == 0);
 
   s = req.ptr;
+#ifdef _WIN32
+  /* 
+   * 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 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 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", 0600);
+  check_permission("test_file", (int)req->data);
 }
 
 
@@ -113,7 +164,23 @@ static void chmod_cb(uv_fs_t* req) {
   ASSERT(req->result == 0);
   chmod_cb_count++;
   uv_fs_req_cleanup(req);
-  check_permission("test_file", 0200);
+  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);
 }
 
 
@@ -187,6 +254,8 @@ static void open_cb(uv_fs_t* req) {
     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));
   r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
@@ -253,6 +322,8 @@ static void mkdir_cb(uv_fs_t* req) {
   ASSERT(req->fs_type == UV_FS_MKDIR);
   ASSERT(req->result != -1);
   mkdir_cb_count++;
+  ASSERT(req->path);
+  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
   uv_fs_req_cleanup(req);
 }
 
@@ -262,6 +333,8 @@ static void rmdir_cb(uv_fs_t* req) {
   ASSERT(req->fs_type == UV_FS_RMDIR);
   ASSERT(req->result != -1);
   rmdir_cb_count++;
+  ASSERT(req->path);
+  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
   uv_fs_req_cleanup(req);
 }
 
@@ -271,10 +344,11 @@ static void readdir_cb(uv_fs_t* req) {
   ASSERT(req->fs_type == UV_FS_READDIR);
   ASSERT(req->result == 2);
   ASSERT(req->ptr);
-  ASSERT(strcmp((const char*)req->ptr, "file1") == 0);
-  ASSERT(strcmp((char*)req->ptr + strlen((const char*)req->ptr) + 1,
-                "file2") == 0);
+  ASSERT(memcmp(req->ptr, "file1\0file2\0", 12) == 0
+      || memcmp(req->ptr, "file2\0file1\0", 12) == 0);
   readdir_cb_count++;
+  ASSERT(req->path);
+  ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
   uv_fs_req_cleanup(req);
   ASSERT(!req->ptr);
 }
@@ -300,6 +374,100 @@ static void sendfile_cb(uv_fs_t* req) {
 }
 
 
+static void open_noent_cb(uv_fs_t* req) {
+  ASSERT(req->fs_type == UV_FS_OPEN);
+  ASSERT(req->errorno == UV_ENOENT);
+  ASSERT(req->result == -1);
+  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(loop, &req, "does_not_exist", O_RDONLY, 0, NULL);
+  ASSERT(r == -1);
+  ASSERT(req.result == -1);
+  ASSERT(uv_last_error(loop).code == 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);
+  ASSERT(open_cb_count == 1);
+
+  /* TODO add EACCES test */
+
+  return 0;
+}
+
+
+static void check_utime(const char* path, double atime, double mtime) {
+  struct stat* s;
+  uv_fs_t req;
+  int r;
+
+  r = uv_fs_stat(loop, &req, path, NULL);
+  ASSERT(r == 0);
+
+  ASSERT(req.result == 0);
+  s = req.ptr;
+
+#if _WIN32
+  ASSERT(s->st_atime == atime);
+  ASSERT(s->st_mtime == mtime);
+#elif !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+  ASSERT(s->st_atimespec.tv_sec  == atime);
+  ASSERT(s->st_atimespec.tv_nsec == 0); /* FIXME check sub-second precision */
+  ASSERT(s->st_mtimespec.tv_sec  == mtime);
+  ASSERT(s->st_mtimespec.tv_nsec == 0); /* FIXME check sub-second precision */
+#else
+  ASSERT(s->st_atim.tv_sec  == atime);
+  ASSERT(s->st_atim.tv_nsec == 0); /* FIXME check sub-second precision */
+  ASSERT(s->st_mtim.tv_sec  == mtime);
+  ASSERT(s->st_mtim.tv_nsec == 0); /* FIXME check sub-second precision */
+#endif
+
+  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;
 
@@ -307,7 +475,6 @@ TEST_IMPL(fs_file_async) {
   unlink("test_file");
   unlink("test_file2");
 
-  uv_init();
   loop = uv_default_loop();
 
   r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
@@ -370,73 +537,72 @@ TEST_IMPL(fs_file_sync) {
   unlink("test_file");
   unlink("test_file2");
 
-  uv_init();
   loop = uv_default_loop();
 
   r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
       S_IWRITE | S_IREAD, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(open_req1.result != -1);
   uv_fs_req_cleanup(&open_req1);
 
   r = uv_fs_write(loop, &write_req, open_req1.result, test_buf,
       sizeof(test_buf), -1, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(write_req.result != -1);
   uv_fs_req_cleanup(&write_req);
 
   r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(close_req.result != -1);
   uv_fs_req_cleanup(&close_req);
 
   r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(open_req1.result != -1);
   uv_fs_req_cleanup(&open_req1);
 
   r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
       NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(read_req.result != -1);
   ASSERT(strcmp(buf, test_buf) == 0);
   uv_fs_req_cleanup(&read_req);
 
   r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(ftruncate_req.result != -1);
   uv_fs_req_cleanup(&ftruncate_req);
 
   r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(close_req.result != -1);
   uv_fs_req_cleanup(&close_req);
 
   r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(rename_req.result != -1);
   uv_fs_req_cleanup(&rename_req);
 
   r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(open_req1.result != -1);
   uv_fs_req_cleanup(&open_req1);
 
   memset(buf, 0, sizeof(buf));
   r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
       NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(read_req.result != -1);
   ASSERT(strcmp(buf, "test-bu") == 0);
   uv_fs_req_cleanup(&read_req);
 
   r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(close_req.result != -1);
   uv_fs_req_cleanup(&close_req);
 
   r = uv_fs_unlink(loop, &unlink_req, "test_file2", NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(unlink_req.result != -1);
   uv_fs_req_cleanup(&unlink_req);
 
@@ -456,7 +622,6 @@ TEST_IMPL(fs_async_dir) {
   unlink("test_dir/file2");
   rmdir("test_dir");
 
-  uv_init();
   loop = uv_default_loop();
 
   r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb);
@@ -468,7 +633,7 @@ TEST_IMPL(fs_async_dir) {
   /* Create 2 files synchronously. */
   r = uv_fs_open(loop, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT,
       S_IWRITE | S_IREAD, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   uv_fs_req_cleanup(&open_req1);
   r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
   ASSERT(r == 0);
@@ -476,7 +641,7 @@ TEST_IMPL(fs_async_dir) {
 
   r = uv_fs_open(loop, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT,
       S_IWRITE | S_IREAD, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   uv_fs_req_cleanup(&open_req1);
   r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
   ASSERT(r == 0);
@@ -488,6 +653,16 @@ TEST_IMPL(fs_async_dir) {
   uv_run(loop);
   ASSERT(readdir_cb_count == 1);
 
+  /* sync uv_fs_readdir */
+  r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
+  ASSERT(r == 2);
+  ASSERT(readdir_req.result == 2);
+  ASSERT(readdir_req.ptr);
+  ASSERT(memcmp(readdir_req.ptr, "file1\0file2\0", 12) == 0
+      || memcmp(readdir_req.ptr, "file2\0file1\0", 12) == 0);
+  uv_fs_req_cleanup(&readdir_req);
+  ASSERT(!readdir_req.ptr);
+
   r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
   ASSERT(r == 0);
   uv_run(loop);
@@ -534,8 +709,9 @@ TEST_IMPL(fs_async_sendfile) {
   int f, r;
   struct stat s1, s2;
 
+  loop = uv_default_loop();
+
   /* Setup. */
-  uv_init();
   unlink("test_file");
   unlink("test_file2");
 
@@ -555,16 +731,14 @@ TEST_IMPL(fs_async_sendfile) {
   ASSERT(r == 0);
 
   /* Test starts here. */
-  loop = uv_default_loop();
-
   r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(open_req1.result != -1);
   uv_fs_req_cleanup(&open_req1);
 
   r = uv_fs_open(loop, &open_req2, "test_file2", O_WRONLY | O_CREAT,
       S_IWRITE | S_IREAD, NULL);
-  ASSERT(r == 0);
+  ASSERT(r != -1);
   ASSERT(open_req2.result != -1);
   uv_fs_req_cleanup(&open_req2);
 
@@ -598,29 +772,29 @@ TEST_IMPL(fs_fstat) {
   int r;
   uv_fs_t req;
   uv_file file;
+  struct stat* s;
 
   /* Setup. */
   unlink("test_file");
 
-  uv_init();
-
   loop = uv_default_loop();
 
-  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT, 0, NULL);
-  ASSERT(r == 0);
+  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
   ASSERT(req.result != -1);
   file = req.result;
   uv_fs_req_cleanup(&req);
 
   r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
-  ASSERT(r == 0);
+  ASSERT(r == sizeof(test_buf));
   ASSERT(req.result == sizeof(test_buf));
   uv_fs_req_cleanup(&req);
 
   r = uv_fs_fstat(loop, &req, file, NULL);
   ASSERT(r == 0);
   ASSERT(req.result == 0);
-  struct stat* s = req.ptr;
+  s = req.ptr;
   ASSERT(s->st_size == sizeof(test_buf));
   uv_fs_req_cleanup(&req);
 
@@ -637,7 +811,7 @@ TEST_IMPL(fs_fstat) {
   uv_fs_req_cleanup(&req);
 
   /*
-   * Run the loop just to check we don't have make any extranious uv_ref()
+   * Run the loop just to check we don't have make any extraneous uv_ref()
    * calls. This should drop out immediately.
    */
   uv_run(loop);
@@ -657,21 +831,21 @@ TEST_IMPL(fs_chmod) {
   /* Setup. */
   unlink("test_file");
 
-  uv_init();
-
   loop = uv_default_loop();
 
-  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT, 0, NULL);
-  ASSERT(r == 0);
+  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
   ASSERT(req.result != -1);
   file = req.result;
   uv_fs_req_cleanup(&req);
 
   r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
-  ASSERT(r == 0);
+  ASSERT(r == sizeof(test_buf));
   ASSERT(req.result == sizeof(test_buf));
   uv_fs_req_cleanup(&req);
 
+#ifndef _WIN32
   /* Make the file write-only */
   r = uv_fs_chmod(loop, &req, "test_file", 0200, NULL);
   ASSERT(r == 0);
@@ -679,6 +853,15 @@ TEST_IMPL(fs_chmod) {
   uv_fs_req_cleanup(&req);
 
   check_permission("test_file", 0200);
+#endif
+
+  /* Make the file read-only */
+  r = uv_fs_chmod(loop, &req, "test_file", 0400, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  check_permission("test_file", 0400);
 
   /* Make the file read+write with sync uv_fs_fchmod */
   r = uv_fs_fchmod(loop, &req, file, 0600, NULL);
@@ -688,13 +871,25 @@ TEST_IMPL(fs_chmod) {
 
   check_permission("test_file", 0600);
 
+#ifndef _WIN32
   /* async chmod */
+  req.data = (void*)0200;
   r = uv_fs_chmod(loop, &req, "test_file", 0200, chmod_cb);
   ASSERT(r == 0);
   uv_run(loop);
   ASSERT(chmod_cb_count == 1);
+  chmod_cb_count = 0; /* reset for the next test */
+#endif
+
+  /* async chmod */
+  req.data = (void*)0400;
+  r = uv_fs_chmod(loop, &req, "test_file", 0400, chmod_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(chmod_cb_count == 1);
 
   /* async fchmod */
+  req.data = (void*)0600;
   r = uv_fs_fchmod(loop, &req, file, 0600, fchmod_cb);
   ASSERT(r == 0);
   uv_run(loop);
@@ -703,13 +898,354 @@ TEST_IMPL(fs_chmod) {
   close(file);
 
   /*
-   * Run the loop just to check we don't have make any extranious uv_ref()
+   * Run the loop just to check we don't have make any extraneous uv_ref()
+   * calls. This should drop out immediately.
+   */
+  uv_run(loop);
+
+  /* Cleanup. */
+  unlink("test_file");
+
+  return 0;
+}
+
+
+TEST_IMPL(fs_chown) {
+  int r;
+  uv_fs_t req;
+  uv_file file;
+
+  /* Setup. */
+  unlink("test_file");
+
+  loop = uv_default_loop();
+
+  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  file = req.result;
+  uv_fs_req_cleanup(&req);
+
+  /* sync chown */
+  r = uv_fs_chown(loop, &req, "test_file", -1, -1, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  /* sync fchown */
+  r = uv_fs_fchown(loop, &req, file, -1, -1, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  /* async chown */
+  r = uv_fs_chown(loop, &req, "test_file", -1, -1, chown_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(chown_cb_count == 1);
+
+  /* async fchown */
+  r = uv_fs_fchown(loop, &req, file, -1, -1, fchown_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(fchown_cb_count == 1);
+
+  close(file);
+
+  /*
+   * Run the loop just to check we don't have make any extraneous uv_ref()
+   * calls. This should drop out immediately.
+   */
+  uv_run(loop);
+
+  /* Cleanup. */
+  unlink("test_file");
+
+  return 0;
+}
+
+
+TEST_IMPL(fs_link) {
+  int r;
+  uv_fs_t req;
+  uv_file file;
+  uv_file link;
+
+  /* Setup. */
+  unlink("test_file");
+  unlink("test_file_link");
+  unlink("test_file_link2");
+
+  loop = uv_default_loop();
+
+  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  file = req.result;
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
+  ASSERT(r == sizeof(test_buf));
+  ASSERT(req.result == sizeof(test_buf));
+  uv_fs_req_cleanup(&req);
+
+  close(file);
+
+  /* sync link */
+  r = uv_fs_link(loop, &req, "test_file", "test_file_link", NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_open(loop, &req, "test_file_link", O_RDWR, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  link = req.result;
+  uv_fs_req_cleanup(&req);
+
+  memset(buf, 0, sizeof(buf));
+  r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  ASSERT(strcmp(buf, test_buf) == 0);
+
+  close(link);
+
+  /* async link */
+  r = uv_fs_link(loop, &req, "test_file", "test_file_link2", link_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(link_cb_count == 1);
+
+  r = uv_fs_open(loop, &req, "test_file_link2", O_RDWR, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  link = req.result;
+  uv_fs_req_cleanup(&req);
+
+  memset(buf, 0, sizeof(buf));
+  r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  ASSERT(strcmp(buf, test_buf) == 0);
+
+  close(link);
+
+  /*
+   * Run the loop just to check we don't have make any extraneous uv_ref()
+   * calls. This should drop out immediately.
+   */
+  uv_run(loop);
+
+  /* Cleanup. */
+  unlink("test_file");
+  unlink("test_file_link");
+  unlink("test_file_link2");
+
+  return 0;
+}
+
+
+TEST_IMPL(fs_symlink) {
+  int r;
+  uv_fs_t req;
+  uv_file file;
+  uv_file link;
+
+  /* Setup. */
+  unlink("test_file");
+  unlink("test_file_symlink");
+  unlink("test_file_symlink2");
+  unlink("test_file_symlink_symlink");
+  unlink("test_file_symlink2_symlink");
+
+  loop = uv_default_loop();
+
+  r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
+      S_IWRITE | S_IREAD, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  file = req.result;
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
+  ASSERT(r == sizeof(test_buf));
+  ASSERT(req.result == sizeof(test_buf));
+  uv_fs_req_cleanup(&req);
+
+  close(file);
+
+  /* sync symlink */
+  r = uv_fs_symlink(loop, &req, "test_file", "test_file_symlink", 0, NULL);
+#ifdef _WIN32
+  if (r == -1) {
+    if (req.errorno == ENOSYS) {
+      /*
+       * Windows doesn't support symlinks on older versions.
+       * We just pass the test and bail out early if we get ENOTSUP.
+       */
+      return 0;
+    } else if (uv_last_error(loop).sys_errno_ == ERROR_PRIVILEGE_NOT_HELD) {
+      /* 
+       * Creating a symlink is only allowed when running elevated.
+       * We pass the test and bail out early if we get ERROR_PRIVILEGE_NOT_HELD.
+       */
+      return 0;
+    }
+  }
+#endif
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_open(loop, &req, "test_file_symlink", O_RDWR, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  link = req.result;
+  uv_fs_req_cleanup(&req);
+
+  memset(buf, 0, sizeof(buf));
+  r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  ASSERT(strcmp(buf, test_buf) == 0);
+
+  close(link);
+
+  r = uv_fs_symlink(loop, &req, "test_file_symlink", "test_file_symlink_symlink", 0, NULL);
+  ASSERT(r != -1);
+  r = uv_fs_readlink(loop, &req, "test_file_symlink_symlink", NULL);
+  ASSERT(r != -1);
+  ASSERT(strcmp(req.ptr, "test_file_symlink") == 0);
+  uv_fs_req_cleanup(&req);
+
+  /* async link */
+  r = uv_fs_symlink(loop, &req, "test_file", "test_file_symlink2", 0, symlink_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(symlink_cb_count == 1);
+
+  r = uv_fs_open(loop, &req, "test_file_symlink2", O_RDWR, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  link = req.result;
+  uv_fs_req_cleanup(&req);
+
+  memset(buf, 0, sizeof(buf));
+  r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  ASSERT(strcmp(buf, test_buf) == 0);
+
+  close(link);
+
+  r = uv_fs_symlink(loop, &req, "test_file_symlink2", "test_file_symlink2_symlink", 0, NULL);
+  ASSERT(r != -1);
+  r = uv_fs_readlink(loop, &req, "test_file_symlink2_symlink", readlink_cb);
+  ASSERT(r != -1);
+  uv_run(loop);
+  ASSERT(readlink_cb_count == 1);
+
+  /*
+   * Run the loop just to check we don't have make any extraneous uv_ref()
    * calls. This should drop out immediately.
    */
   uv_run(loop);
 
   /* Cleanup. */
   unlink("test_file");
+  unlink("test_file_symlink");
+  unlink("test_file_symlink_symlink");
+  unlink("test_file_symlink2");
+  unlink("test_file_symlink2_symlink");
+
+  return 0;
+}
+
+
+TEST_IMPL(fs_utime) {
+  utime_check_t checkme;
+  const char* path = ".";
+  double atime;
+  double mtime;
+  uv_fs_t req;
+  int r;
+
+  loop = uv_default_loop();
+
+  atime = mtime = 400497753; /* 1982-09-10 11:22:33 */
+
+  r = uv_fs_utime(loop, &req, path, atime, mtime, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_stat(loop, &req, path, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  check_utime(path, atime, mtime);
+  uv_fs_req_cleanup(&req);
+
+  atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */
+  checkme.path = path;
+  checkme.atime = atime;
+  checkme.mtime = mtime;
+
+  /* async utime */
+  utime_req.data = &checkme;
+  r = uv_fs_utime(loop, &utime_req, path, atime, mtime, utime_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(utime_cb_count == 1);
+
+  return 0;
+}
+
+
+TEST_IMPL(fs_futime) {
+  utime_check_t checkme;
+  const char* path = ".";
+  double atime;
+  double mtime;
+  uv_file file;
+  uv_fs_t req;
+  int r;
+
+  loop = uv_default_loop();
+
+  atime = mtime = 400497753; /* 1982-09-10 11:22:33 */
+
+  r = uv_fs_open(loop, &req, path, O_RDONLY, 0, NULL);
+  ASSERT(r != -1);
+  ASSERT(req.result != -1);
+  file = req.result; /* FIXME probably not how it's supposed to be used */
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_futime(loop, &req, file, atime, mtime, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  uv_fs_req_cleanup(&req);
+
+  r = uv_fs_stat(loop, &req, path, NULL);
+  ASSERT(r == 0);
+  ASSERT(req.result == 0);
+  check_utime(path, atime, mtime);
+  uv_fs_req_cleanup(&req);
+
+  atime = mtime = 1291404900; /* 2010-12-03 20:35:00 - mees <3 */
+
+  checkme.atime = atime;
+  checkme.mtime = mtime;
+  checkme.path = path;
+
+  /* async futime */
+  futime_req.data = &checkme;
+  r = uv_fs_futime(loop, &futime_req, file, atime, mtime, futime_cb);
+  ASSERT(r == 0);
+  uv_run(loop);
+  ASSERT(futime_cb_count == 1);
 
   return 0;
 }