foolio 0.0.3

data/ext/libuv/test/test-pipe-connect-error.c

@@ -0,0 +1,96 @@
+/* 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>
+
+
+#ifdef _WIN32
+# define BAD_PIPENAME "bad-pipe"
+#else
+# define BAD_PIPENAME "/path/to/unix/socket/that/really/should/not/be/there"
+#endif
+
+
+static int close_cb_called = 0;
+static int connect_cb_called = 0;
+
+
+static void close_cb(uv_handle_t* handle) {
+  ASSERT(handle != NULL);
+  close_cb_called++;
+}
+
+
+static void connect_cb(uv_connect_t* connect_req, int status) {
+  ASSERT(status == -1);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_ENOENT);
+  uv_close((uv_handle_t*)connect_req->handle, close_cb);
+  connect_cb_called++;
+}
+
+
+static void connect_cb_file(uv_connect_t* connect_req, int status) {
+  ASSERT(status == -1);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_ENOTSOCK ||
+         uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);
+  uv_close((uv_handle_t*)connect_req->handle, close_cb);
+  connect_cb_called++;
+}
+
+
+TEST_IMPL(pipe_connect_bad_name) {
+  uv_pipe_t client;
+  uv_connect_t req;
+  int r;
+
+  r = uv_pipe_init(uv_default_loop(), &client, 0);
+  ASSERT(r == 0);
+  uv_pipe_connect(&req, &client, BAD_PIPENAME, connect_cb);
+
+  uv_run(uv_default_loop());
+
+  ASSERT(close_cb_called == 1);
+  ASSERT(connect_cb_called == 1);
+
+  return 0;
+}
+
+
+TEST_IMPL(pipe_connect_to_file) {
+  const char* path = "test/fixtures/empty_file";
+  uv_pipe_t client;
+  uv_connect_t req;
+  int r;
+
+  r = uv_pipe_init(uv_default_loop(), &client, 0);
+  ASSERT(r == 0);
+  uv_pipe_connect(&req, &client, path, connect_cb_file);
+
+  uv_run(uv_default_loop());
+
+  ASSERT(close_cb_called == 1);
+  ASSERT(connect_cb_called == 1);
+
+  return 0;
+}

data/ext/libuv/test/test-platform-output.c

@@ -0,0 +1,87 @@
+/* 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 <string.h>
+
+
+TEST_IMPL(platform_output) {
+  char buffer[512];
+  size_t rss;
+  double uptime;
+  uv_cpu_info_t* cpus;
+  uv_interface_address_t* interfaces;
+  int count;
+  int i;
+  uv_err_t err;
+
+  err = uv_get_process_title(buffer, sizeof(buffer));
+  ASSERT(UV_OK == err.code);
+  printf("uv_get_process_title: %s\n", buffer);
+
+  err = uv_resident_set_memory(&rss);
+  ASSERT(UV_OK == err.code);
+  printf("uv_resident_set_memory: %llu\n", (unsigned long long) rss);
+
+  err = uv_uptime(&uptime);
+  ASSERT(UV_OK == err.code);
+  ASSERT(uptime > 0);
+  printf("uv_uptime: %f\n", uptime);
+
+  err = uv_cpu_info(&cpus, &count);
+  ASSERT(UV_OK == err.code);
+
+  printf("uv_cpu_info:\n");
+  for (i = 0; i < count; i++) {
+    printf("  model: %s\n", cpus[i].model);
+    printf("  speed: %d\n", cpus[i].speed);
+    printf("  times.sys: %llu\n", (unsigned long long) cpus[i].cpu_times.sys);
+    printf("  times.user: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.user);
+    printf("  times.idle: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.idle);
+    printf("  times.irq: %llu\n",  (unsigned long long) cpus[i].cpu_times.irq);
+    printf("  times.nice: %llu\n",
+           (unsigned long long) cpus[i].cpu_times.nice);
+  }
+  uv_free_cpu_info(cpus, count);
+
+  err = uv_interface_addresses(&interfaces, &count);
+  ASSERT(UV_OK == err.code);
+
+  printf("uv_interface_addresses:\n");
+  for (i = 0; i < count; i++) {
+    printf("  name: %s\n", interfaces[i].name);
+    printf("  internal: %d\n", interfaces[i].is_internal);
+
+    if (interfaces[i].address.address4.sin_family == AF_INET) {
+      uv_ip4_name(&interfaces[i].address.address4, buffer, sizeof(buffer));
+    } else if (interfaces[i].address.address4.sin_family == AF_INET6) {
+      uv_ip6_name(&interfaces[i].address.address6, buffer, sizeof(buffer));
+    }
+
+    printf("  address: %s\n", buffer);
+  }
+  uv_free_interface_addresses(interfaces, count);
+
+  return 0;
+}

data/ext/libuv/test/test-poll-close.c

@@ -0,0 +1,72 @@
+/* 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 <errno.h>
+
+#ifndef _WIN32
+# include <fcntl.h>
+# include <sys/socket.h>
+# include <unistd.h>
+#endif
+
+#include "uv.h"
+#include "task.h"
+
+#define NUM_SOCKETS 64
+
+
+static int close_cb_called = 0;
+
+
+static void close_cb(uv_handle_t* handle) {
+  close_cb_called++;
+}
+
+
+TEST_IMPL(poll_close) {
+  uv_os_sock_t sockets[NUM_SOCKETS];
+  uv_poll_t poll_handles[NUM_SOCKETS];
+  int i;
+
+#ifdef _WIN32
+  {
+    struct WSAData wsa_data;
+    int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+    ASSERT(r == 0);
+  }
+#endif
+
+  for (i = 0; i < NUM_SOCKETS; i++) {
+    sockets[i] = socket(AF_INET, SOCK_STREAM, 0);
+    uv_poll_init_socket(uv_default_loop(), &poll_handles[i], sockets[i]);
+    uv_poll_start(&poll_handles[i], UV_READABLE | UV_WRITABLE, NULL);
+  }
+  
+  for (i = 0; i < NUM_SOCKETS; i++) {
+    uv_close((uv_handle_t*) &poll_handles[i], close_cb);
+  }
+
+  uv_run(uv_default_loop());
+
+  ASSERT(close_cb_called == NUM_SOCKETS);
+
+  return 0;
+}

data/ext/libuv/test/test-poll.c

@@ -0,0 +1,573 @@
+/* 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 <errno.h>
+
+#ifndef _WIN32
+# include <fcntl.h>
+# include <sys/socket.h>
+# include <unistd.h>
+#endif
+
+#include "uv.h"
+#include "task.h"
+
+
+#define NUM_CLIENTS 5
+#define TRANSFER_BYTES (1 << 16)
+
+#undef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b));
+
+
+typedef enum {
+  UNIDIRECTIONAL,
+  DUPLEX
+} test_mode_t;
+
+typedef struct connection_context_s {
+  uv_poll_t poll_handle;
+  uv_timer_t timer_handle;
+  uv_os_sock_t sock;
+  size_t read, sent;
+  int is_server_connection;
+  int open_handles;
+  int got_fin, sent_fin;
+  unsigned int events, delayed_events;
+} connection_context_t;
+
+typedef struct server_context_s {
+  uv_poll_t poll_handle;
+  uv_os_sock_t sock;
+  int connections;
+} server_context_t;
+
+
+static void delay_timer_cb(uv_timer_t* timer, int status);
+
+
+static test_mode_t test_mode = DUPLEX;
+
+static int closed_connections = 0;
+
+static int valid_writable_wakeups = 0;
+static int spurious_writable_wakeups = 0;
+
+
+static int got_eagain() {
+#ifdef _WIN32
+  return WSAGetLastError() == WSAEWOULDBLOCK;
+#else
+  return errno == EAGAIN
+      || errno == EINPROGRESS
+#ifdef EWOULDBLOCK
+      || errno == EWOULDBLOCK;
+#endif
+      ;
+#endif
+}
+
+
+static void set_nonblocking(uv_os_sock_t sock) {
+  int r;
+#ifdef _WIN32
+  unsigned long on = 1;
+  r = ioctlsocket(sock, FIONBIO, &on);
+  ASSERT(r == 0);
+#else
+  int flags = fcntl(sock, F_GETFL, 0);
+  ASSERT(flags >= 0);
+  r = fcntl(sock, F_SETFL, flags | O_NONBLOCK);
+  ASSERT(r >= 0);
+#endif
+}
+
+
+static uv_os_sock_t create_nonblocking_bound_socket(
+    struct sockaddr_in bind_addr) {
+  uv_os_sock_t sock;
+  int r;
+
+  sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+#ifdef _WIN32
+  ASSERT(sock != INVALID_SOCKET);
+#else
+  ASSERT(sock >= 0);
+#endif
+
+  set_nonblocking(sock);
+
+#ifndef _WIN32
+  {
+    /* Allow reuse of the port. */
+    int yes = 1;
+    r = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes);
+    ASSERT(r == 0);
+  }
+#endif
+
+  r = bind(sock, (const struct sockaddr*) &bind_addr, sizeof bind_addr);
+  ASSERT(r == 0);
+
+  return sock;
+}
+
+
+static void close_socket(uv_os_sock_t sock) {
+  int r;
+#ifdef _WIN32
+  r = closesocket(sock);
+#else
+  r = close(sock);
+#endif
+  ASSERT(r == 0);
+}
+
+
+static connection_context_t* create_connection_context(
+    uv_os_sock_t sock, int is_server_connection) {
+  int r;
+  connection_context_t* context;
+
+  context = (connection_context_t*) malloc(sizeof *context);
+  ASSERT(context != NULL);
+
+  context->sock = sock;
+  context->is_server_connection = is_server_connection;
+  context->read = 0;
+  context->sent = 0;
+  context->open_handles = 0;
+  context->events = 0;
+  context->delayed_events = 0;
+  context->got_fin = 0;
+  context->sent_fin = 0;
+
+  r = uv_poll_init_socket(uv_default_loop(), &context->poll_handle, sock);
+  context->open_handles++;
+  context->poll_handle.data = context;
+  ASSERT(r == 0);
+
+  r = uv_timer_init(uv_default_loop(), &context->timer_handle);
+  context->open_handles++;
+  context->timer_handle.data = context;
+  ASSERT(r == 0);
+
+  return context;
+}
+
+
+static void connection_close_cb(uv_handle_t* handle) {
+  connection_context_t* context = (connection_context_t*) handle->data;
+
+  if (--context->open_handles == 0) {
+    if (test_mode == DUPLEX || context->is_server_connection) {
+      ASSERT(context->read == TRANSFER_BYTES);
+    } else {
+      ASSERT(context->read == 0);
+    }
+
+    if (test_mode == DUPLEX || !context->is_server_connection) {
+      ASSERT(context->sent == TRANSFER_BYTES);
+    } else {
+      ASSERT(context->sent == 0);
+    }
+
+    closed_connections++;
+
+    free(context);
+  }
+}
+
+
+static void destroy_connection_context(connection_context_t* context) {
+  uv_close((uv_handle_t*) &context->poll_handle, connection_close_cb);
+  uv_close((uv_handle_t*) &context->timer_handle, connection_close_cb);
+}
+
+
+static void connection_poll_cb(uv_poll_t* handle, int status, int events) {
+  connection_context_t* context = (connection_context_t*) handle->data;
+  int new_events;
+  int r;
+
+  ASSERT(status == 0);
+  ASSERT(events & context->events);
+  ASSERT(!(events & ~context->events));
+
+  new_events = context->events;
+
+  if (events & UV_READABLE) {
+    int action = rand() % 7;
+
+    switch (action) {
+      case 0:
+      case 1: {
+        /* Read a couple of bytes. */
+        static char buffer[74];
+        r = recv(context->sock, buffer, sizeof buffer, 0);
+        ASSERT(r >= 0);
+
+        if (r > 0) {
+          context->read += r;
+        } else {
+          /* Got FIN. */
+          context->got_fin = 1;
+          new_events &= ~UV_READABLE;
+        }
+
+        break;
+      }
+
+      case 2:
+      case 3: {
+        /* Read until EAGAIN. */
+        static char buffer[931];
+        r = recv(context->sock, buffer, sizeof buffer, 0);
+        ASSERT(r >= 0);
+
+        while (r > 0) {
+          context->read += r;
+          r = recv(context->sock, buffer, sizeof buffer, 0);
+        }
+
+        if (r == 0) {
+          /* Got FIN. */
+          context->got_fin = 1;
+          new_events &= ~UV_READABLE;
+        } else {
+          ASSERT(got_eagain());
+        }
+
+        break;
+      }
+
+      case 4:
+        /* Ignore. */
+        break;
+
+      case 5:
+        /* Stop reading for a while. Restart in timer callback. */
+        new_events &= ~UV_READABLE;
+        if (!uv_is_active((uv_handle_t*) &context->timer_handle)) {
+          context->delayed_events = UV_READABLE;
+          uv_timer_start(&context->timer_handle, delay_timer_cb, 10, 0);
+        } else {
+          context->delayed_events |= UV_READABLE;
+        }
+        break;
+
+      case 6:
+        /* Fudge with the event mask. */
+        uv_poll_start(&context->poll_handle, UV_WRITABLE, connection_poll_cb);
+        uv_poll_start(&context->poll_handle, UV_READABLE, connection_poll_cb);
+        context->events = UV_READABLE;
+        break;
+
+      default:
+        ASSERT(0);
+    }
+  }
+
+  if (events & UV_WRITABLE) {
+    if (context->sent < TRANSFER_BYTES &&
+        !(test_mode == UNIDIRECTIONAL && context->is_server_connection)) {
+      /* We have to send more bytes. */
+      int action = rand() % 7;
+
+      switch (action) {
+        case 0:
+        case 1: {
+          /* Send a couple of bytes. */
+          static char buffer[103];
+
+          int send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer);
+          ASSERT(send_bytes > 0);
+
+          r = send(context->sock, buffer, send_bytes, 0);
+
+          if (r < 0) {
+            ASSERT(got_eagain());
+            spurious_writable_wakeups++;
+            break;
+          }
+
+          ASSERT(r > 0);
+          context->sent += r;
+          valid_writable_wakeups++;
+          break;
+        }
+
+        case 2:
+        case 3: {
+          /* Send until EAGAIN. */
+          static char buffer[1234];
+
+          int send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer);
+          ASSERT(send_bytes > 0);
+
+          r = send(context->sock, buffer, send_bytes, 0);
+
+          if (r < 0) {
+            ASSERT(got_eagain());
+            spurious_writable_wakeups++;
+            break;
+          }
+
+          ASSERT(r > 0);
+          valid_writable_wakeups++;
+          context->sent += r;
+
+          while (context->sent < TRANSFER_BYTES) {
+            send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer);
+            ASSERT(send_bytes > 0);
+
+            r = send(context->sock, buffer, send_bytes, 0);
+
+            if (r <= 0) break;
+            context->sent += r;
+          }
+          ASSERT(r > 0 || got_eagain());
+          break;
+        }
+
+        case 4:
+          /* Ignore. */
+         break;
+
+        case 5:
+          /* Stop sending for a while. Restart in timer callback. */
+          new_events &= ~UV_WRITABLE;
+          if (!uv_is_active((uv_handle_t*) &context->timer_handle)) {
+            context->delayed_events = UV_WRITABLE;
+            uv_timer_start(&context->timer_handle, delay_timer_cb, 100, 0);
+          } else {
+            context->delayed_events |= UV_WRITABLE;
+          }
+          break;
+
+        case 6:
+          /* Fudge with the event mask. */
+          uv_poll_start(&context->poll_handle,
+                        UV_READABLE,
+                        connection_poll_cb);
+          uv_poll_start(&context->poll_handle,
+                        UV_WRITABLE,
+                        connection_poll_cb);
+          context->events = UV_WRITABLE;
+          break;
+
+        default:
+          ASSERT(0);
+      }
+
+    } else {
+      /* Nothing more to write. Send FIN. */
+      int r;
+#ifdef _WIN32
+      r = shutdown(context->sock, SD_SEND);
+#else
+      r = shutdown(context->sock, SHUT_WR);
+#endif
+      ASSERT(r == 0);
+      context->sent_fin = 1;
+      new_events &= ~UV_WRITABLE;
+    }
+  }
+
+  if (context->got_fin && context->sent_fin) {
+    /* Sent and received FIN. Close and destroy context. */
+    close_socket(context->sock);
+    destroy_connection_context(context);
+    context->events = 0;
+
+  } else if (new_events != context->events) {
+    /* Poll mask changed. Call uv_poll_start again. */
+    context->events = new_events;
+    uv_poll_start(handle, new_events, connection_poll_cb);
+  }
+
+  /* Assert that uv_is_active works correctly for poll handles. */
+  if (context->events != 0) {
+    ASSERT(uv_is_active((uv_handle_t*) handle));
+  } else {
+    ASSERT(!uv_is_active((uv_handle_t*) handle));
+  }
+}
+
+
+static void delay_timer_cb(uv_timer_t* timer, int status) {
+  connection_context_t* context = (connection_context_t*) timer->data;
+  int r;
+
+  /* Timer should auto stop. */
+  ASSERT(!uv_is_active((uv_handle_t*) timer));
+
+  /* Add the requested events to the poll mask. */
+  ASSERT(context->delayed_events != 0);
+  context->events |= context->delayed_events;
+  context->delayed_events = 0;
+
+  r = uv_poll_start(&context->poll_handle,
+                    context->events,
+                    connection_poll_cb);
+  ASSERT(r == 0);
+}
+
+
+static server_context_t* create_server_context(
+    uv_os_sock_t sock) {
+  int r;
+  server_context_t* context;
+
+  context = (server_context_t*) malloc(sizeof *context);
+  ASSERT(context != NULL);
+
+  context->sock = sock;
+  context->connections = 0;
+
+  r = uv_poll_init_socket(uv_default_loop(), &context->poll_handle, sock);
+  context->poll_handle.data = context;
+  ASSERT(r == 0);
+
+  return context;
+}
+
+
+static void server_close_cb(uv_handle_t* handle) {
+  server_context_t* context = (server_context_t*) handle->data;
+  free(context);
+}
+
+
+static void destroy_server_context(server_context_t* context) {
+  uv_close((uv_handle_t*) &context->poll_handle, server_close_cb);
+}
+
+
+static void server_poll_cb(uv_poll_t* handle, int status, int events) {
+  server_context_t* server_context = (server_context_t*)
+                                          handle->data;
+  connection_context_t* connection_context;
+  struct sockaddr_in addr;
+  socklen_t addr_len;
+  uv_os_sock_t sock;
+  int r;
+
+  addr_len = sizeof addr;
+  sock = accept(server_context->sock, (struct sockaddr*) &addr, &addr_len);
+#ifdef _WIN32
+  ASSERT(sock != INVALID_SOCKET);
+#else
+  ASSERT(sock >= 0);
+#endif
+
+  set_nonblocking(sock);
+
+  connection_context = create_connection_context(sock, 1);
+  connection_context->events = UV_READABLE | UV_WRITABLE;
+  r = uv_poll_start(&connection_context->poll_handle,
+                    UV_READABLE | UV_WRITABLE,
+                    connection_poll_cb);
+  ASSERT(r == 0);
+
+  if (++server_context->connections == NUM_CLIENTS) {
+    close_socket(server_context->sock);
+    destroy_server_context(server_context);
+  }
+}
+
+
+static void start_server() {
+  uv_os_sock_t sock;
+  server_context_t* context;
+  int r;
+
+  sock = create_nonblocking_bound_socket(uv_ip4_addr("127.0.0.1", TEST_PORT));
+  context = create_server_context(sock);
+
+  r = listen(sock, 100);
+  ASSERT(r == 0);
+
+  r = uv_poll_start(&context->poll_handle, UV_READABLE, server_poll_cb);
+  ASSERT(r == 0);
+}
+
+
+static void start_client() {
+  uv_os_sock_t sock;
+  connection_context_t* context;
+  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  int r;
+
+  sock = create_nonblocking_bound_socket(uv_ip4_addr("0.0.0.0", 0));
+  context = create_connection_context(sock, 0);
+
+  context->events = UV_READABLE | UV_WRITABLE;
+  r = uv_poll_start(&context->poll_handle,
+                    UV_READABLE | UV_WRITABLE,
+                    connection_poll_cb);
+  ASSERT(r == 0);
+
+  r = connect(sock, (struct sockaddr*) &server_addr, sizeof server_addr);
+  ASSERT(r == 0 || got_eagain());
+}
+
+
+static void start_poll_test() {
+  int i, r;
+
+#ifdef _WIN32
+  {
+    struct WSAData wsa_data;
+    int r = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+    ASSERT(r == 0);
+  }
+#endif
+
+  start_server();
+
+  for (i = 0; i < NUM_CLIENTS; i++)
+    start_client();
+
+  r = uv_run(uv_default_loop());
+  ASSERT(r == 0);
+
+  /* Assert that at most five percent of the writable wakeups was spurious. */
+  ASSERT(spurious_writable_wakeups == 0 ||
+         (valid_writable_wakeups + spurious_writable_wakeups) /
+         spurious_writable_wakeups > 20);
+
+  ASSERT(closed_connections == NUM_CLIENTS * 2);
+}
+
+
+TEST_IMPL(poll_duplex) {
+  test_mode = DUPLEX;
+  start_poll_test();
+  return 0;
+}
+
+
+TEST_IMPL(poll_unidirectional) {
+  test_mode = UNIDIRECTIONAL;
+  start_poll_test();
+  return 0;
+}