noderb 0.0.4 → 0.0.6

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

@@ -0,0 +1,250 @@
+/* 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 "task.h"
+#include "uv.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define EXPECTED "RANG TANG DING DONG I AM THE JAPANESE SANDMAN" /* "Take eight!" */
+
+#define TEST_DURATION 5000 /* ms */
+
+#define MAX_SENDERS   1000
+#define MAX_RECEIVERS 1000
+
+#define BASE_PORT 12345
+
+#define ARRAY_SIZE(a) (sizeof((a)) / sizeof((a)[0]))
+
+static uv_loop_t* loop;
+
+static int n_senders_;
+static int n_receivers_;
+static uv_udp_t senders[MAX_SENDERS];
+static uv_udp_t receivers[MAX_RECEIVERS];
+static uv_buf_t bufs[5];
+
+static int send_cb_called;
+static int recv_cb_called;
+static int close_cb_called;
+static int stopping = 0;
+
+typedef struct {
+  struct sockaddr_in addr;
+} sender_state_t;
+
+
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+  static char slab[65536];
+  ASSERT(suggested_size <= sizeof slab);
+  return uv_buf_init(slab, sizeof slab);
+}
+
+
+static void send_cb(uv_udp_send_t* req, int status) {
+  sender_state_t* ss;
+  int r;
+
+  if (stopping) {
+    return;
+  }
+
+  ASSERT(req != NULL);
+  ASSERT(status == 0);
+
+  ss = req->data;
+
+  r = uv_udp_send(req, req->handle, bufs, ARRAY_SIZE(bufs), ss->addr, send_cb);
+  ASSERT(r == 0);
+
+  req->data = ss;
+
+  send_cb_called++;
+}
+
+
+static void recv_cb(uv_udp_t* handle,
+                    ssize_t nread,
+                    uv_buf_t buf,
+                    struct sockaddr* addr,
+                    unsigned flags) {
+  if (nread == 0)
+    return;
+
+  if (nread == -1) {
+    ASSERT(uv_last_error(loop).code == UV_EINTR); /* FIXME change error code */
+    return;
+  }
+
+  ASSERT(addr->sa_family == AF_INET);
+  ASSERT(!memcmp(buf.base, EXPECTED, nread));
+
+  recv_cb_called++;
+}
+
+
+static void close_cb(uv_handle_t* handle) {
+  ASSERT(handle != NULL);
+  close_cb_called++;
+}
+
+
+static void timeout_cb(uv_timer_t* timer, int status) {
+  int i;
+
+  stopping = 1;
+
+  for (i = 0; i < n_senders_; i++)
+    uv_close((uv_handle_t*)&senders[i], close_cb);
+
+  for (i = 0; i < n_receivers_; i++)
+    uv_close((uv_handle_t*)&receivers[i], close_cb);
+}
+
+
+static int do_packet_storm(int n_senders, int n_receivers) {
+  uv_timer_t timeout;
+  sender_state_t *ss;
+  uv_udp_send_t* req;
+  uv_udp_t* handle;
+  int i;
+  int r;
+
+  ASSERT(n_senders <= MAX_SENDERS);
+  ASSERT(n_receivers <= MAX_RECEIVERS);
+
+  uv_init();
+  loop = uv_default_loop();
+
+  n_senders_ = n_senders;
+  n_receivers_ = n_receivers;
+
+  r = uv_timer_init(loop, &timeout);
+  ASSERT(r == 0);
+
+  r = uv_timer_start(&timeout, timeout_cb, TEST_DURATION, 0);
+  ASSERT(r == 0);
+
+  /* Timer should not keep loop alive. */
+  uv_unref(loop);
+
+  for (i = 0; i < n_receivers; i++) {
+    struct sockaddr_in addr;
+    handle = &receivers[i];
+
+    r = uv_udp_init(loop, handle);
+    ASSERT(r == 0);
+
+    addr = uv_ip4_addr("0.0.0.0", BASE_PORT + i);
+
+    r = uv_udp_bind(handle, addr, 0);
+    ASSERT(r == 0);
+
+    r = uv_udp_recv_start(handle, alloc_cb, recv_cb);
+    ASSERT(r == 0);
+  }
+
+  bufs[0] = uv_buf_init(EXPECTED + 0,  10);
+  bufs[1] = uv_buf_init(EXPECTED + 10, 10);
+  bufs[2] = uv_buf_init(EXPECTED + 20, 10);
+  bufs[3] = uv_buf_init(EXPECTED + 30, 10);
+  bufs[4] = uv_buf_init(EXPECTED + 40, 5);
+
+  for (i = 0; i < n_senders; i++) {
+    handle = &senders[i];
+
+    r = uv_udp_init(loop, handle);
+    ASSERT(r == 0);
+
+    req = malloc(sizeof(*req) + sizeof(*ss));
+
+    ss = (void*)(req + 1);
+    ss->addr = uv_ip4_addr("127.0.0.1", BASE_PORT + (i % n_receivers));
+
+    r = uv_udp_send(req, handle, bufs, ARRAY_SIZE(bufs), ss->addr, send_cb);
+    ASSERT(r == 0);
+
+    req->data = ss;
+  }
+
+  uv_run(loop);
+
+  printf("udp_packet_storm_%dv%d: %.0f/s received, %.0f/s sent\n",
+         n_receivers,
+         n_senders,
+         recv_cb_called / (TEST_DURATION / 1000.0),
+         send_cb_called / (TEST_DURATION / 1000.0));
+
+  return 0;
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_1v1) {
+  return do_packet_storm(1, 1);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_1v10) {
+  return do_packet_storm(1, 10);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_1v100) {
+  return do_packet_storm(1, 100);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_1v1000) {
+  return do_packet_storm(1, 1000);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_10v10) {
+  return do_packet_storm(10, 10);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_10v100) {
+  return do_packet_storm(10, 100);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_10v1000) {
+  return do_packet_storm(10, 1000);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_100v100) {
+  return do_packet_storm(100, 100);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_100v1000) {
+  return do_packet_storm(100, 1000);
+}
+
+
+BENCHMARK_IMPL(udp_packet_storm_1000v1000) {
+  return do_packet_storm(1000, 1000);
+}

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

@@ -47,6 +47,9 @@ typedef struct {
 } dnshandle;
 
 
+static uv_loop_t* loop;
+
+
 static int server_closed;
 static uv_tcp_t server;
 
@@ -71,7 +74,7 @@ static void after_write(uv_write_t* req, int status) {
   write_req_t* wr;
 
   if (status) {
-    uv_err_t err = uv_last_error();
+    uv_err_t err = uv_last_error(loop);
     fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
     ASSERT(0);
   }
@@ -220,7 +223,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   if (nread < 0) {
     /* Error or EOF */
-    ASSERT (uv_last_error().code == UV_EOF);
+    ASSERT (uv_last_error(loop).code == UV_EOF);
 
     if (buf.base) {
       free(buf.base);
@@ -247,7 +250,7 @@ static void on_close(uv_handle_t* peer) {
 }
 
 
-static uv_buf_t buf_alloc(uv_stream_t* handle, size_t suggested_size) {
+static uv_buf_t buf_alloc(uv_handle_t* handle, size_t suggested_size) {
   uv_buf_t buf;
   buf.base = (char*) malloc(suggested_size);
   buf.len = suggested_size;
@@ -269,7 +272,7 @@ static void on_connection(uv_stream_t* server, int status) {
   handle->state.prevbuf_pos = 0;
   handle->state.prevbuf_rem = 0;
 
-  uv_tcp_init((uv_tcp_t*)handle);
+  uv_tcp_init(loop, (uv_tcp_t*)handle);
 
   r = uv_accept(server, (uv_stream_t*)handle);
   ASSERT(r == 0);
@@ -288,7 +291,7 @@ static int dns_start(int port) {
   struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
   int r;
 
-  r = uv_tcp_init(&server);
+  r = uv_tcp_init(loop, &server);
   if (r) {
     /* TODO: Error codes */
     fprintf(stderr, "Socket creation error\n");
@@ -315,9 +318,11 @@ static int dns_start(int port) {
 
 HELPER_IMPL(dns_server) {
   uv_init();
+  loop = uv_default_loop();
+
   if (dns_start(TEST_PORT_2))
     return 1;
 
-  uv_run();
+  uv_run(loop);
   return 0;
 }

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

@@ -29,6 +29,8 @@ typedef struct {
   uv_buf_t buf;
 } write_req_t;
 
+static uv_loop_t* loop;
+
 static int server_closed;
 static stream_type serverType;
 static uv_tcp_t tcpServer;
@@ -46,7 +48,7 @@ static void after_write(uv_write_t* req, int status) {
   write_req_t* wr;
 
   if (status) {
-    uv_err_t err = uv_last_error();
+    uv_err_t err = uv_last_error(loop);
     fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
     ASSERT(0);
   }
@@ -72,7 +74,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   if (nread < 0) {
     /* Error or EOF */
-    ASSERT (uv_last_error().code == UV_EOF);
+    ASSERT (uv_last_error(loop).code == UV_EOF);
 
     if (buf.base) {
       free(buf.base);
@@ -111,8 +113,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   wr = (write_req_t*) malloc(sizeof *wr);
 
-  wr->buf.base = buf.base;
-  wr->buf.len = nread;
+  wr->buf = uv_buf_init(buf.base, nread);
   if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
     FATAL("uv_write failed");
   }
@@ -124,11 +125,8 @@ static void on_close(uv_handle_t* peer) {
 }
 
 
-static uv_buf_t echo_alloc(uv_stream_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = (char*) malloc(suggested_size);
-  buf.len = suggested_size;
-  return buf;
+static uv_buf_t echo_alloc(uv_handle_t* handle, size_t suggested_size) {
+  return uv_buf_init(malloc(suggested_size), suggested_size);
 }
 
 
@@ -137,7 +135,8 @@ static void on_connection(uv_stream_t* server, int status) {
   int r;
 
   if (status != 0) {
-    fprintf(stderr, "Connect error %d\n", uv_last_error().code);
+    fprintf(stderr, "Connect error %d\n",
+        uv_last_error(loop).code);
   }
   ASSERT(status == 0);
 
@@ -145,13 +144,13 @@ static void on_connection(uv_stream_t* server, int status) {
   case TCP:
     stream = malloc(sizeof(uv_tcp_t));
     ASSERT(stream != NULL);
-    uv_tcp_init((uv_tcp_t*)stream);
+    uv_tcp_init(loop, (uv_tcp_t*)stream);
     break;
 
   case PIPE:
     stream = malloc(sizeof(uv_pipe_t));
     ASSERT(stream != NULL);
-    uv_pipe_init((uv_pipe_t*)stream);
+    uv_pipe_init(loop, (uv_pipe_t*)stream);
     break;
 
   default:
@@ -182,7 +181,7 @@ static int tcp4_echo_start(int port) {
   server = (uv_handle_t*)&tcpServer;
   serverType = TCP;
 
-  r = uv_tcp_init(&tcpServer);
+  r = uv_tcp_init(loop, &tcpServer);
   if (r) {
     /* TODO: Error codes */
     fprintf(stderr, "Socket creation error\n");
@@ -199,7 +198,8 @@ static int tcp4_echo_start(int port) {
   r = uv_listen((uv_stream_t*)&tcpServer, SOMAXCONN, on_connection);
   if (r) {
     /* TODO: Error codes */
-    fprintf(stderr, "Listen error\n");
+    fprintf(stderr, "Listen error %s\n",
+        uv_err_name(uv_last_error(loop)));
     return 1;
   }
 
@@ -214,7 +214,7 @@ static int tcp6_echo_start(int port) {
   server = (uv_handle_t*)&tcpServer;
   serverType = TCP;
 
-  r = uv_tcp_init(&tcpServer);
+  r = uv_tcp_init(loop, &tcpServer);
   if (r) {
     /* TODO: Error codes */
     fprintf(stderr, "Socket creation error\n");
@@ -246,21 +246,24 @@ static int pipe_echo_start(char* pipeName) {
   server = (uv_handle_t*)&pipeServer;
   serverType = PIPE;
 
-  r = uv_pipe_init(&pipeServer);
+  r = uv_pipe_init(loop, &pipeServer);
   if (r) {
-    fprintf(stderr, "uv_pipe_init: %s\n", uv_strerror(uv_last_error()));
+    fprintf(stderr, "uv_pipe_init: %s\n",
+        uv_strerror(uv_last_error(loop)));
     return 1;
   }
 
   r = uv_pipe_bind(&pipeServer, pipeName);
   if (r) {
-    fprintf(stderr, "uv_pipe_bind: %s\n", uv_strerror(uv_last_error()));
+    fprintf(stderr, "uv_pipe_bind: %s\n",
+        uv_strerror(uv_last_error(loop)));
     return 1;
   }
 
   r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
   if (r) {
-    fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(uv_last_error()));
+    fprintf(stderr, "uv_pipe_listen: %s\n",
+        uv_strerror(uv_last_error(loop)));
     return 1;
   }
 
@@ -270,30 +273,35 @@ static int pipe_echo_start(char* pipeName) {
 
 HELPER_IMPL(tcp4_echo_server) {
   uv_init();
+  loop = uv_default_loop();
+
   if (tcp4_echo_start(TEST_PORT))
     return 1;
 
-  uv_run();
+  uv_run(loop);
   return 0;
 }
 
 
 HELPER_IMPL(tcp6_echo_server) {
   uv_init();
+  loop = uv_default_loop();
+
   if (tcp6_echo_start(TEST_PORT))
     return 1;
 
-  uv_run();
+  uv_run(loop);
   return 0;
 }
 
 
 HELPER_IMPL(pipe_echo_server) {
   uv_init();
+  loop = uv_default_loop();
 
   if (pipe_echo_start(TEST_PIPENAME))
     return 1;
 
-  uv_run();
+  uv_run(loop);
   return 0;
 }

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

@@ -184,12 +184,12 @@ TEST_IMPL(async) {
 
   uv_init();
 
-  r = uv_prepare_init(&prepare_handle);
+  r = uv_prepare_init(uv_default_loop(), &prepare_handle);
   ASSERT(r == 0);
   r = uv_prepare_start(&prepare_handle, prepare_cb);
   ASSERT(r == 0);
 
-  r = uv_async_init(&async1_handle, async1_cb);
+  r = uv_async_init(uv_default_loop(), &async1_handle, async1_cb);
   ASSERT(r == 0);
 
 #if 0
@@ -197,7 +197,7 @@ TEST_IMPL(async) {
   ASSERT(r == 0);
 #endif
 
-  r = uv_run();
+  r = uv_run(uv_default_loop());
   ASSERT(r == 0);
 
   r = uv_wait_thread(thread1_id);

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

@@ -45,7 +45,7 @@ static int bytes_received = 0;
 static int shutdown_cb_called = 0;
 
 
-static uv_buf_t alloc_cb(uv_stream_t* tcp, size_t size) {
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
   uv_buf_t buf;
   buf.len = size;
   buf.base = (char*) malloc(size);
@@ -76,11 +76,11 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
   free(buf.base);
 
   if (nread == 0) {
-    ASSERT(uv_last_error().code == UV_EAGAIN);
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EAGAIN);
     return;
 
   } else if (nread == -1) {
-    ASSERT(uv_last_error().code == UV_EOF);
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
 
     nested++;
     uv_close((uv_handle_t*)tcp, close_cb);
@@ -140,7 +140,7 @@ static void write_cb(uv_write_t* req, int status) {
   /* back to our receive buffer when we start reading. This maximizes the */
   /* tempation for the backend to use dirty stack for calling read_cb. */
   nested++;
-  r = uv_timer_init(&timer);
+  r = uv_timer_init(uv_default_loop(), &timer);
   ASSERT(r == 0);
   r = uv_timer_start(&timer, timer_cb, 500, 0);
   ASSERT(r == 0);
@@ -178,7 +178,7 @@ TEST_IMPL(callback_stack) {
 
   uv_init();
 
-  if (uv_tcp_init(&client)) {
+  if (uv_tcp_init(uv_default_loop(), &client)) {
     FATAL("uv_tcp_init failed");
   }
 
@@ -191,7 +191,7 @@ TEST_IMPL(callback_stack) {
   }
   nested--;
 
-  uv_run();
+  uv_run(uv_default_loop());
 
   ASSERT(nested == 0);
   ASSERT(connect_cb_called == 1 && "connect_cb must be called exactly once");

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

@@ -69,7 +69,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
 static void on_connect_with_close(uv_connect_t *req, int status) {
   ASSERT((uv_stream_t*) &tcp == req->handle);
   ASSERT(status == -1);
-  ASSERT(uv_last_error().code == UV_ECONNREFUSED);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);
   connect_cb_calls++;
 
   ASSERT(close_cb_calls == 0);
@@ -79,7 +79,7 @@ static void on_connect_with_close(uv_connect_t *req, int status) {
 
 static void on_connect_without_close(uv_connect_t *req, int status) {
   ASSERT(status == -1);
-  ASSERT(uv_last_error().code == UV_ECONNREFUSED);
+  ASSERT(uv_last_error(uv_default_loop()).code == UV_ECONNREFUSED);
   connect_cb_calls++;
 
   uv_timer_start(&timer, timer_cb, 100, 0);
@@ -98,7 +98,7 @@ void connection_fail(uv_connect_cb connect_cb) {
   server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
 
   /* Try to connec to the server and do NUM_PINGS ping-pongs. */
-  r = uv_tcp_init(&tcp);
+  r = uv_tcp_init(uv_default_loop(), &tcp);
   ASSERT(!r);
 
   /* We are never doing multiple reads/connects at a time anyway. */
@@ -107,7 +107,7 @@ void connection_fail(uv_connect_cb connect_cb) {
   r = uv_tcp_connect(&req, &tcp, server_addr, connect_cb);
   ASSERT(!r);
 
-  uv_run();
+  uv_run(uv_default_loop());
 
   ASSERT(connect_cb_calls == 1);
   ASSERT(close_cb_calls == 1);
@@ -138,7 +138,8 @@ TEST_IMPL(connection_fail) {
 TEST_IMPL(connection_fail_doesnt_auto_close) {
   uv_init();
 
-  uv_timer_init(&timer);
+
+  uv_timer_init(uv_default_loop(), &timer);
 
   connection_fail(on_connect_without_close);
 

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

@@ -30,7 +30,7 @@ static int close_cb_called = 0;
 static int connect_cb_called = 0;
 
 
-static uv_buf_t alloc_cb(uv_stream_t* tcp, size_t size) {
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
   uv_buf_t buf;
   buf.base = (char*)malloc(size);
   buf.len = size;
@@ -57,16 +57,16 @@ static void do_accept(uv_timer_t* timer_handle, int status) {
   ASSERT(status == 0);
   ASSERT(accepted_handle != NULL);
 
-  uv_tcp_init(accepted_handle);
+  uv_tcp_init(uv_default_loop(), accepted_handle);
 
-  /* Test to that uv_counters()->tcp_init does not increase across the uv_accept. */
-  tcpcnt = uv_counters()->tcp_init;
+  /* Test to that uv_default_loop()->counters.tcp_init does not increase across the uv_accept. */
+  tcpcnt = uv_default_loop()->counters.tcp_init;
 
   server = (uv_tcp_t*)timer_handle->data;
   r = uv_accept((uv_stream_t*)server, (uv_stream_t*)accepted_handle);
   ASSERT(r == 0);
 
-  ASSERT(uv_counters()->tcp_init == tcpcnt);
+  ASSERT(uv_default_loop()->counters.tcp_init == tcpcnt);
 
   do_accept_called++;
 
@@ -93,7 +93,7 @@ static void connection_cb(uv_stream_t* tcp, int status) {
   ASSERT(timer_handle != NULL);
 
   /* Accept the client after 1 second */
-  r = uv_timer_init(timer_handle);
+  r = uv_timer_init(uv_default_loop(), timer_handle);
   ASSERT(r == 0);
 
   timer_handle->data = tcp;
@@ -112,10 +112,10 @@ static void start_server() {
 
   ASSERT(server != NULL);
 
-  r = uv_tcp_init(server);
+  r = uv_tcp_init(uv_default_loop(), server);
   ASSERT(r == 0);
-  ASSERT(uv_counters()->tcp_init == 1);
-  ASSERT(uv_counters()->handle_init == 1);
+  ASSERT(uv_default_loop()->counters.tcp_init == 1);
+  ASSERT(uv_default_loop()->counters.handle_init == 1);
 
   r = uv_tcp_bind(server, addr);
   ASSERT(r == 0);
@@ -134,11 +134,11 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
 
   if (nread != -1) {
     ASSERT(nread == 0);
-    ASSERT(uv_last_error().code == UV_EAGAIN);
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EAGAIN);
   } else {
     ASSERT(tcp != NULL);
     ASSERT(nread == -1);
-    ASSERT(uv_last_error().code == UV_EOF);
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
     uv_close((uv_handle_t*)tcp, close_cb);
   }
 }
@@ -170,7 +170,7 @@ static void client_connect() {
   ASSERT(client != NULL);
   ASSERT(connect_req != NULL);
 
-  r = uv_tcp_init(client);
+  r = uv_tcp_init(uv_default_loop(), client);
   ASSERT(r == 0);
 
   r = uv_tcp_connect(connect_req, client, addr, connect_cb);
@@ -187,7 +187,7 @@ TEST_IMPL(delayed_accept) {
   client_connect();
   client_connect();
 
-  uv_run();
+  uv_run(uv_default_loop());
 
   ASSERT(connection_cb_called == 2);
   ASSERT(do_accept_called == 2);