asyncengine 0.0.1.testing

data/ext/asyncengine_ext/libuv/test/runner.h

@@ -0,0 +1,159 @@
+/* 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.
+ */
+
+#ifndef RUNNER_H_
+#define RUNNER_H_
+
+#include <stdio.h> /* FILE */
+
+
+/*
+ * The maximum number of processes (main + helpers) that a test / benchmark
+ * can have.
+ */
+#define MAX_PROCESSES 8
+
+
+/*
+ * Struct to store both tests and to define helper processes for tasks.
+ */
+typedef struct {
+  char *task_name;
+  char *process_name;
+  int (*main)();
+  int is_helper;
+  int show_output;
+} task_entry_t, bench_entry_t;
+
+
+/*
+ * Macros used by test-list.h and benchmark-list.h.
+ */
+#define TASK_LIST_START                             \
+  task_entry_t TASKS[] = {
+
+#define TASK_LIST_END                               \
+    { 0, 0, 0, 0 }                                  \
+  };
+
+#define TEST_DECLARE(name)                          \
+  int run_test_##name();
+
+#define TEST_ENTRY(name)                            \
+    { #name, #name, &run_test_##name, 0, 0 },
+
+#define TEST_OUTPUT_ENTRY(name)                     \
+    { #name, #name, &run_test_##name, 0, 1 },
+
+#define BENCHMARK_DECLARE(name)                     \
+  int run_benchmark_##name();
+
+#define BENCHMARK_ENTRY(name)                       \
+    { #name, #name, &run_benchmark_##name, 0, 0 },
+
+#define HELPER_DECLARE(name)                        \
+  int run_helper_##name();
+
+#define HELPER_ENTRY(task_name, name)               \
+    { #task_name, #name, &run_helper_##name, 1, 0 },
+
+#define TEST_HELPER       HELPER_ENTRY
+#define BENCHMARK_HELPER  HELPER_ENTRY
+
+#define PATHMAX 1024
+extern char executable_path[PATHMAX];
+
+/*
+ * Include platform-dependent definitions
+ */
+#ifdef _WIN32
+# include "runner-win.h"
+#else
+# include "runner-unix.h"
+#endif
+
+
+/* The array that is filled by test-list.h or benchmark-list.h */
+extern task_entry_t TASKS[];
+
+/*
+ * Run all tests.
+ */
+int run_tests(int timeout, int benchmark_output);
+
+/*
+ * Run a single test. Starts up any helpers.
+ */
+int run_test(const char* test, int timeout, int benchmark_output);
+
+/*
+ * Run a test part, i.e. the test or one of its helpers.
+ */
+int run_test_part(const char* test, const char* part);
+
+
+/*
+ * Print tests in sorted order to `stream`. Used by `./run-tests --list`.
+ */
+void print_tests(FILE* stream);
+
+
+/*
+ * Stuff that should be implemented by test-runner-<platform>.h
+ * All functions return 0 on success, -1 on failure, unless specified
+ * otherwise.
+ */
+
+/* Do platform-specific initialization. */
+void platform_init();
+
+/* Invoke "argv[0] test-name [test-part]". Store process info in *p. */
+/* Make sure that all stdio output of the processes is buffered up. */
+int process_start(char *name, char* part, process_info_t *p);
+
+/* Wait for all `n` processes in `vec` to terminate. */
+/* Time out after `timeout` msec, or never if timeout == -1 */
+/* Return 0 if all processes are terminated, -1 on error, -2 on timeout. */
+int process_wait(process_info_t *vec, int n, int timeout);
+
+/* Returns the number of bytes in the stdio output buffer for process `p`. */
+long int process_output_size(process_info_t *p);
+
+/* Copy the contents of the stdio output buffer to `fd`. */
+int process_copy_output(process_info_t *p, int fd);
+
+/* Return the name that was specified when `p` was started by process_start */
+char* process_get_name(process_info_t *p);
+
+/* Terminate process `p`. */
+int process_terminate(process_info_t *p);
+
+/* Return the exit code of process p. */
+/* On error, return -1. */
+int process_reap(process_info_t *p);
+
+/* Clean up after terminating process `p` (e.g. free the output buffer etc.). */
+void process_cleanup(process_info_t *p);
+
+/* Move the console cursor one line up and back to the first column. */
+void rewind_cursor();
+
+#endif /* RUNNER_H_ */

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

@@ -0,0 +1,117 @@
+/* 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.
+ */
+
+#ifndef TASK_H_
+#define TASK_H_
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define TEST_PORT 9123
+#define TEST_PORT_2 9124
+
+#ifdef _WIN32
+# define TEST_PIPENAME "\\\\.\\pipe\\uv-test"
+# define TEST_PIPENAME_2 "\\\\.\\pipe\\uv-test2"
+#else
+# define TEST_PIPENAME "/tmp/uv-test-sock"
+# define TEST_PIPENAME_2 "/tmp/uv-test-sock2"
+#endif
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+#define container_of(ptr, type, member) \
+  ((type *) ((char *) (ptr) - offsetof(type, member)))
+
+typedef enum {
+  TCP = 0,
+  UDP,
+  PIPE
+} stream_type;
+
+/* Log to stderr. */
+#define LOG(...)                        \
+  do {                                  \
+    fprintf(stderr, "%s", __VA_ARGS__); \
+    fflush(stderr);                     \
+  } while (0)
+
+#define LOGF(...)                       \
+  do {                                  \
+    fprintf(stderr, __VA_ARGS__);       \
+    fflush(stderr);                     \
+  } while (0)
+
+/* Die with fatal error. */
+#define FATAL(msg)                                        \
+  do {                                                    \
+    fprintf(stderr,                                       \
+            "Fatal error in %s on line %d: %s\n",         \
+            __FILE__,                                     \
+            __LINE__,                                     \
+            msg);                                         \
+    fflush(stderr);                                       \
+    abort();                                              \
+  } while (0)
+
+
+
+/* Have our own assert, so we are sure it does not get optimized away in
+ * a release build.
+ */
+#define ASSERT(expr)                                      \
+ do {                                                     \
+  if (!(expr)) {                                          \
+    fprintf(stderr,                                       \
+            "Assertion failed in %s on line %d: %s\n",    \
+            __FILE__,                                     \
+            __LINE__,                                     \
+            #expr);                                       \
+    abort();                                              \
+  }                                                       \
+ } while (0)
+
+
+/* Just sugar for wrapping the main() for a task or helper. */
+#define TEST_IMPL(name)   \
+  int run_test_##name()
+
+#define BENCHMARK_IMPL(name)  \
+  int run_benchmark_##name()
+
+#define HELPER_IMPL(name)  \
+  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);
+
+#endif /* TASK_H_ */

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

@@ -0,0 +1,216 @@
+/* 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>
+
+
+static uv_prepare_t prepare_handle;
+
+static uv_async_t async1_handle;
+/* static uv_handle_t async2_handle; */
+
+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;
+
+      case 1:
+        uv_async_send(&async2_handle);
+        break;
+
+      case 2:
+        uv_async_send(&async2_handle);
+        break;
+    }
+    uv_sleep(5);
+  }
+
+  if (async1_cb_called == 20) {
+    uv_close(handle);
+  }
+}
+
+
+/* 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);
+  }
+}
+
+
+#if 0
+static void async2_cb(uv_handle_t* handle, int status) {
+  ASSERT(handle == &async2_handle);
+  ASSERT(status == 0);
+
+  async2_cb_called++;
+  printf("async2_cb #%d\n", async2_cb_called);
+
+  if (async2_cb_called == 16) {
+    uv_close(handle);
+  }
+}
+#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
+
+    case 1:
+      uv_close((uv_handle_t*)handle, close_cb);
+      break;
+
+    default:
+      FATAL("Should never get here");
+  }
+
+  prepare_cb_called++;
+}
+
+
+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);
+  ASSERT(r == 0);
+
+  r = uv_async_init(uv_default_loop(), &async1_handle, async1_cb);
+  ASSERT(r == 0);
+
+#if 0
+  r = uv_async_init(&async2_handle, async2_cb, close_cb, NULL);
+  ASSERT(r == 0);
+#endif
+
+  r = uv_run(uv_default_loop());
+  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);
+  ASSERT(r == 0);
+#endif
+
+  ASSERT(prepare_cb_called == 2);
+  ASSERT(async1_cb_called > 2);
+  /* ASSERT(async2_cb_called = 16); */
+  ASSERT(close_cb_called == 2);
+
+  return 0;
+}

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

@@ -0,0 +1,203 @@
+/* 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.
+ */
+
+/*
+ * TODO: Add explanation of why we want on_close to be called from fresh
+ * stack.
+ */
+
+#include "uv.h"
+#include "task.h"
+
+
+static const char MESSAGE[] = "Failure is for the weak. Everyone dies alone.";
+
+static uv_tcp_t client;
+static uv_timer_t timer;
+static uv_connect_t connect_req;
+static uv_write_t write_req;
+static uv_shutdown_t shutdown_req;
+
+static int nested = 0;
+static int close_cb_called = 0;
+static int connect_cb_called = 0;
+static int write_cb_called = 0;
+static int timer_cb_called = 0;
+static int bytes_received = 0;
+static int shutdown_cb_called = 0;
+
+
+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);
+  ASSERT(buf.base);
+  return buf;
+}
+
+
+static void close_cb(uv_handle_t* handle) {
+  ASSERT(nested == 0 && "close_cb must be called from a fresh stack");
+
+  close_cb_called++;
+}
+
+
+static void shutdown_cb(uv_shutdown_t* req, int status) {
+  ASSERT(status == 0);
+  ASSERT(nested == 0 && "shutdown_cb must be called from a fresh stack");
+
+  shutdown_cb_called++;
+}
+
+
+static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+  ASSERT(nested == 0 && "read_cb must be called from a fresh stack");
+
+  printf("Read. nread == %d\n", (int)nread);
+  free(buf.base);
+
+  if (nread == 0) {
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EAGAIN);
+    return;
+
+  } else if (nread == -1) {
+    ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);
+
+    nested++;
+    uv_close((uv_handle_t*)tcp, close_cb);
+    nested--;
+
+    return;
+  }
+
+  bytes_received += nread;
+
+  /* We call shutdown here because when bytes_received == sizeof MESSAGE */
+  /* there will be no more data sent nor received, so here it would be */
+  /* possible for a backend to to call shutdown_cb immediately and *not* */
+  /* from a fresh stack. */
+  if (bytes_received == sizeof MESSAGE) {
+    nested++;
+
+    puts("Shutdown");
+
+    if (uv_shutdown(&shutdown_req, (uv_stream_t*)tcp, shutdown_cb)) {
+      FATAL("uv_shutdown failed");
+    }
+    nested--;
+  }
+}
+
+
+static void timer_cb(uv_timer_t* handle, int status) {
+  ASSERT(handle == &timer);
+  ASSERT(status == 0);
+  ASSERT(nested == 0 && "timer_cb must be called from a fresh stack");
+
+  puts("Timeout complete. Now read data...");
+
+  nested++;
+  if (uv_read_start((uv_stream_t*)&client, alloc_cb, read_cb)) {
+    FATAL("uv_read_start failed");
+  }
+  nested--;
+
+  timer_cb_called++;
+
+  uv_close((uv_handle_t*)handle, close_cb);
+}
+
+
+static void write_cb(uv_write_t* req, int status) {
+  int r;
+
+  ASSERT(status == 0);
+  ASSERT(nested == 0 && "write_cb must be called from a fresh stack");
+
+  puts("Data written. 500ms timeout...");
+
+  /* After the data has been sent, we're going to wait for a while, then */
+  /* start reading. This makes us certain that the message has been echoed */
+  /* back to our receive buffer when we start reading. This maximizes the */
+  /* temptation for the backend to use dirty stack for calling read_cb. */
+  nested++;
+  r = uv_timer_init(uv_default_loop(), &timer);
+  ASSERT(r == 0);
+  r = uv_timer_start(&timer, timer_cb, 500, 0);
+  ASSERT(r == 0);
+  nested--;
+
+  write_cb_called++;
+}
+
+
+static void connect_cb(uv_connect_t* req, int status) {
+  uv_buf_t buf;
+
+  puts("Connected. Write some data to echo server...");
+
+  ASSERT(status == 0);
+  ASSERT(nested == 0 && "connect_cb must be called from a fresh stack");
+
+  nested++;
+
+  buf.base = (char*) &MESSAGE;
+  buf.len = sizeof MESSAGE;
+
+  if (uv_write(&write_req, (uv_stream_t*)req->handle, &buf, 1, write_cb)) {
+    FATAL("uv_write failed");
+  }
+
+  nested--;
+
+  connect_cb_called++;
+}
+
+
+TEST_IMPL(callback_stack) {
+  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+
+  if (uv_tcp_init(uv_default_loop(), &client)) {
+    FATAL("uv_tcp_init failed");
+  }
+
+  puts("Connecting...");
+
+  nested++;
+
+  if (uv_tcp_connect(&connect_req, &client, addr, connect_cb)) {
+    FATAL("uv_tcp_connect failed");
+  }
+  nested--;
+
+  uv_run(uv_default_loop());
+
+  ASSERT(nested == 0);
+  ASSERT(connect_cb_called == 1 && "connect_cb must be called exactly once");
+  ASSERT(write_cb_called == 1 && "write_cb must be called exactly once");
+  ASSERT(timer_cb_called == 1 && "timer_cb must be called exactly once");
+  ASSERT(bytes_received == sizeof MESSAGE);
+  ASSERT(shutdown_cb_called == 1 && "shutdown_cb must be called exactly once");
+  ASSERT(close_cb_called == 2 && "close_cb must be called exactly twice");
+
+  return 0;
+}