asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/test/test-tcp-write-error.c

@@ -100,7 +100,7 @@ static void connect_cb(uv_connect_t* req, int status) {
     r = uv_write(&(wr->req), req->handle, &wr->buf, 1, write_cb);
     ASSERT(r == 0);
  
-    if (req->handle->write_queue_size > 0) {
+    if (req->handle->write_queue_size >= size * 2) {
       break;
     }
   }
@@ -161,7 +161,7 @@ TEST_IMPL(tcp_write_error) {
   ASSERT(r == 0);
 
   ASSERT(write_cb_called > 0);
-  ASSERT(write_cb_error_called == 1);
+  ASSERT(write_cb_error_called >= 1);
   ASSERT(tcp_client.write_queue_size == 0);
 
   return 0;

data/ext/asyncengine/libuv/test/test-tcp-writealot.c

@@ -31,32 +31,28 @@
 
 #define TOTAL_BYTES       (WRITES * CHUNKS_PER_WRITE * CHUNK_SIZE)
 
-
 static char* send_buffer;
 
-
 static int shutdown_cb_called = 0;
 static int connect_cb_called = 0;
 static int write_cb_called = 0;
 static int close_cb_called = 0;
-static int bytes_sent = 0;
-static int bytes_sent_done = 0;
-static int bytes_received_done = 0;
+static size_t bytes_sent = 0;
+static size_t bytes_sent_done = 0;
+static size_t bytes_received_done = 0;
+
+static uv_connect_t connect_req;
+static uv_shutdown_t shutdown_req;
+static uv_write_t write_reqs[WRITES];
 
 
 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;
-  return buf;
+  return uv_buf_init(malloc(size), size);
 }
 
 
 static void close_cb(uv_handle_t* handle) {
   ASSERT(handle != NULL);
-
-  free(handle);
-
   close_cb_called++;
 }
 
@@ -64,7 +60,7 @@ static void close_cb(uv_handle_t* handle) {
 static void shutdown_cb(uv_shutdown_t* req, int status) {
   uv_tcp_t* tcp;
 
-  ASSERT(req);
+  ASSERT(req == &shutdown_req);
   ASSERT(status == 0);
 
   tcp = (uv_tcp_t*)(req->handle);
@@ -77,28 +73,21 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
 
   /* We should have had all the writes called already. */
   ASSERT(write_cb_called == WRITES);
-
-  free(req);
 }
 
 
 static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
   ASSERT(tcp != NULL);
 
-  if (nread < 0) {
+  if (nread >= 0) {
+    bytes_received_done += nread;
+  }
+  else {
     ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
     printf("GOT EOF\n");
-
-    if (buf.base) {
-      free(buf.base);
-    }
-
     uv_close((uv_handle_t*)tcp, close_cb);
-    return;
   }
 
-  bytes_received_done += nread;
-
   free(buf.base);
 }
 
@@ -114,71 +103,55 @@ static void write_cb(uv_write_t* req, int status) {
 
   bytes_sent_done += CHUNKS_PER_WRITE * CHUNK_SIZE;
   write_cb_called++;
-
-  free(req);
 }
 
 
 static void connect_cb(uv_connect_t* req, int status) {
   uv_buf_t send_bufs[CHUNKS_PER_WRITE];
-  uv_tcp_t* tcp;
-  uv_write_t* write_req;
-  uv_shutdown_t* shutdown_req;
+  uv_stream_t* stream;
   int i, j, r;
 
-  ASSERT(req != NULL);
+  ASSERT(req == &connect_req);
   ASSERT(status == 0);
 
-  tcp = (uv_tcp_t*)req->handle;
-
+  stream = req->handle;
   connect_cb_called++;
-  free(req);
 
   /* Write a lot of data */
   for (i = 0; i < WRITES; i++) {
+    uv_write_t* write_req = write_reqs + i;
+
     for (j = 0; j < CHUNKS_PER_WRITE; j++) {
-      send_bufs[j].len = CHUNK_SIZE;
-      send_bufs[j].base = send_buffer + bytes_sent;
+      send_bufs[j] = uv_buf_init(send_buffer + bytes_sent, CHUNK_SIZE);
       bytes_sent += CHUNK_SIZE;
     }
 
-    write_req = malloc(sizeof(uv_write_t));
-    ASSERT(write_req != NULL);
-
-    r = uv_write(write_req, (uv_stream_t*) tcp, (uv_buf_t*)&send_bufs,
-        CHUNKS_PER_WRITE, write_cb);
+    r = uv_write(write_req, stream, send_bufs, CHUNKS_PER_WRITE, write_cb);
     ASSERT(r == 0);
   }
 
-  /* Shutdown on drain. FIXME: dealloc req? */
-  shutdown_req = malloc(sizeof(uv_shutdown_t));
-  ASSERT(shutdown_req != NULL);
-  r = uv_shutdown(shutdown_req, (uv_stream_t*)tcp, shutdown_cb);
+  /* Shutdown on drain. */
+  r = uv_shutdown(&shutdown_req, stream, shutdown_cb);
   ASSERT(r == 0);
 
   /* Start reading */
-  r = uv_read_start((uv_stream_t*)tcp, alloc_cb, read_cb);
+  r = uv_read_start(stream, alloc_cb, read_cb);
   ASSERT(r == 0);
 }
 
 
 TEST_IMPL(tcp_writealot) {
   struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
-  uv_tcp_t* client = (uv_tcp_t*)malloc(sizeof *client);
-  uv_connect_t* connect_req = malloc(sizeof(uv_connect_t));
+  uv_tcp_t client;
   int r;
 
-  ASSERT(client != NULL);
-  ASSERT(connect_req != NULL);
-
-  send_buffer = (char*)malloc(TOTAL_BYTES + 1);
-
+  send_buffer = malloc(TOTAL_BYTES);
   ASSERT(send_buffer != NULL);
 
-  r = uv_tcp_init(uv_default_loop(), client);
+  r = uv_tcp_init(uv_default_loop(), &client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(connect_req, client, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
   ASSERT(r == 0);
 
   uv_run(uv_default_loop());
@@ -191,5 +164,7 @@ TEST_IMPL(tcp_writealot) {
   ASSERT(bytes_sent_done == TOTAL_BYTES);
   ASSERT(bytes_received_done == TOTAL_BYTES);
 
+  free(send_buffer);
+
   return 0;
 }

data/ext/asyncengine/libuv/test/test-timer-again.c

@@ -104,7 +104,7 @@ TEST_IMPL(timer_again) {
   r = uv_timer_again(&dummy);
   ASSERT(r == -1);
   ASSERT(uv_last_error(uv_default_loop()).code == UV_EINVAL);
-  uv_unref(uv_default_loop());
+  uv_unref((uv_handle_t*)&dummy);
 
   /* Start timer repeat_1. */
   r = uv_timer_init(uv_default_loop(), &repeat_1);

data/ext/asyncengine/libuv/test/test-timer.c

@@ -35,6 +35,7 @@ static void once_close_cb(uv_handle_t* handle) {
   printf("ONCE_CLOSE_CB\n");
 
   ASSERT(handle != NULL);
+  ASSERT(!uv_is_active(handle));
 
   once_close_cb_called++;
 }
@@ -45,6 +46,7 @@ static void once_cb(uv_timer_t* handle, int status) {
 
   ASSERT(handle != NULL);
   ASSERT(status == 0);
+  ASSERT(!uv_is_active((uv_handle_t*)handle));
 
   once_cb_called++;
 
@@ -69,6 +71,7 @@ static void repeat_cb(uv_timer_t* handle, int status) {
 
   ASSERT(handle != NULL);
   ASSERT(status == 0);
+  ASSERT(uv_is_active((uv_handle_t*)handle));
 
   repeat_cb_called++;
 
@@ -114,7 +117,7 @@ TEST_IMPL(timer) {
   ASSERT(r == 0);
   r = uv_timer_stop(&never);
   ASSERT(r == 0);
-  uv_unref(uv_default_loop());
+  uv_unref((uv_handle_t*)&never);
 
   uv_run(uv_default_loop());
 
@@ -128,3 +131,22 @@ TEST_IMPL(timer) {
 
   return 0;
 }
+
+
+TEST_IMPL(timer_start_twice) {
+  uv_timer_t once;
+  int r;
+
+  r = uv_timer_init(uv_default_loop(), &once);
+  ASSERT(r == 0);
+  r = uv_timer_start(&once, never_cb, 86400 * 1000, 0);
+  ASSERT(r == 0);
+  r = uv_timer_start(&once, once_cb, 10, 0);
+  ASSERT(r == 0);
+  r = uv_run(uv_default_loop());
+  ASSERT(r == 0);
+
+  ASSERT(once_cb_called == 1);
+
+  return 0;
+}

data/ext/asyncengine/libuv/test/test-udp-options.c

@@ -38,7 +38,7 @@ TEST_IMPL(udp_options) {
   r = uv_udp_init(loop, &h);
   ASSERT(r == 0);
 
-  uv_unref(loop); /* don't keep the loop alive */
+  uv_unref((uv_handle_t*)&h); /* don't keep the loop alive */
 
   r = uv_udp_bind(&h, uv_ip4_addr("0.0.0.0", TEST_PORT), 0);
   ASSERT(r == 0);

data/ext/asyncengine/libuv/test/{test-eio-overflow.c → test-walk-handles.c}

@@ -21,70 +21,57 @@
 
 #include "uv.h"
 #include "task.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 
+static char magic_cookie[] = "magic cookie";
+static int seen_timer_handle;
+static uv_timer_t timer;
 
-static uv_idle_t idle;
-
-static const int max_opened = 10000;
-static const int max_delta = 4000;
-
-static int opened = 0;
-static int closed = 0;
-
-
-void work_cb(uv_work_t* work) {
-  /* continue as fast as possible */
-}
-
-
-void after_work_cb(uv_work_t* work) {
-  free(work);
-  closed++;
-}
-
-
-void make_eio_req(void) {
-  uv_work_t* w;
-
-  opened++;
 
-  w = (uv_work_t*) malloc(sizeof(*w));
-  ASSERT(w != NULL);
+static void walk_cb(uv_handle_t* handle, void* arg) {
+  ASSERT(arg == (void*)magic_cookie);
 
-  uv_queue_work(uv_default_loop(), w, work_cb, after_work_cb);
+  if (handle == (uv_handle_t*)&timer) {
+    seen_timer_handle++;
+  } else {
+    ASSERT(0 && "unexpected handle");
+  }
 }
 
 
-void idle_cb(uv_idle_t* idle, int status) {
-  ASSERT(opened - closed < max_delta);
-  if (opened <= max_opened) {
-    int i;
-    for (i = 0; i < 30; i++) {
-      make_eio_req();
-    }
-  } else {
-    int r;
+static void timer_cb(uv_timer_t* handle, int status) {
+  ASSERT(handle == &timer);
+  ASSERT(status == 0);
 
-    r = uv_idle_stop(idle);
-    uv_unref(uv_default_loop());
-    ASSERT(r == 0);
-  }
+  uv_walk(handle->loop, walk_cb, magic_cookie);
+  uv_close((uv_handle_t*)handle, NULL);
 }
 
 
-TEST_IMPL(eio_overflow) {
+TEST_IMPL(walk_handles) {
+  uv_loop_t* loop;
   int r;
 
-  r = uv_idle_init(uv_default_loop(), &idle);
+  loop = uv_default_loop();
+
+  r = uv_timer_init(loop, &timer);
   ASSERT(r == 0);
 
-  r = uv_idle_start(&idle, idle_cb);
+  r = uv_timer_start(&timer, timer_cb, 1, 0);
   ASSERT(r == 0);
 
-  r = uv_run(uv_default_loop());
+  /* Start event loop, expect to see the timer handle in walk_cb. */
+  ASSERT(seen_timer_handle == 0);
+  r = uv_run(loop);
   ASSERT(r == 0);
+  ASSERT(seen_timer_handle == 1);
+
+  /* Loop is finished, walk_cb should not see our timer handle. */
+  seen_timer_handle = 0;
+  uv_walk(loop, walk_cb, magic_cookie);
+  ASSERT(seen_timer_handle == 0);
 
   return 0;
 }

data/ext/asyncengine/libuv/uv.gyp

@@ -47,6 +47,10 @@
         'include/ares.h',
         'include/ares_version.h',
         'include/uv.h',
+        'include/uv-private/ngx-queue.h',
+        'include/uv-private/tree.h',
+        'src/cares.c',
+        'src/fs-poll.c',
         'src/uv-common.c',
         'src/uv-common.h',
         'src/ares/ares_cancel.c',
@@ -125,7 +129,6 @@
             '_GNU_SOURCE',
           ],
           'sources': [
-            'include/uv-private/tree.h',
             'include/uv-private/uv-win.h',
             'src/ares/config_win32/ares_config.h',
             'src/ares/windows_port.c',
@@ -133,7 +136,6 @@
             'src/ares/ares_iphlpapi.h',
             'src/ares/ares_platform.c',
             'src/win/async.c',
-            'src/win/cares.c',
             'src/win/core.c',
             'src/win/dl.c',
             'src/win/error.c',
@@ -141,13 +143,18 @@
             'src/win/fs-event.c',
             'src/win/getaddrinfo.c',
             'src/win/handle.c',
+            'src/win/handle-inl.h',
             'src/win/internal.h',
             'src/win/loop-watcher.c',
             'src/win/pipe.c',
             'src/win/thread.c',
+            'src/win/poll.c',
             'src/win/process.c',
+            'src/win/process-stdio.c',
             'src/win/req.c',
+            'src/win/req-inl.h',
             'src/win/stream.c',
+            'src/win/stream-inl.h',
             'src/win/tcp.c',
             'src/win/tty.c',
             'src/win/threadpool.c',
@@ -178,11 +185,8 @@
           'sources': [
             'include/uv-private/eio.h',
             'include/uv-private/ev.h',
-            'include/uv-private/ngx-queue.h',
             'include/uv-private/uv-unix.h',
             'src/unix/async.c',
-            'src/unix/cares.c',
-            'src/unix/check.c',
             'src/unix/core.c',
             'src/unix/dl.c',
             'src/unix/eio/ecb.h',
@@ -194,11 +198,11 @@
             'src/unix/ev/ev_wrap.h',
             'src/unix/ev/event.h',
             'src/unix/fs.c',
-            'src/unix/idle.c',
             'src/unix/internal.h',
             'src/unix/loop.c',
+            'src/unix/loop-watcher.c',
             'src/unix/pipe.c',
-            'src/unix/prepare.c',
+            'src/unix/poll.c',
             'src/unix/process.c',
             'src/unix/stream.c',
             'src/unix/tcp.c',
@@ -229,7 +233,7 @@
         [ 'OS=="linux"', {
           'include_dirs': [ 'src/ares/config_linux' ],
           'sources': [
-            'src/unix/linux/core.c',
+            'src/unix/linux/linux-core.c',
             'src/unix/linux/inotify.c',
             'src/unix/linux/syscalls.c',
             'src/unix/linux/syscalls.h',
@@ -302,10 +306,10 @@
         'test/test-async.c',
         'test/test-error.c',
         'test/test-callback-stack.c',
+        'test/test-callback-order.c',
         'test/test-connection-fail.c',
         'test/test-cwd-and-chdir.c',
         'test/test-delayed-accept.c',
-        'test/test-eio-overflow.c',
         'test/test-fail-always.c',
         'test/test-fs.c',
         'test/test-fs-event.c',
@@ -320,23 +324,33 @@
         'test/test-ipc-send-recv.c',
         'test/test-list.h',
         'test/test-loop-handles.c',
+        'test/test-walk-handles.c',
         'test/test-multiple-listen.c',
         'test/test-pass-always.c',
         'test/test-ping-pong.c',
         'test/test-pipe-bind-error.c',
         'test/test-pipe-connect-error.c',
         'test/test-platform-output.c',
+        'test/test-poll.c',
+        'test/test-poll-close.c',
         'test/test-process-title.c',
         'test/test-ref.c',
+        'test/test-run-once.c',
+        'test/test-semaphore.c',
         'test/test-shutdown-close.c',
         'test/test-shutdown-eof.c',
         'test/test-spawn.c',
+        'test/test-fs-poll.c',
         'test/test-stdio-over-pipes.c',
         'test/test-tcp-bind-error.c',
         'test/test-tcp-bind6-error.c',
         'test/test-tcp-close.c',
+        'test/test-tcp-close-while-connecting.c',
+        'test/test-tcp-connect-error-after-write.c',
+        'test/test-tcp-shutdown-after-write.c',
         'test/test-tcp-flags.c',
         'test/test-tcp-connect-error.c',
+        'test/test-tcp-connect-timeout.c',
         'test/test-tcp-connect6-error.c',
         'test/test-tcp-write-error.c',
         'test/test-tcp-write-to-half-open-connection.c',
@@ -390,8 +404,11 @@
       'dependencies': [ 'uv' ],
       'sources': [
         'test/benchmark-ares.c',
+        'test/benchmark-fs-stat.c',
         'test/benchmark-getaddrinfo.c',
         'test/benchmark-list.h',
+        'test/benchmark-loop-count.c',
+        'test/benchmark-million-timers.c',
         'test/benchmark-ping-pongs.c',
         'test/benchmark-pound.c',
         'test/benchmark-pump.c',