asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/test/runner.c

@@ -19,6 +19,7 @@
  * IN THE SOFTWARE.
  */
 
+#include <stdio.h>
 #include <string.h>
 
 #include "runner.h"
@@ -28,7 +29,10 @@ char executable_path[PATHMAX] = { '\0' };
 
 
 static void log_progress(int total, int passed, int failed, const char* name) {
-  LOGF("[%% %3d|+ %3d|- %3d]: %s", (passed + failed) / total * 100,
+  if (total == 0)
+    total = 1;
+
+  LOGF("[%% %3d|+ %3d|- %3d]: %s", (int) ((passed + failed) / ((double) total) * 100.0),
       passed, failed, name);
 }
 
@@ -89,6 +93,11 @@ int run_test(const char* test, int timeout, int benchmark_output) {
   main_proc = NULL;
   process_count = 0;
 
+#ifndef _WIN32
+  /* Clean up stale socket from previous run. */
+  remove(TEST_PIPENAME);
+#endif
+
   /* If it's a helper the user asks for, start it directly. */
   for (task = TASKS; task->main; task++) {
     if (task->is_helper && strcmp(test, task->process_name) == 0) {

data/ext/asyncengine/libuv/test/task.h

@@ -103,14 +103,6 @@ typedef enum {
   int run_helper_##name()
 
 
-/* Create a thread. Returns the thread identifier, or 0 on failure. */
-uintptr_t uv_create_thread(void (*entry)(void* arg), void* arg);
-
-/* Wait for a thread to terminate. Should return 0 if the thread ended, -1 on
- * error.
- */
-int uv_wait_thread(uintptr_t thread_id);
-
 /* Pause the calling thread for a number of milliseconds. */
 void uv_sleep(int msec);
 

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

@@ -24,192 +24,94 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+static uv_thread_t thread;
+static uv_mutex_t mutex;
 
-static uv_prepare_t prepare_handle;
+static uv_prepare_t prepare;
+static uv_async_t async;
 
-static uv_async_t async1_handle;
-/* static uv_handle_t async2_handle; */
+static volatile int async_cb_called;
+static int prepare_cb_called;
+static int close_cb_called;
 
-static int prepare_cb_called = 0;
 
-static volatile int async1_cb_called = 0;
-static int async1_closed = 0;
-/* static volatile int async2_cb_called = 0; */
-
-static int close_cb_called = 0;
-
-static uintptr_t thread1_id = 0;
-#if 0
-static uintptr_t thread2_id = 0;
-static uintptr_t thread3_id = 0;
-#endif
-
-
-/* Thread 1 makes sure that async1_cb_called reaches 3 before exiting. */
-void thread1_entry(void *arg) {
-  uv_sleep(50);
-
-  while (1) {
-    switch (async1_cb_called) {
-      case 0:
-        uv_async_send(&async1_handle);
-        break;
-
-      case 1:
-        uv_async_send(&async1_handle);
-        break;
-
-      case 2:
-        uv_async_send(&async1_handle);
-        break;
-
-      default:
-        return;
-    }
-  }
-}
-
-#if 0
-/* Thread 2 calls uv_async_send on async_handle_2 8 times. */
-void thread2_entry(void *arg) {
-  int i;
-
-  while (1) {
-    switch (async1_cb_called) {
-      case 0:
-        uv_async_send(&async2_handle);
-        break;
+void thread_cb(void *arg) {
+  int n;
+  int r;
 
-      case 1:
-        uv_async_send(&async2_handle);
-        break;
+  for (;;) {
+    uv_mutex_lock(&mutex);
+    n = async_cb_called;
+    uv_mutex_unlock(&mutex);
 
-      case 2:
-        uv_async_send(&async2_handle);
-        break;
+    if (n == 3) {
+      break;
     }
-    uv_sleep(5);
-  }
 
-  if (async1_cb_called == 20) {
-    uv_close(handle);
+    r = uv_async_send(&async);
+    ASSERT(r == 0);
   }
 }
 
 
-/* Thread 3 calls uv_async_send on async_handle_2 8 times
- * after waiting half a second first.
- */
-void thread3_entry(void *arg) {
-  int i;
-
-  for (i = 0; i < 8; i++) {
-    uv_async_send(&async2_handle);
-  }
-}
-#endif
-
-
 static void close_cb(uv_handle_t* handle) {
   ASSERT(handle != NULL);
   close_cb_called++;
 }
 
 
-static void async1_cb(uv_async_t* handle, int status) {
-  ASSERT(handle == &async1_handle);
-  ASSERT(status == 0);
-
-  async1_cb_called++;
-  printf("async1_cb #%d\n", async1_cb_called);
-
-  if (async1_cb_called > 2 && !async1_closed) {
-    async1_closed = 1;
-    uv_close((uv_handle_t*)handle, close_cb);
-  }
-}
-
+static void async_cb(uv_async_t* handle, int status) {
+  int n;
 
-#if 0
-static void async2_cb(uv_handle_t* handle, int status) {
-  ASSERT(handle == &async2_handle);
+  ASSERT(handle == &async);
   ASSERT(status == 0);
 
-  async2_cb_called++;
-  printf("async2_cb #%d\n", async2_cb_called);
+  uv_mutex_lock(&mutex);
+  n = ++async_cb_called;
+  uv_mutex_unlock(&mutex);
 
-  if (async2_cb_called == 16) {
-    uv_close(handle);
+  if (n == 3) {
+    uv_close((uv_handle_t*)&async, close_cb);
+    uv_close((uv_handle_t*)&prepare, close_cb);
   }
 }
-#endif
 
 
 static void prepare_cb(uv_prepare_t* handle, int status) {
-  ASSERT(handle == &prepare_handle);
-  ASSERT(status == 0);
-
-  switch (prepare_cb_called) {
-    case 0:
-      thread1_id = uv_create_thread(thread1_entry, NULL);
-      ASSERT(thread1_id != 0);
-      break;
-
-#if 0
-    case 1:
-      thread2_id = uv_create_thread(thread2_entry, NULL);
-      ASSERT(thread2_id != 0);
-      break;
-
-    case 2:
-      thread3_id = uv_create_thread(thread3_entry, NULL);
-      ASSERT(thread3_id != 0);
-      break;
-#endif
+  int r;
 
-    case 1:
-      uv_close((uv_handle_t*)handle, close_cb);
-      break;
+  ASSERT(handle == &prepare);
+  ASSERT(status == 0);
 
-    default:
-      FATAL("Should never get here");
-  }
+  if (prepare_cb_called++)
+    return;
 
-  prepare_cb_called++;
+  r = uv_thread_create(&thread, thread_cb, NULL);
+  ASSERT(r == 0);
+  uv_mutex_unlock(&mutex);
 }
 
 
 TEST_IMPL(async) {
   int r;
 
-  r = uv_prepare_init(uv_default_loop(), &prepare_handle);
-  ASSERT(r == 0);
-  r = uv_prepare_start(&prepare_handle, prepare_cb);
+  r = uv_mutex_init(&mutex);
   ASSERT(r == 0);
+  uv_mutex_lock(&mutex);
 
-  r = uv_async_init(uv_default_loop(), &async1_handle, async1_cb);
+  r = uv_prepare_init(uv_default_loop(), &prepare);
   ASSERT(r == 0);
-
-#if 0
-  r = uv_async_init(&async2_handle, async2_cb, close_cb, NULL);
+  r = uv_prepare_start(&prepare, prepare_cb);
   ASSERT(r == 0);
-#endif
 
-  r = uv_run(uv_default_loop());
+  r = uv_async_init(uv_default_loop(), &async, async_cb);
   ASSERT(r == 0);
 
-  r = uv_wait_thread(thread1_id);
-  ASSERT(r == 0);
-#if 0
-  r = uv_wait_thread(thread2_id);
-  ASSERT(r == 0);
-  r = uv_wait_thread(thread3_id);
+  r = uv_run(uv_default_loop());
   ASSERT(r == 0);
-#endif
 
-  ASSERT(prepare_cb_called == 2);
-  ASSERT(async1_cb_called > 2);
-  /* ASSERT(async2_cb_called = 16); */
+  ASSERT(prepare_cb_called > 0);
+  ASSERT(async_cb_called == 3);
   ASSERT(close_cb_called == 2);
 
   return 0;

data/ext/asyncengine/libuv/test/test-callback-order.c

@@ -0,0 +1,76 @@
+/* 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 idle_cb_called;
+static int timer_cb_called;
+
+static uv_idle_t idle_handle;
+static uv_timer_t timer_handle;
+
+
+/* idle_cb should run before timer_cb */
+static void idle_cb(uv_idle_t* handle, int status) {
+  ASSERT(idle_cb_called == 0);
+  ASSERT(timer_cb_called == 0);
+  uv_idle_stop(handle);
+  idle_cb_called++;
+}
+
+
+static void timer_cb(uv_timer_t* handle, int status) {
+  ASSERT(idle_cb_called == 1);
+  ASSERT(timer_cb_called == 0);
+  uv_timer_stop(handle);
+  timer_cb_called++;
+}
+
+
+static void next_tick(uv_idle_t* handle, int status) {
+  uv_loop_t* loop = handle->loop;
+  uv_idle_stop(handle);
+  uv_idle_init(loop, &idle_handle);
+  uv_idle_start(&idle_handle, idle_cb);
+  uv_timer_init(loop, &timer_handle);
+  uv_timer_start(&timer_handle, timer_cb, 0, 0);
+}
+
+
+TEST_IMPL(callback_order) {
+  uv_loop_t* loop;
+  uv_idle_t idle;
+
+  loop = uv_default_loop();
+  uv_idle_init(loop, &idle);
+  uv_idle_start(&idle, next_tick);
+
+  ASSERT(idle_cb_called == 0);
+  ASSERT(timer_cb_called == 0);
+
+  uv_run(loop);
+
+  ASSERT(idle_cb_called == 1);
+  ASSERT(timer_cb_called == 1);
+
+  return 0;
+}

data/ext/asyncengine/libuv/test/test-counters-init.c

@@ -78,7 +78,7 @@ static void create_dir(uv_loop_t* loop, const char* name) {
   uv_fs_t req;
   r = uv_fs_rmdir(loop, &req, name, NULL);
   r = uv_fs_mkdir(loop, &req, name, 0755, NULL);
-  ASSERT(r == 0);
+  ASSERT(r == 0 || uv_last_error(loop).code == UV_EEXIST);
   uv_fs_req_cleanup(&req);
 }
 
@@ -208,8 +208,7 @@ TEST_IMPL(counters_init) {
   r = uv_fs_event_init(uv_default_loop(), &fs_event, "watch_dir", NULL, 0);
   ASSERT(r == 0);
   ASSERT(uv_default_loop()->counters.fs_event_init == ++fs_event_init_prev);
-  r = uv_fs_rmdir(uv_default_loop(), &fs_req, "watch_dir", NULL);
-  ASSERT(r == 0);
+  uv_fs_rmdir(uv_default_loop(), &fs_req, "watch_dir", NULL);
   uv_fs_req_cleanup(&fs_req);
 
   return 0;

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

@@ -23,8 +23,12 @@
 #include "task.h"
 #include <string.h>
 
-const char* path = "test/fixtures/load_error.node";
-const char* msg;
+
+TEST_IMPL(dlerror) {
+  const char* path = "test/fixtures/load_error.node";
+  const char* msg;
+  uv_lib_t lib;
+  int r;
 
 #ifdef __linux__
   const char* dlerror_desc = "file too short";
@@ -36,14 +40,19 @@ const char* msg;
   const char* dlerror_desc = "";
 #endif
 
-uv_lib_t lib;
-uv_err_t r;
-
-TEST_IMPL(dlerror) {
   r = uv_dlopen(path, &lib);
-  msg = uv_dlerror(lib);
+  ASSERT(r == -1);
+
+  msg = uv_dlerror(&lib);
   ASSERT(msg != NULL);
   ASSERT(strstr(msg, dlerror_desc) != NULL);
-  uv_dlerror_free(lib, msg);
+
+  /* Should return the same error twice in a row. */
+  msg = uv_dlerror(&lib);
+  ASSERT(msg != NULL);
+  ASSERT(strstr(msg, dlerror_desc) != NULL);
+
+  uv_dlclose(&lib);
+
   return 0;
 }

data/ext/asyncengine/libuv/test/test-fs-event.c

@@ -38,6 +38,26 @@ static int close_cb_called = 0;
 static int fs_event_cb_called = 0;
 static int timer_cb_touch_called = 0;
 
+static void cleanup_watch_dir() {
+  uv_loop_t* loop = uv_default_loop();
+  uv_fs_t readdir_req;
+  int i, r;
+  char *buffer, *name;
+
+  r = uv_fs_readdir(loop, &readdir_req, "watch_dir", 0, NULL);
+  buffer = readdir_req.ptr;
+  uv_chdir("watch_dir");
+  for (i = 0; i < readdir_req.result; i++) {
+    name = buffer;
+    r = remove(name);
+    ASSERT(r == 0);
+    buffer += strlen(name) + 1;
+  }
+  uv_chdir("..");
+  r = remove("watch_dir");
+  ASSERT(r == 0 || uv_last_error(loop).code == UV_ENOENT);
+}
+
 static void create_dir(uv_loop_t* loop, const char* name) {
   int r;
   uv_fs_t req;
@@ -160,14 +180,11 @@ static void timer_cb_touch(uv_timer_t* timer, int status) {
 }
 
 TEST_IMPL(fs_event_watch_dir) {
-  uv_fs_t fs_req;
   uv_loop_t* loop = uv_default_loop();
   int r;
 
   /* Setup */
-  uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  uv_fs_unlink(loop, &fs_req, "watch_dir/file2", NULL);
-  uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
+  cleanup_watch_dir();
   create_dir(loop, "watch_dir");
 
   r = uv_fs_event_init(loop, &fs_event, "watch_dir", fs_event_cb_dir, 0);
@@ -184,22 +201,15 @@ TEST_IMPL(fs_event_watch_dir) {
   ASSERT(close_cb_called == 2);
 
   /* Cleanup */
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file2", NULL);
-  r = uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
-
+  cleanup_watch_dir();
   return 0;
 }
 
 TEST_IMPL(fs_event_watch_file) {
-  uv_fs_t fs_req;
   uv_loop_t* loop = uv_default_loop();
   int r;
 
   /* Setup */
-  uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  uv_fs_unlink(loop, &fs_req, "watch_dir/file2", NULL);
-  uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
   create_dir(loop, "watch_dir");
   create_file(loop, "watch_dir/file1");
   create_file(loop, "watch_dir/file2");
@@ -218,10 +228,7 @@ TEST_IMPL(fs_event_watch_file) {
   ASSERT(close_cb_called == 2);
 
   /* Cleanup */
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file2", NULL);
-  r = uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
-
+  cleanup_watch_dir();
   return 0;
 }
 
@@ -264,13 +271,11 @@ TEST_IMPL(fs_event_watch_file_current_dir) {
 
 
 TEST_IMPL(fs_event_no_callback_on_close) {
-  uv_fs_t fs_req;
   uv_loop_t* loop = uv_default_loop();
   int r;
 
   /* Setup */
-  uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
+  cleanup_watch_dir();
   create_dir(loop, "watch_dir");
   create_file(loop, "watch_dir/file1");
 
@@ -289,8 +294,7 @@ TEST_IMPL(fs_event_no_callback_on_close) {
   ASSERT(close_cb_called == 1);
 
   /* Cleanup */
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  r = uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
+  cleanup_watch_dir();
 
   return 0;
 }
@@ -338,11 +342,12 @@ TEST_IMPL(fs_event_immediate_close) {
 
 TEST_IMPL(fs_event_close_with_pending_event) {
   uv_loop_t* loop;
-  uv_fs_t fs_req;
   int r;
 
   loop = uv_default_loop();
 
+  cleanup_watch_dir();
+
   create_dir(loop, "watch_dir");
   create_file(loop, "watch_dir/file");
 
@@ -359,10 +364,7 @@ TEST_IMPL(fs_event_close_with_pending_event) {
   ASSERT(close_cb_called == 1);
 
   /* Clean up */
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
-  ASSERT(r == 0);
+  cleanup_watch_dir();
 
   return 0;
 }
@@ -395,11 +397,12 @@ static void fs_event_cb_close(uv_fs_event_t* handle, const char* filename,
 
 TEST_IMPL(fs_event_close_in_callback) {
   uv_loop_t* loop;
-  uv_fs_t fs_req;
   int r;
 
   loop = uv_default_loop();
 
+  cleanup_watch_dir();
+
   create_dir(loop, "watch_dir");
   create_file(loop, "watch_dir/file1");
   create_file(loop, "watch_dir/file2");
@@ -423,18 +426,7 @@ TEST_IMPL(fs_event_close_in_callback) {
   ASSERT(fs_event_cb_called == 3);
 
   /* Clean up */
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file1", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file2", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file3", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file4", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_unlink(loop, &fs_req, "watch_dir/file5", NULL);
-  ASSERT(r == 0);
-  r = uv_fs_rmdir(loop, &fs_req, "watch_dir", NULL);
-  ASSERT(r == 0);
+  cleanup_watch_dir();
 
   return 0;
 }