rbuv 0.0.1 → 0.0.2

data/deps/libuv/test/test-thread.c

@@ -0,0 +1,183 @@
+/* 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h> /* memset */
+
+struct getaddrinfo_req {
+  uv_thread_t thread_id;
+  unsigned int counter;
+  uv_loop_t* loop;
+  uv_getaddrinfo_t handle;
+};
+
+
+struct fs_req {
+  uv_thread_t thread_id;
+  unsigned int counter;
+  uv_loop_t* loop;
+  uv_fs_t handle;
+};
+
+
+struct test_thread {
+  uv_thread_t thread_id;
+  volatile int thread_called;
+};
+
+static void getaddrinfo_do(struct getaddrinfo_req* req);
+static void getaddrinfo_cb(uv_getaddrinfo_t* handle,
+                           int status,
+                           struct addrinfo* res);
+static void fs_do(struct fs_req* req);
+static void fs_cb(uv_fs_t* handle);
+
+static volatile int thread_called;
+
+
+static void getaddrinfo_do(struct getaddrinfo_req* req) {
+  int r;
+
+  r = uv_getaddrinfo(req->loop,
+                     &req->handle,
+                     getaddrinfo_cb,
+                     "localhost",
+                     NULL,
+                     NULL);
+  ASSERT(r == 0);
+}
+
+
+static void getaddrinfo_cb(uv_getaddrinfo_t* handle,
+                           int status,
+                           struct addrinfo* res) {
+  struct getaddrinfo_req* req;
+
+  ASSERT(status == 0);
+
+  req = container_of(handle, struct getaddrinfo_req, handle);
+  uv_freeaddrinfo(res);
+
+  if (--req->counter)
+    getaddrinfo_do(req);
+}
+
+
+static void fs_do(struct fs_req* req) {
+  int r;
+
+  r = uv_fs_stat(req->loop, &req->handle, ".", fs_cb);
+  ASSERT(r == 0);
+}
+
+
+static void fs_cb(uv_fs_t* handle) {
+  struct fs_req* req = container_of(handle, struct fs_req, handle);
+
+  uv_fs_req_cleanup(handle);
+
+  if (--req->counter)
+    fs_do(req);
+}
+
+
+static void do_work(void* arg) {
+  struct getaddrinfo_req getaddrinfo_reqs[16];
+  struct fs_req fs_reqs[16];
+  uv_loop_t* loop;
+  size_t i;
+  int r;
+  struct test_thread* thread = arg;
+
+  loop = uv_loop_new();
+  ASSERT(loop != NULL);
+
+  for (i = 0; i < ARRAY_SIZE(getaddrinfo_reqs); i++) {
+    struct getaddrinfo_req* req = getaddrinfo_reqs + i;
+    req->counter = 16;
+    req->loop = loop;
+    getaddrinfo_do(req);
+  }
+
+  for (i = 0; i < ARRAY_SIZE(fs_reqs); i++) {
+    struct fs_req* req = fs_reqs + i;
+    req->counter = 16;
+    req->loop = loop;
+    fs_do(req);
+  }
+
+  r = uv_run(loop, UV_RUN_DEFAULT);
+  ASSERT(r == 0);
+
+  uv_loop_delete(loop);
+  thread->thread_called = 1;
+}
+
+
+static void thread_entry(void* arg) {
+  ASSERT(arg == (void *) 42);
+  thread_called++;
+}
+
+
+TEST_IMPL(thread_create) {
+  uv_thread_t tid;
+  int r;
+
+  r = uv_thread_create(&tid, thread_entry, (void *) 42);
+  ASSERT(r == 0);
+
+  r = uv_thread_join(&tid);
+  ASSERT(r == 0);
+
+  ASSERT(thread_called == 1);
+
+  return 0;
+}
+
+
+/* Hilariously bad test name. Run a lot of tasks in the thread pool and verify
+ * that each "finished" callback is run in its originating thread.
+ */
+TEST_IMPL(threadpool_multiple_event_loops) {
+  struct test_thread threads[8];
+  size_t i;
+  int r;
+
+  memset(threads, 0, sizeof(threads));
+
+  for (i = 0; i < ARRAY_SIZE(threads); i++) {
+    r = uv_thread_create(&threads[i].thread_id, do_work, &threads[i]);
+    ASSERT(r == 0);
+  }
+
+  for (i = 0; i < ARRAY_SIZE(threads); i++) {
+    r = uv_thread_join(&threads[i].thread_id);
+    ASSERT(r == 0);
+    ASSERT(threads[i].thread_called);
+  }
+
+  return 0;
+}

data/deps/libuv/test/test-threadpool-cancel.c

@@ -0,0 +1,311 @@
+/* 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"
+
+#define INIT_CANCEL_INFO(ci, what)                                            \
+  do {                                                                        \
+    (ci)->reqs = (what);                                                      \
+    (ci)->nreqs = ARRAY_SIZE(what);                                           \
+    (ci)->stride = sizeof((what)[0]);                                         \
+  }                                                                           \
+  while (0)
+
+struct cancel_info {
+  void* reqs;
+  unsigned nreqs;
+  unsigned stride;
+  uv_timer_t timer_handle;
+};
+
+static uv_cond_t signal_cond;
+static uv_mutex_t signal_mutex;
+static uv_mutex_t wait_mutex;
+static unsigned num_threads;
+static unsigned fs_cb_called;
+static unsigned work_cb_called;
+static unsigned done_cb_called;
+static unsigned done2_cb_called;
+static unsigned timer_cb_called;
+static unsigned getaddrinfo_cb_called;
+
+
+static void work_cb(uv_work_t* req) {
+  uv_mutex_lock(&signal_mutex);
+  uv_cond_signal(&signal_cond);
+  uv_mutex_unlock(&signal_mutex);
+
+  uv_mutex_lock(&wait_mutex);
+  uv_mutex_unlock(&wait_mutex);
+
+  work_cb_called++;
+}
+
+
+static void done_cb(uv_work_t* req, int status) {
+  done_cb_called++;
+  free(req);
+}
+
+
+static void saturate_threadpool(void) {
+  uv_work_t* req;
+
+  ASSERT(0 == uv_cond_init(&signal_cond));
+  ASSERT(0 == uv_mutex_init(&signal_mutex));
+  ASSERT(0 == uv_mutex_init(&wait_mutex));
+
+  uv_mutex_lock(&signal_mutex);
+  uv_mutex_lock(&wait_mutex);
+
+  for (num_threads = 0; /* empty */; num_threads++) {
+    req = malloc(sizeof(*req));
+    ASSERT(req != NULL);
+    ASSERT(0 == uv_queue_work(uv_default_loop(), req, work_cb, done_cb));
+
+    /* Expect to get signalled within 350 ms, otherwise assume that
+     * the thread pool is saturated. As with any timing dependent test,
+     * this is obviously not ideal.
+     */
+    if (uv_cond_timedwait(&signal_cond, &signal_mutex, 350 * 1e6)) {
+      ASSERT(0 == uv_cancel((uv_req_t*) req));
+      break;
+    }
+  }
+}
+
+
+static void unblock_threadpool(void) {
+  uv_mutex_unlock(&signal_mutex);
+  uv_mutex_unlock(&wait_mutex);
+}
+
+
+static void cleanup_threadpool(void) {
+  ASSERT(done_cb_called == num_threads + 1);  /* +1 == cancelled work req. */
+  ASSERT(work_cb_called == num_threads);
+
+  uv_cond_destroy(&signal_cond);
+  uv_mutex_destroy(&signal_mutex);
+  uv_mutex_destroy(&wait_mutex);
+}
+
+
+static void fs_cb(uv_fs_t* req) {
+  ASSERT(req->errorno == UV_ECANCELED);
+  uv_fs_req_cleanup(req);
+  fs_cb_called++;
+}
+
+
+static void getaddrinfo_cb(uv_getaddrinfo_t* req,
+                           int status,
+                           struct addrinfo* res) {
+  ASSERT(UV_ECANCELED == uv_last_error(req->loop).code);
+  ASSERT(UV_ECANCELED == status);
+  getaddrinfo_cb_called++;
+}
+
+
+static void work2_cb(uv_work_t* req) {
+  ASSERT(0 && "work2_cb called");
+}
+
+
+static void done2_cb(uv_work_t* req, int status) {
+  ASSERT(uv_last_error(req->loop).code == UV_ECANCELED);
+  ASSERT(status == -1);
+  done2_cb_called++;
+}
+
+
+static void timer_cb(uv_timer_t* handle, int status) {
+  struct cancel_info* ci;
+  uv_req_t* req;
+  unsigned i;
+
+  ci = container_of(handle, struct cancel_info, timer_handle);
+
+  for (i = 0; i < ci->nreqs; i++) {
+    req = (uv_req_t*) ((char*) ci->reqs + i * ci->stride);
+    ASSERT(0 == uv_cancel(req));
+  }
+
+  uv_close((uv_handle_t*) &ci->timer_handle, NULL);
+  unblock_threadpool();
+  timer_cb_called++;
+}
+
+
+static void nop_work_cb(uv_work_t* req) {
+}
+
+
+static void nop_done_cb(uv_work_t* req, int status) {
+  req->data = "OK";
+}
+
+
+TEST_IMPL(threadpool_cancel_getaddrinfo) {
+  uv_getaddrinfo_t reqs[4];
+  struct cancel_info ci;
+  struct addrinfo hints;
+  uv_loop_t* loop;
+  int r;
+
+  INIT_CANCEL_INFO(&ci, reqs);
+  loop = uv_default_loop();
+  saturate_threadpool();
+
+  r = uv_getaddrinfo(loop, reqs + 0, getaddrinfo_cb, "fail", NULL, NULL);
+  ASSERT(r == 0);
+
+  r = uv_getaddrinfo(loop, reqs + 1, getaddrinfo_cb, NULL, "fail", NULL);
+  ASSERT(r == 0);
+
+  r = uv_getaddrinfo(loop, reqs + 2, getaddrinfo_cb, "fail", "fail", NULL);
+  ASSERT(r == 0);
+
+  r = uv_getaddrinfo(loop, reqs + 3, getaddrinfo_cb, "fail", NULL, &hints);
+  ASSERT(r == 0);
+
+  ASSERT(0 == uv_timer_init(loop, &ci.timer_handle));
+  ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
+  ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
+  ASSERT(1 == timer_cb_called);
+
+  cleanup_threadpool();
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+
+TEST_IMPL(threadpool_cancel_work) {
+  struct cancel_info ci;
+  uv_work_t reqs[16];
+  uv_loop_t* loop;
+  unsigned i;
+
+  INIT_CANCEL_INFO(&ci, reqs);
+  loop = uv_default_loop();
+  saturate_threadpool();
+
+  for (i = 0; i < ARRAY_SIZE(reqs); i++)
+    ASSERT(0 == uv_queue_work(loop, reqs + i, work2_cb, done2_cb));
+
+  ASSERT(0 == uv_timer_init(loop, &ci.timer_handle));
+  ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
+  ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
+  ASSERT(1 == timer_cb_called);
+  ASSERT(ARRAY_SIZE(reqs) == done2_cb_called);
+
+  cleanup_threadpool();
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+
+TEST_IMPL(threadpool_cancel_fs) {
+  struct cancel_info ci;
+  uv_fs_t reqs[25];
+  uv_loop_t* loop;
+  unsigned n;
+
+  INIT_CANCEL_INFO(&ci, reqs);
+  loop = uv_default_loop();
+  saturate_threadpool();
+
+  /* Needs to match ARRAY_SIZE(fs_reqs). */
+  n = 0;
+  ASSERT(0 == uv_fs_chmod(loop, reqs + n++, "/", 0, fs_cb));
+  ASSERT(0 == uv_fs_chown(loop, reqs + n++, "/", 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_close(loop, reqs + n++, 0, fs_cb));
+  ASSERT(0 == uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb));
+  ASSERT(0 == uv_fs_fstat(loop, reqs + n++, 0, fs_cb));
+  ASSERT(0 == uv_fs_fsync(loop, reqs + n++, 0, fs_cb));
+  ASSERT(0 == uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_link(loop, reqs + n++, "/", "/", fs_cb));
+  ASSERT(0 == uv_fs_lstat(loop, reqs + n++, "/", fs_cb));
+  ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));
+  ASSERT(0 == uv_fs_open(loop, reqs + n++, "/", 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_read(loop, reqs + n++, 0, NULL, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_readdir(loop, reqs + n++, "/", 0, fs_cb));
+  ASSERT(0 == uv_fs_readlink(loop, reqs + n++, "/", fs_cb));
+  ASSERT(0 == uv_fs_rename(loop, reqs + n++, "/", "/", fs_cb));
+  ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));
+  ASSERT(0 == uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_stat(loop, reqs + n++, "/", fs_cb));
+  ASSERT(0 == uv_fs_symlink(loop, reqs + n++, "/", "/", 0, fs_cb));
+  ASSERT(0 == uv_fs_unlink(loop, reqs + n++, "/", fs_cb));
+  ASSERT(0 == uv_fs_utime(loop, reqs + n++, "/", 0, 0, fs_cb));
+  ASSERT(0 == uv_fs_write(loop, reqs + n++, 0, NULL, 0, 0, fs_cb));
+  ASSERT(n == ARRAY_SIZE(reqs));
+
+  ASSERT(0 == uv_timer_init(loop, &ci.timer_handle));
+  ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
+  ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
+  ASSERT(n == fs_cb_called);
+  ASSERT(1 == timer_cb_called);
+
+  cleanup_threadpool();
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+
+TEST_IMPL(threadpool_cancel_single) {
+  uv_loop_t* loop;
+  uv_work_t req;
+  int cancelled;
+  int i;
+
+  loop = uv_default_loop();
+  for (i = 0; i < 5000; i++) {
+    req.data = NULL;
+    ASSERT(0 == uv_queue_work(loop, &req, nop_work_cb, nop_done_cb));
+
+    cancelled = uv_cancel((uv_req_t*) &req);
+    if (cancelled == 0)
+      break;
+
+    ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
+  }
+
+  if (cancelled != 0) {
+    fputs("Failed to cancel a work req in 5,000 iterations, giving up.\n",
+          stderr);
+    return 1;
+  }
+
+  ASSERT(req.data == NULL);
+  ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
+  ASSERT(req.data != NULL);  /* Should have been updated by nop_done_cb(). */
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}

data/deps/libuv/test/test-threadpool.c

@@ -0,0 +1,77 @@
+/* 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"
+
+static int work_cb_count;
+static int after_work_cb_count;
+static uv_work_t work_req;
+static char data;
+
+
+static void work_cb(uv_work_t* req) {
+  ASSERT(req == &work_req);
+  ASSERT(req->data == &data);
+  work_cb_count++;
+}
+
+
+static void after_work_cb(uv_work_t* req, int status) {
+  ASSERT(status == 0);
+  ASSERT(req == &work_req);
+  ASSERT(req->data == &data);
+  after_work_cb_count++;
+}
+
+
+TEST_IMPL(threadpool_queue_work_simple) {
+  int r;
+
+  work_req.data = &data;
+  r = uv_queue_work(uv_default_loop(), &work_req, work_cb, after_work_cb);
+  ASSERT(r == 0);
+  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+  ASSERT(work_cb_count == 1);
+  ASSERT(after_work_cb_count == 1);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}
+
+
+TEST_IMPL(threadpool_queue_work_einval) {
+  int r;
+
+  work_req.data = &data;
+  r = uv_queue_work(uv_default_loop(), &work_req, NULL, after_work_cb);
+  ASSERT(r == -1);
+
+  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
+
+  ASSERT(work_cb_count == 0);
+  ASSERT(after_work_cb_count == 0);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}

data/deps/libuv/test/test-timer-again.c

@@ -0,0 +1,142 @@
+/* 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"
+
+
+static int close_cb_called = 0;
+static int repeat_1_cb_called = 0;
+static int repeat_2_cb_called = 0;
+
+static int repeat_2_cb_allowed = 0;
+
+static uv_timer_t dummy, repeat_1, repeat_2;
+
+static uint64_t start_time;
+
+
+static void close_cb(uv_handle_t* handle) {
+  ASSERT(handle != NULL);
+
+  close_cb_called++;
+}
+
+
+static void repeat_1_cb(uv_timer_t* handle, int status) {
+  int r;
+
+  ASSERT(handle == &repeat_1);
+  ASSERT(status == 0);
+
+  ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);
+
+  LOGF("repeat_1_cb called after %ld ms\n",
+      (long int)(uv_now(uv_default_loop()) - start_time));
+
+  repeat_1_cb_called++;
+
+  r = uv_timer_again(&repeat_2);
+  ASSERT(r == 0);
+
+  if (uv_now(uv_default_loop()) >= start_time + 500) {
+    uv_close((uv_handle_t*)handle, close_cb);
+    /* We're not calling uv_timer_again on repeat_2 any more, so after this */
+    /* timer_2_cb is expected. */
+    repeat_2_cb_allowed = 1;
+    return;
+  }
+}
+
+
+static void repeat_2_cb(uv_timer_t* handle, int status) {
+  ASSERT(handle == &repeat_2);
+  ASSERT(status == 0);
+  ASSERT(repeat_2_cb_allowed);
+
+  LOGF("repeat_2_cb called after %ld ms\n",
+      (long int)(uv_now(uv_default_loop()) - start_time));
+
+  repeat_2_cb_called++;
+
+  if (uv_timer_get_repeat(&repeat_2) == 0) {
+    ASSERT(!uv_is_active((uv_handle_t*)handle));
+    uv_close((uv_handle_t*)handle, close_cb);
+    return;
+  }
+
+  LOGF("uv_timer_get_repeat %ld ms\n",
+      (long int)uv_timer_get_repeat(&repeat_2));
+  ASSERT(uv_timer_get_repeat(&repeat_2) == 100);
+
+  /* This shouldn't take effect immediately. */
+  uv_timer_set_repeat(&repeat_2, 0);
+}
+
+
+TEST_IMPL(timer_again) {
+  int r;
+
+  start_time = uv_now(uv_default_loop());
+  ASSERT(0 < start_time);
+
+  /* Verify that it is not possible to uv_timer_again a never-started timer. */
+  r = uv_timer_init(uv_default_loop(), &dummy);
+  ASSERT(r == 0);
+  r = uv_timer_again(&dummy);
+  ASSERT(r == -1);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
+  uv_unref((uv_handle_t*)&dummy);
+
+  /* Start timer repeat_1. */
+  r = uv_timer_init(uv_default_loop(), &repeat_1);
+  ASSERT(r == 0);
+  r = uv_timer_start(&repeat_1, repeat_1_cb, 50, 0);
+  ASSERT(r == 0);
+  ASSERT(uv_timer_get_repeat(&repeat_1) == 0);
+
+  /* Actually make repeat_1 repeating. */
+  uv_timer_set_repeat(&repeat_1, 50);
+  ASSERT(uv_timer_get_repeat(&repeat_1) == 50);
+
+  /*
+   * Start another repeating timer. It'll be again()ed by the repeat_1 so
+   * it should not time out until repeat_1 stops.
+   */
+  r = uv_timer_init(uv_default_loop(), &repeat_2);
+  ASSERT(r == 0);
+  r = uv_timer_start(&repeat_2, repeat_2_cb, 100, 100);
+  ASSERT(r == 0);
+  ASSERT(uv_timer_get_repeat(&repeat_2) == 100);
+
+  uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+
+  ASSERT(repeat_1_cb_called == 10);
+  ASSERT(repeat_2_cb_called == 2);
+  ASSERT(close_cb_called == 2);
+
+  LOGF("Test took %ld ms (expected ~700 ms)\n",
+       (long int)(uv_now(uv_default_loop()) - start_time));
+  ASSERT(700 <= uv_now(uv_default_loop()) - start_time);
+
+  MAKE_VALGRIND_HAPPY();
+  return 0;
+}