foolio 0.0.3

data/ext/libuv/test/test-list.h

@@ -0,0 +1,427 @@
+/* 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.
+ */
+
+TEST_DECLARE   (platform_output)
+TEST_DECLARE   (callback_order)
+TEST_DECLARE   (run_once)
+TEST_DECLARE   (semaphore_1)
+TEST_DECLARE   (semaphore_2)
+TEST_DECLARE   (semaphore_3)
+TEST_DECLARE   (tty)
+TEST_DECLARE   (stdio_over_pipes)
+TEST_DECLARE   (ipc_listen_before_write)
+TEST_DECLARE   (ipc_listen_after_write)
+#ifndef _WIN32
+TEST_DECLARE   (ipc_send_recv_pipe)
+#endif
+TEST_DECLARE   (ipc_send_recv_tcp)
+TEST_DECLARE   (ipc_tcp_connection)
+TEST_DECLARE   (tcp_ping_pong)
+TEST_DECLARE   (tcp_ping_pong_v6)
+TEST_DECLARE   (pipe_ping_pong)
+TEST_DECLARE   (delayed_accept)
+TEST_DECLARE   (multiple_listen)
+TEST_DECLARE   (tcp_writealot)
+TEST_DECLARE   (tcp_connect_error_after_write)
+TEST_DECLARE   (tcp_shutdown_after_write)
+TEST_DECLARE   (tcp_bind_error_addrinuse)
+TEST_DECLARE   (tcp_bind_error_addrnotavail_1)
+TEST_DECLARE   (tcp_bind_error_addrnotavail_2)
+TEST_DECLARE   (tcp_bind_error_fault)
+TEST_DECLARE   (tcp_bind_error_inval)
+TEST_DECLARE   (tcp_bind_localhost_ok)
+TEST_DECLARE   (tcp_listen_without_bind)
+TEST_DECLARE   (tcp_connect_error_fault)
+TEST_DECLARE   (tcp_connect_timeout)
+TEST_DECLARE   (tcp_close_while_connecting)
+TEST_DECLARE   (tcp_close)
+TEST_DECLARE   (tcp_flags)
+TEST_DECLARE   (tcp_write_error)
+TEST_DECLARE   (tcp_write_to_half_open_connection)
+TEST_DECLARE   (tcp_unexpected_read)
+TEST_DECLARE   (tcp_bind6_error_addrinuse)
+TEST_DECLARE   (tcp_bind6_error_addrnotavail)
+TEST_DECLARE   (tcp_bind6_error_fault)
+TEST_DECLARE   (tcp_bind6_error_inval)
+TEST_DECLARE   (tcp_bind6_localhost_ok)
+TEST_DECLARE   (udp_send_and_recv)
+TEST_DECLARE   (udp_multicast_join)
+TEST_DECLARE   (udp_multicast_ttl)
+TEST_DECLARE   (udp_dgram_too_big)
+TEST_DECLARE   (udp_dual_stack)
+TEST_DECLARE   (udp_ipv6_only)
+TEST_DECLARE   (udp_options)
+TEST_DECLARE   (pipe_bind_error_addrinuse)
+TEST_DECLARE   (pipe_bind_error_addrnotavail)
+TEST_DECLARE   (pipe_bind_error_inval)
+TEST_DECLARE   (pipe_listen_without_bind)
+TEST_DECLARE   (pipe_connect_bad_name)
+TEST_DECLARE   (pipe_connect_to_file)
+TEST_DECLARE   (connection_fail)
+TEST_DECLARE   (connection_fail_doesnt_auto_close)
+TEST_DECLARE   (shutdown_close_tcp)
+TEST_DECLARE   (shutdown_close_pipe)
+TEST_DECLARE   (shutdown_eof)
+TEST_DECLARE   (callback_stack)
+TEST_DECLARE   (error_message)
+TEST_DECLARE   (timer)
+TEST_DECLARE   (timer_again)
+TEST_DECLARE   (timer_start_twice)
+TEST_DECLARE   (idle_starvation)
+TEST_DECLARE   (loop_handles)
+TEST_DECLARE   (get_loadavg)
+TEST_DECLARE   (walk_handles)
+TEST_DECLARE   (ref)
+TEST_DECLARE   (idle_ref)
+TEST_DECLARE   (async_ref)
+TEST_DECLARE   (prepare_ref)
+TEST_DECLARE   (check_ref)
+TEST_DECLARE   (unref_in_prepare_cb)
+TEST_DECLARE   (timer_ref)
+TEST_DECLARE   (timer_ref2)
+TEST_DECLARE   (fs_event_ref)
+TEST_DECLARE   (fs_poll_ref)
+TEST_DECLARE   (tcp_ref)
+TEST_DECLARE   (tcp_ref2)
+TEST_DECLARE   (tcp_ref3)
+TEST_DECLARE   (tcp_ref4)
+TEST_DECLARE   (udp_ref)
+TEST_DECLARE   (udp_ref2)
+TEST_DECLARE   (udp_ref3)
+TEST_DECLARE   (pipe_ref)
+TEST_DECLARE   (pipe_ref2)
+TEST_DECLARE   (pipe_ref3)
+TEST_DECLARE   (pipe_ref4)
+TEST_DECLARE   (process_ref)
+TEST_DECLARE   (async)
+TEST_DECLARE   (get_currentexe)
+TEST_DECLARE   (process_title)
+TEST_DECLARE   (cwd_and_chdir)
+TEST_DECLARE   (get_memory)
+TEST_DECLARE   (hrtime)
+TEST_DECLARE   (getaddrinfo_basic)
+TEST_DECLARE   (getaddrinfo_concurrent)
+TEST_DECLARE   (getsockname_tcp)
+TEST_DECLARE   (getsockname_udp)
+TEST_DECLARE   (fail_always)
+TEST_DECLARE   (pass_always)
+TEST_DECLARE   (spawn_fails)
+TEST_DECLARE   (spawn_exit_code)
+TEST_DECLARE   (spawn_stdout)
+TEST_DECLARE   (spawn_stdin)
+TEST_DECLARE   (spawn_stdio_greater_than_3)
+TEST_DECLARE   (spawn_ignored_stdio)
+TEST_DECLARE   (spawn_and_kill)
+TEST_DECLARE   (spawn_detached)
+TEST_DECLARE   (spawn_and_kill_with_std)
+TEST_DECLARE   (spawn_and_ping)
+TEST_DECLARE   (spawn_setuid_fails)
+TEST_DECLARE   (spawn_setgid_fails)
+TEST_DECLARE   (spawn_stdout_to_file)
+TEST_DECLARE   (fs_poll)
+TEST_DECLARE   (kill)
+TEST_DECLARE   (fs_file_noent)
+TEST_DECLARE   (fs_file_nametoolong)
+TEST_DECLARE   (fs_file_loop)
+TEST_DECLARE   (fs_file_async)
+TEST_DECLARE   (fs_file_sync)
+TEST_DECLARE   (fs_async_dir)
+TEST_DECLARE   (fs_async_sendfile)
+TEST_DECLARE   (fs_fstat)
+TEST_DECLARE   (fs_chmod)
+TEST_DECLARE   (fs_chown)
+TEST_DECLARE   (fs_link)
+TEST_DECLARE   (fs_symlink)
+TEST_DECLARE   (fs_symlink_dir)
+TEST_DECLARE   (fs_utime)
+TEST_DECLARE   (fs_futime)
+TEST_DECLARE   (fs_file_open_append)
+TEST_DECLARE   (fs_stat_missing_path)
+TEST_DECLARE   (fs_read_file_eof)
+TEST_DECLARE   (fs_event_watch_dir)
+TEST_DECLARE   (fs_event_watch_file)
+TEST_DECLARE   (fs_event_watch_file_twice)
+TEST_DECLARE   (fs_event_watch_file_current_dir)
+TEST_DECLARE   (fs_event_no_callback_on_close)
+TEST_DECLARE   (fs_event_immediate_close)
+TEST_DECLARE   (fs_event_close_with_pending_event)
+TEST_DECLARE   (fs_event_close_in_callback)
+TEST_DECLARE   (fs_readdir_empty_dir)
+TEST_DECLARE   (fs_readdir_file)
+TEST_DECLARE   (fs_open_dir)
+TEST_DECLARE   (fs_rename_to_existing_file)
+TEST_DECLARE   (threadpool_queue_work_simple)
+TEST_DECLARE   (threadpool_multiple_event_loops)
+TEST_DECLARE   (thread_mutex)
+TEST_DECLARE   (thread_rwlock)
+TEST_DECLARE   (thread_create)
+TEST_DECLARE   (strlcpy)
+TEST_DECLARE   (strlcat)
+TEST_DECLARE   (dlerror)
+TEST_DECLARE   (poll_duplex)
+TEST_DECLARE   (poll_unidirectional)
+TEST_DECLARE   (poll_close)
+TEST_DECLARE   (we_get_signal)
+TEST_DECLARE   (we_get_signals)
+#ifdef _WIN32
+TEST_DECLARE   (spawn_detect_pipe_name_collisions_on_windows)
+TEST_DECLARE   (argument_escaping)
+TEST_DECLARE   (environment_creation)
+TEST_DECLARE   (listen_with_simultaneous_accepts)
+TEST_DECLARE   (listen_no_simultaneous_accepts)
+TEST_DECLARE   (fs_stat_root)
+#else
+TEST_DECLARE   (spawn_setuid_setgid)
+#endif
+HELPER_DECLARE (tcp4_echo_server)
+HELPER_DECLARE (tcp6_echo_server)
+HELPER_DECLARE (udp4_echo_server)
+HELPER_DECLARE (pipe_echo_server)
+
+
+TASK_LIST_START
+  TEST_OUTPUT_ENTRY  (platform_output)
+
+#if 0
+  TEST_ENTRY  (callback_order)
+#endif
+  TEST_ENTRY  (run_once)
+  TEST_ENTRY  (semaphore_1)
+  TEST_ENTRY  (semaphore_2)
+  TEST_ENTRY  (semaphore_3)
+
+  TEST_ENTRY  (pipe_connect_bad_name)
+  TEST_ENTRY  (pipe_connect_to_file)
+
+  TEST_ENTRY  (tty)
+  TEST_ENTRY  (stdio_over_pipes)
+  TEST_ENTRY  (ipc_listen_before_write)
+  TEST_ENTRY  (ipc_listen_after_write)
+#ifndef _WIN32
+  TEST_ENTRY  (ipc_send_recv_pipe)
+#endif
+  TEST_ENTRY  (ipc_send_recv_tcp)
+  TEST_ENTRY  (ipc_tcp_connection)
+
+  TEST_ENTRY  (tcp_ping_pong)
+  TEST_HELPER (tcp_ping_pong, tcp4_echo_server)
+
+  TEST_ENTRY  (tcp_ping_pong_v6)
+  TEST_HELPER (tcp_ping_pong_v6, tcp6_echo_server)
+
+  TEST_ENTRY  (pipe_ping_pong)
+  TEST_HELPER (pipe_ping_pong, pipe_echo_server)
+
+  TEST_ENTRY  (delayed_accept)
+  TEST_ENTRY  (multiple_listen)
+
+  TEST_ENTRY  (tcp_writealot)
+  TEST_HELPER (tcp_writealot, tcp4_echo_server)
+
+  TEST_ENTRY  (tcp_shutdown_after_write)
+  TEST_HELPER (tcp_shutdown_after_write, tcp4_echo_server)
+
+  TEST_ENTRY  (tcp_connect_error_after_write)
+  TEST_ENTRY  (tcp_bind_error_addrinuse)
+  TEST_ENTRY  (tcp_bind_error_addrnotavail_1)
+  TEST_ENTRY  (tcp_bind_error_addrnotavail_2)
+  TEST_ENTRY  (tcp_bind_error_fault)
+  TEST_ENTRY  (tcp_bind_error_inval)
+  TEST_ENTRY  (tcp_bind_localhost_ok)
+  TEST_ENTRY  (tcp_listen_without_bind)
+  TEST_ENTRY  (tcp_connect_error_fault)
+  TEST_ENTRY  (tcp_connect_timeout)
+  TEST_ENTRY  (tcp_close_while_connecting)
+  TEST_ENTRY  (tcp_close)
+  TEST_ENTRY  (tcp_flags)
+  TEST_ENTRY  (tcp_write_error)
+  TEST_ENTRY  (tcp_write_to_half_open_connection)
+  TEST_ENTRY  (tcp_unexpected_read)
+
+  TEST_ENTRY  (tcp_bind6_error_addrinuse)
+  TEST_ENTRY  (tcp_bind6_error_addrnotavail)
+  TEST_ENTRY  (tcp_bind6_error_fault)
+  TEST_ENTRY  (tcp_bind6_error_inval)
+  TEST_ENTRY  (tcp_bind6_localhost_ok)
+
+  TEST_ENTRY  (udp_send_and_recv)
+  TEST_ENTRY  (udp_dgram_too_big)
+  TEST_ENTRY  (udp_dual_stack)
+  TEST_ENTRY  (udp_ipv6_only)
+  TEST_ENTRY  (udp_options)
+  TEST_ENTRY  (udp_multicast_join)
+  TEST_ENTRY  (udp_multicast_ttl)
+
+  TEST_ENTRY  (pipe_bind_error_addrinuse)
+  TEST_ENTRY  (pipe_bind_error_addrnotavail)
+  TEST_ENTRY  (pipe_bind_error_inval)
+  TEST_ENTRY  (pipe_listen_without_bind)
+
+  TEST_ENTRY  (connection_fail)
+  TEST_ENTRY  (connection_fail_doesnt_auto_close)
+
+  TEST_ENTRY  (shutdown_close_tcp)
+  TEST_HELPER (shutdown_close_tcp, tcp4_echo_server)
+  TEST_ENTRY  (shutdown_close_pipe)
+  TEST_HELPER (shutdown_close_pipe, pipe_echo_server)
+
+  TEST_ENTRY  (shutdown_eof)
+  TEST_HELPER (shutdown_eof, tcp4_echo_server)
+
+  TEST_ENTRY  (callback_stack)
+  TEST_HELPER (callback_stack, tcp4_echo_server)
+
+  TEST_ENTRY  (error_message)
+
+  TEST_ENTRY  (timer)
+  TEST_ENTRY  (timer_again)
+  TEST_ENTRY  (timer_start_twice)
+
+  TEST_ENTRY  (idle_starvation)
+
+  TEST_ENTRY  (ref)
+  TEST_ENTRY  (idle_ref)
+  TEST_ENTRY  (fs_poll_ref)
+  TEST_ENTRY  (async_ref)
+  TEST_ENTRY  (prepare_ref)
+  TEST_ENTRY  (check_ref)
+  TEST_ENTRY  (unref_in_prepare_cb)
+  TEST_ENTRY  (timer_ref)
+  TEST_ENTRY  (timer_ref2)
+  TEST_ENTRY  (fs_event_ref)
+  TEST_ENTRY  (tcp_ref)
+  TEST_ENTRY  (tcp_ref2)
+  TEST_ENTRY  (tcp_ref3)
+  TEST_HELPER (tcp_ref3, tcp4_echo_server)
+  TEST_ENTRY  (tcp_ref4)
+  TEST_HELPER (tcp_ref4, tcp4_echo_server)
+  TEST_ENTRY  (udp_ref)
+  TEST_ENTRY  (udp_ref2)
+  TEST_ENTRY  (udp_ref3)
+  TEST_HELPER (udp_ref3, udp4_echo_server)
+  TEST_ENTRY  (pipe_ref)
+  TEST_ENTRY  (pipe_ref2)
+  TEST_ENTRY  (pipe_ref3)
+  TEST_HELPER (pipe_ref3, pipe_echo_server)
+  TEST_ENTRY  (pipe_ref4)
+  TEST_HELPER (pipe_ref4, pipe_echo_server)
+  TEST_ENTRY  (process_ref)
+
+  TEST_ENTRY  (loop_handles)
+  TEST_ENTRY  (walk_handles)
+
+  TEST_ENTRY  (async)
+
+  TEST_ENTRY  (get_currentexe)
+
+  TEST_ENTRY  (process_title)
+
+  TEST_ENTRY  (cwd_and_chdir)
+
+  TEST_ENTRY  (get_memory)
+
+  TEST_ENTRY  (get_loadavg)
+
+  TEST_ENTRY  (hrtime)
+
+  TEST_ENTRY  (getaddrinfo_basic)
+  TEST_ENTRY  (getaddrinfo_concurrent)
+
+  TEST_ENTRY  (getsockname_tcp)
+  TEST_ENTRY  (getsockname_udp)
+
+  TEST_ENTRY  (poll_duplex)
+  TEST_ENTRY  (poll_unidirectional)
+  TEST_ENTRY  (poll_close)
+
+  TEST_ENTRY  (spawn_fails)
+  TEST_ENTRY  (spawn_exit_code)
+  TEST_ENTRY  (spawn_stdout)
+  TEST_ENTRY  (spawn_stdin)
+  TEST_ENTRY  (spawn_stdio_greater_than_3)
+  TEST_ENTRY  (spawn_ignored_stdio)
+  TEST_ENTRY  (spawn_and_kill)
+  TEST_ENTRY  (spawn_detached)
+  TEST_ENTRY  (spawn_and_kill_with_std)
+  TEST_ENTRY  (spawn_and_ping)
+  TEST_ENTRY  (spawn_setuid_fails)
+  TEST_ENTRY  (spawn_setgid_fails)
+  TEST_ENTRY  (spawn_stdout_to_file)
+  TEST_ENTRY  (fs_poll)
+  TEST_ENTRY  (kill)
+
+  TEST_ENTRY  (we_get_signal)
+  TEST_ENTRY  (we_get_signals)
+
+#ifdef _WIN32
+  TEST_ENTRY  (spawn_detect_pipe_name_collisions_on_windows)
+  TEST_ENTRY  (argument_escaping)
+  TEST_ENTRY  (environment_creation)
+  TEST_ENTRY  (listen_with_simultaneous_accepts)
+  TEST_ENTRY  (listen_no_simultaneous_accepts)
+  TEST_ENTRY  (fs_stat_root)
+#else
+  TEST_ENTRY  (spawn_setuid_setgid)
+#endif
+
+  TEST_ENTRY  (fs_file_noent)
+  TEST_ENTRY  (fs_file_nametoolong)
+  TEST_ENTRY  (fs_file_loop)
+  TEST_ENTRY  (fs_file_async)
+  TEST_ENTRY  (fs_file_sync)
+  TEST_ENTRY  (fs_async_dir)
+  TEST_ENTRY  (fs_async_sendfile)
+  TEST_ENTRY  (fs_fstat)
+  TEST_ENTRY  (fs_chmod)
+  TEST_ENTRY  (fs_chown)
+  TEST_ENTRY  (fs_utime)
+  TEST_ENTRY  (fs_futime)
+  TEST_ENTRY  (fs_symlink)
+  TEST_ENTRY  (fs_symlink_dir)
+  TEST_ENTRY  (fs_stat_missing_path)
+  TEST_ENTRY  (fs_read_file_eof)
+  TEST_ENTRY  (fs_file_open_append)
+  TEST_ENTRY  (fs_event_watch_dir)
+  TEST_ENTRY  (fs_event_watch_file)
+  TEST_ENTRY  (fs_event_watch_file_twice)
+  TEST_ENTRY  (fs_event_watch_file_current_dir)
+  TEST_ENTRY  (fs_event_no_callback_on_close)
+  TEST_ENTRY  (fs_event_immediate_close)
+  TEST_ENTRY  (fs_event_close_with_pending_event)
+  TEST_ENTRY  (fs_event_close_in_callback)
+  TEST_ENTRY  (fs_readdir_empty_dir)
+  TEST_ENTRY  (fs_readdir_file)
+  TEST_ENTRY  (fs_open_dir)
+  TEST_ENTRY  (fs_rename_to_existing_file)
+  TEST_ENTRY  (threadpool_queue_work_simple)
+  TEST_ENTRY  (threadpool_multiple_event_loops)
+  TEST_ENTRY  (thread_mutex)
+  TEST_ENTRY  (thread_rwlock)
+  TEST_ENTRY  (thread_create)
+  TEST_ENTRY  (strlcpy)
+  TEST_ENTRY  (strlcat)
+  TEST_ENTRY  (dlerror)
+#if 0
+  /* These are for testing the test runner. */
+  TEST_ENTRY  (fail_always)
+  TEST_ENTRY  (pass_always)
+#endif
+TASK_LIST_END

data/ext/libuv/test/test-loop-handles.c

@@ -0,0 +1,336 @@
+/* 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.
+ */
+
+/* Tests commented out with XXX are ones that are failing on Linux */
+
+/*
+ * Purpose of this test is to check semantics of starting and stopping
+ * prepare, check and idle watchers.
+ *
+ * - A watcher must be able to safely stop or close itself;
+ * - Once a watcher is stopped or closed its callback should never be called.
+ * - If a watcher is closed, it is implicitly stopped and its close_cb should
+ *   be called exactly once.
+ * - A watcher can safely start and stop other watchers of the same type.
+ * - Prepare and check watchers are called once per event loop iterations.
+ * - All active idle watchers are queued when the event loop has no more work
+ *   to do. This is done repeatedly until all idle watchers are inactive.
+ * - If a watcher starts another watcher of the same type its callback is not
+ *   immediately queued. For check and prepare watchers, that means that if
+ *   a watcher makes another of the same type active, it'll not be called until
+ *   the next event loop iteration. For idle. watchers this means that the
+ *   newly activated idle watcher might not be queued immediately.
+ * - Prepare, check, idle watchers keep the event loop alive even when they're
+ *   not active.
+ *
+ * This is what the test globally does:
+ *
+ * - prepare_1 is always active and counts event loop iterations. It also
+ *   creates and starts prepare_2 every other iteration. Finally it verifies
+ *   that no idle watchers are active before polling.
+ * - prepare_2 is started by prepare_1 every other iteration. It immediately
+ *   stops itself. It verifies that a watcher is not queued immediately
+ *   if created by another watcher of the same type.
+ * - There's a check watcher that stops the event loop after a certain number
+ *   of iterations. It starts a varying number of idle_1 watchers.
+ * - Idle_1 watchers stop themselves after being called a few times. All idle_1
+ *   watchers try to start the idle_2 watcher if it is not already started or
+ *   awaiting its close callback.
+ * - The idle_2 watcher always exists but immediately closes itself after
+ *   being started by a check_1 watcher. It verifies that a watcher is
+ *   implicitly stopped when closed, and that a watcher can close itself
+ *   safely.
+ * - There is a repeating timer. It does not keep the event loop alive
+ *   (ev_unref) but makes sure that the loop keeps polling the system for
+ *   events.
+ */
+
+
+#include "uv.h"
+#include "task.h"
+
+#include <math.h>
+
+
+#define IDLE_COUNT      7
+#define ITERATIONS      21
+#define TIMEOUT         100
+
+
+static uv_prepare_t prepare_1_handle;
+static uv_prepare_t prepare_2_handle;
+
+static uv_check_t check_handle;
+
+static uv_idle_t idle_1_handles[IDLE_COUNT];
+static uv_idle_t idle_2_handle;
+
+static uv_timer_t timer_handle;
+
+
+static int loop_iteration = 0;
+
+static int prepare_1_cb_called = 0;
+static int prepare_1_close_cb_called = 0;
+
+static int prepare_2_cb_called = 0;
+static int prepare_2_close_cb_called = 0;
+
+static int check_cb_called = 0;
+static int check_close_cb_called = 0;
+
+static int idle_1_cb_called = 0;
+static int idle_1_close_cb_called = 0;
+static int idles_1_active = 0;
+
+static int idle_2_cb_called = 0;
+static int idle_2_close_cb_called = 0;
+static int idle_2_cb_started = 0;
+static int idle_2_is_active = 0;
+
+
+static void timer_cb(uv_timer_t* handle, int status) {
+  ASSERT(handle == &timer_handle);
+  ASSERT(status == 0);
+}
+
+
+static void idle_2_close_cb(uv_handle_t* handle) {
+  LOG("IDLE_2_CLOSE_CB\n");
+
+  ASSERT(handle == (uv_handle_t*)&idle_2_handle);
+
+  ASSERT(idle_2_is_active);
+
+  idle_2_close_cb_called++;
+  idle_2_is_active = 0;
+}
+
+
+static void idle_2_cb(uv_idle_t* handle, int status) {
+  LOG("IDLE_2_CB\n");
+
+  ASSERT(handle == &idle_2_handle);
+  ASSERT(status == 0);
+
+  idle_2_cb_called++;
+
+  uv_close((uv_handle_t*)handle, idle_2_close_cb);
+}
+
+
+static void idle_1_cb(uv_idle_t* handle, int status) {
+  int r;
+
+  LOG("IDLE_1_CB\n");
+
+  ASSERT(handle != NULL);
+  ASSERT(status == 0);
+
+  ASSERT(idles_1_active > 0);
+
+  /* Init idle_2 and make it active */
+  if (!idle_2_is_active && !uv_is_closing((uv_handle_t*)&idle_2_handle)) {
+    r = uv_idle_init(uv_default_loop(), &idle_2_handle);
+    ASSERT(r == 0);
+    r = uv_idle_start(&idle_2_handle, idle_2_cb);
+    ASSERT(r == 0);
+    idle_2_is_active = 1;
+    idle_2_cb_started++;
+  }
+
+  idle_1_cb_called++;
+
+  if (idle_1_cb_called % 5 == 0) {
+    r = uv_idle_stop((uv_idle_t*)handle);
+    ASSERT(r == 0);
+    idles_1_active--;
+  }
+}
+
+
+static void idle_1_close_cb(uv_handle_t* handle) {
+  LOG("IDLE_1_CLOSE_CB\n");
+
+  ASSERT(handle != NULL);
+
+  idle_1_close_cb_called++;
+}
+
+
+static void prepare_1_close_cb(uv_handle_t* handle) {
+  LOG("PREPARE_1_CLOSE_CB");
+  ASSERT(handle == (uv_handle_t*)&prepare_1_handle);
+
+  prepare_1_close_cb_called++;
+}
+
+
+static void check_close_cb(uv_handle_t* handle) {
+  LOG("CHECK_CLOSE_CB\n");
+  ASSERT(handle == (uv_handle_t*)&check_handle);
+
+  check_close_cb_called++;
+}
+
+
+static void prepare_2_close_cb(uv_handle_t* handle) {
+  LOG("PREPARE_2_CLOSE_CB\n");
+  ASSERT(handle == (uv_handle_t*)&prepare_2_handle);
+
+  prepare_2_close_cb_called++;
+}
+
+
+static void check_cb(uv_check_t* handle, int status) {
+  int i, r;
+
+  LOG("CHECK_CB\n");
+
+  ASSERT(handle == &check_handle);
+  ASSERT(status == 0);
+
+  if (loop_iteration < ITERATIONS) {
+    /* Make some idle watchers active */
+    for (i = 0; i < 1 + (loop_iteration % IDLE_COUNT); i++) {
+      r = uv_idle_start(&idle_1_handles[i], idle_1_cb);
+      ASSERT(r == 0);
+      idles_1_active++;
+    }
+
+  } else {
+    /* End of the test - close all handles */
+    uv_close((uv_handle_t*)&prepare_1_handle, prepare_1_close_cb);
+    uv_close((uv_handle_t*)&check_handle, check_close_cb);
+    uv_close((uv_handle_t*)&prepare_2_handle, prepare_2_close_cb);
+
+    for (i = 0; i < IDLE_COUNT; i++) {
+      uv_close((uv_handle_t*)&idle_1_handles[i], idle_1_close_cb);
+    }
+
+    /* This handle is closed/recreated every time, close it only if it is */
+    /* active.*/
+    if (idle_2_is_active) {
+      uv_close((uv_handle_t*)&idle_2_handle, idle_2_close_cb);
+    }
+  }
+
+  check_cb_called++;
+}
+
+
+static void prepare_2_cb(uv_prepare_t* handle, int status) {
+  int r;
+
+  LOG("PREPARE_2_CB\n");
+
+  ASSERT(handle == &prepare_2_handle);
+  ASSERT(status == 0);
+
+  /* prepare_2 gets started by prepare_1 when (loop_iteration % 2 == 0), */
+  /* and it stops itself immediately. A started watcher is not queued */
+  /* until the next round, so when this callback is made */
+  /* (loop_iteration % 2 == 0) cannot be true. */
+  ASSERT(loop_iteration % 2 != 0);
+
+  r = uv_prepare_stop((uv_prepare_t*)handle);
+  ASSERT(r == 0);
+
+  prepare_2_cb_called++;
+}
+
+
+static void prepare_1_cb(uv_prepare_t* handle, int status) {
+  int r;
+
+  LOG("PREPARE_1_CB\n");
+
+  ASSERT(handle == &prepare_1_handle);
+  ASSERT(status == 0);
+
+  if (loop_iteration % 2 == 0) {
+    r = uv_prepare_start(&prepare_2_handle, prepare_2_cb);
+    ASSERT(r == 0);
+  }
+
+  prepare_1_cb_called++;
+  loop_iteration++;
+
+  printf("Loop iteration %d of %d.\n", loop_iteration, ITERATIONS);
+}
+
+
+TEST_IMPL(loop_handles) {
+  int i;
+  int r;
+
+  r = uv_prepare_init(uv_default_loop(), &prepare_1_handle);
+  ASSERT(r == 0);
+  r = uv_prepare_start(&prepare_1_handle, prepare_1_cb);
+  ASSERT(r == 0);
+
+  r = uv_check_init(uv_default_loop(), &check_handle);
+  ASSERT(r == 0);
+  r = uv_check_start(&check_handle, check_cb);
+  ASSERT(r == 0);
+
+  /* initialize only, prepare_2 is started by prepare_1_cb */
+  r = uv_prepare_init(uv_default_loop(), &prepare_2_handle);
+  ASSERT(r == 0);
+
+  for (i = 0; i < IDLE_COUNT; i++) {
+    /* initialize only, idle_1 handles are started by check_cb */
+    r = uv_idle_init(uv_default_loop(), &idle_1_handles[i]);
+    ASSERT(r == 0);
+  }
+
+  /* don't init or start idle_2, both is done by idle_1_cb */
+
+  /* the timer callback is there to keep the event loop polling */
+  /* unref it as it is not supposed to keep the loop alive */
+  r = uv_timer_init(uv_default_loop(), &timer_handle);
+  ASSERT(r == 0);
+  r = uv_timer_start(&timer_handle, timer_cb, TIMEOUT, TIMEOUT);
+  ASSERT(r == 0);
+  uv_unref((uv_handle_t*)&timer_handle);
+
+  r = uv_run(uv_default_loop());
+  ASSERT(r == 0);
+
+  ASSERT(loop_iteration == ITERATIONS);
+
+  ASSERT(prepare_1_cb_called == ITERATIONS);
+  ASSERT(prepare_1_close_cb_called == 1);
+
+  ASSERT(prepare_2_cb_called == floor(ITERATIONS / 2.0));
+  ASSERT(prepare_2_close_cb_called == 1);
+
+  ASSERT(check_cb_called == ITERATIONS);
+  ASSERT(check_close_cb_called == 1);
+
+  /* idle_1_cb should be called a lot */
+  ASSERT(idle_1_close_cb_called == IDLE_COUNT);
+
+  ASSERT(idle_2_close_cb_called == idle_2_cb_started);
+  ASSERT(idle_2_is_active == 0);
+
+  return 0;
+}