noderb 0.0.2

data/ext/noderb_extension/libuv/test/runner-win.c

@@ -0,0 +1,343 @@
+/* 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 <io.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <process.h>
+#include <windows.h>
+
+#include "task.h"
+#include "runner.h"
+
+
+/*
+ * Define the stuff that MinGW doesn't have
+ */
+#ifndef GetFileSizeEx
+  WINBASEAPI BOOL WINAPI GetFileSizeEx(HANDLE hFile,
+                                       PLARGE_INTEGER lpFileSize);
+#endif
+
+
+/* Do platform-specific initialization. */
+void platform_init(int argc, char **argv) {
+  /* Disable the "application crashed" popup. */
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+      SEM_NOOPENFILEERRORBOX);
+
+  /* Disable stdio output buffering. */
+  setvbuf(stdout, NULL, _IONBF, 0);
+  setvbuf(stderr, NULL, _IONBF, 0);
+
+  strcpy(executable_path, argv[0]);
+}
+
+
+int process_start(char *name, char *part, process_info_t *p) {
+  HANDLE file = INVALID_HANDLE_VALUE;
+  HANDLE nul = INVALID_HANDLE_VALUE;
+  WCHAR path[MAX_PATH], filename[MAX_PATH];
+  WCHAR image[MAX_PATH + 1];
+  WCHAR args[MAX_PATH * 2];
+  STARTUPINFOW si;
+  PROCESS_INFORMATION pi;
+  DWORD result;
+
+  if (GetTempPathW(sizeof(path) / sizeof(WCHAR), (WCHAR*)&path) == 0)
+    goto error;
+  if (GetTempFileNameW((WCHAR*)&path, L"uv", 0, (WCHAR*)&filename) == 0)
+    goto error;
+
+  file = CreateFileW((WCHAR*)filename,
+                     GENERIC_READ | GENERIC_WRITE,
+                     0,
+                     NULL,
+                     CREATE_ALWAYS,
+                     FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
+                     NULL);
+  if (file == INVALID_HANDLE_VALUE)
+    goto error;
+
+  if (!SetHandleInformation(file, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
+    goto error;
+
+  nul = CreateFileA("nul",
+                    GENERIC_READ,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE,
+                    NULL,
+                    OPEN_EXISTING,
+                    FILE_ATTRIBUTE_NORMAL,
+                    NULL);
+  if (nul == INVALID_HANDLE_VALUE)
+    goto error;
+
+  if (!SetHandleInformation(nul, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
+    goto error;
+
+  result = GetModuleFileNameW(NULL, (WCHAR*)&image, sizeof(image) / sizeof(WCHAR));
+  if (result == 0 || result == sizeof(image))
+    goto error;
+
+  if (part) {
+    if (_snwprintf((wchar_t*)args,
+                   sizeof(args) / sizeof(wchar_t),
+                   L"\"%s\" %S %S",
+                   image,
+                   name,
+                   part) < 0) {
+      goto error;
+    }
+  } else {
+    if (_snwprintf((wchar_t*)args,
+                   sizeof(args) / sizeof(wchar_t),
+                   L"\"%s\" %S",
+                   image,
+                   name) < 0) {
+      goto error;
+    }
+  }
+
+  memset((void*)&si, 0, sizeof(si));
+  si.cb = sizeof(si);
+  si.dwFlags = STARTF_USESTDHANDLES;
+  si.hStdInput = nul;
+  si.hStdOutput = file;
+  si.hStdError = file;
+
+  if (!CreateProcessW(image, args, NULL, NULL, TRUE,
+                      0, NULL, NULL, &si, &pi))
+    goto error;
+
+  CloseHandle(pi.hThread);
+
+  SetHandleInformation(nul, HANDLE_FLAG_INHERIT, 0);
+  SetHandleInformation(file, HANDLE_FLAG_INHERIT, 0);
+
+  p->stdio_in = nul;
+  p->stdio_out = file;
+  p->process = pi.hProcess;
+  p->name = name;
+
+  return 0;
+
+error:
+  if (file != INVALID_HANDLE_VALUE)
+    CloseHandle(file);
+  if (nul != INVALID_HANDLE_VALUE)
+    CloseHandle(nul);
+
+  return -1;
+}
+
+
+/* Timeout is is msecs. Set timeout < 0 to never time out. */
+/* Returns 0 when all processes are terminated, -2 on timeout. */
+int process_wait(process_info_t *vec, int n, int timeout) {
+  int i;
+  HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+  DWORD timeout_api, result;
+
+  /* If there's nothing to wait for, return immedately. */
+  if (n == 0)
+    return 0;
+
+  ASSERT(n <= MAXIMUM_WAIT_OBJECTS);
+
+  for (i = 0; i < n; i++)
+    handles[i] = vec[i].process;
+
+  if (timeout >= 0) {
+    timeout_api = (DWORD)timeout;
+  } else {
+    timeout_api = INFINITE;
+  }
+
+  result = WaitForMultipleObjects(n, handles, TRUE, timeout_api);
+
+  if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + n) {
+    /* All processes are terminated. */
+    return 0;
+  }
+  if (result == WAIT_TIMEOUT) {
+    return -2;
+  }
+  return -1;
+}
+
+
+long int process_output_size(process_info_t *p) {
+  LARGE_INTEGER size;
+  if (!GetFileSizeEx(p->stdio_out, &size))
+    return -1;
+  return (long int)size.QuadPart;
+}
+
+
+int process_copy_output(process_info_t *p, int fd) {
+  DWORD read;
+  char buf[1024];
+
+  if (SetFilePointer(p->stdio_out, 0, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+    return -1;
+
+  while (ReadFile(p->stdio_out, (void*)&buf, sizeof(buf), &read, NULL) &&
+         read > 0)
+    write(fd, buf, read);
+
+  if (GetLastError() != ERROR_HANDLE_EOF)
+    return -1;
+
+  return 0;
+}
+
+
+char* process_get_name(process_info_t *p) {
+  return p->name;
+}
+
+
+int process_terminate(process_info_t *p) {
+  if (!TerminateProcess(p->process, 1))
+    return -1;
+  return 0;
+}
+
+
+int process_reap(process_info_t *p) {
+  DWORD exitCode;
+  if (!GetExitCodeProcess(p->process, &exitCode))
+    return -1;
+  return (int)exitCode;
+}
+
+
+void process_cleanup(process_info_t *p) {
+  CloseHandle(p->process);
+  CloseHandle(p->stdio_in);
+  CloseHandle(p->stdio_out);
+}
+
+
+static int clear_line() {
+  HANDLE handle;
+  CONSOLE_SCREEN_BUFFER_INFO info;
+  COORD coord;
+  DWORD written;
+
+  handle = (HANDLE)_get_osfhandle(fileno(stderr));
+  if (handle == INVALID_HANDLE_VALUE)
+    return -1;
+
+  if (!GetConsoleScreenBufferInfo(handle, &info))
+    return -1;
+
+  coord = info.dwCursorPosition;
+  if (coord.Y <= 0)
+    return -1;
+
+  coord.X = 0;
+
+  if (!SetConsoleCursorPosition(handle, coord))
+    return -1;
+
+  if (!FillConsoleOutputCharacterW(handle, 0x20, info.dwSize.X, coord, &written))
+    return -1;
+
+  return 0;
+}
+
+
+void rewind_cursor() {
+  if (clear_line() == -1) {
+    /* If clear_line fails (stdout is not a console), print a newline. */
+    fprintf(stderr, "\n");
+  }
+}
+
+
+typedef struct {
+  void (*entry)(void* arg);
+  void* arg;
+} thread_info_t;
+
+
+static unsigned __stdcall create_thread_helper(void* info) {
+  /* Copy thread info locally, then free it */
+  void (*entry)(void* arg) = ((thread_info_t*) info)->entry;
+  void* arg = ((thread_info_t*) info)->arg;
+
+  free(info);
+
+  /* Run the actual thread proc */
+  entry(arg);
+
+  /* Finalize */
+  _endthreadex(0);
+  return 0;
+}
+
+
+/* Create a thread. Returns the thread identifier, or 0 on failure. */
+uintptr_t uv_create_thread(void (*entry)(void* arg), void* arg) {
+  uintptr_t result;
+  thread_info_t* info;
+
+  info = (thread_info_t*) malloc(sizeof *info);
+  if (info == NULL) {
+    return 0;
+  }
+
+  info->entry = entry;
+  info->arg = arg;
+
+  result = _beginthreadex(NULL,
+                          0,
+                          &create_thread_helper,
+                          (void*) info,
+                          0,
+                          NULL);
+
+  if (result == 0) {
+    free(info);
+    return 0;
+  }
+
+  return result;
+}
+
+
+/* Wait for a thread to terminate. Should return 0 if the thread ended, -1 on
+ * error.
+ */
+int uv_wait_thread(uintptr_t thread_id) {
+  if (WaitForSingleObject((HANDLE)thread_id, INFINITE) != WAIT_OBJECT_0) {
+    return -1;
+  }
+
+  return 0;
+}
+
+
+/* Pause the calling thread for a number of milliseconds. */
+void uv_sleep(int msec) {
+  Sleep(msec);
+}

data/ext/noderb_extension/libuv/test/runner-win.h

@@ -0,0 +1,42 @@
+/* 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.
+ */
+
+/* Don't complain about _snprintf being unsecure. */
+#define _CRT_SECURE_NO_WARNINGS
+
+/* Dont complain about write(), fileno() etc. being deprecated. */
+#pragma warning(disable : 4996)
+
+
+#include <windows.h>
+#include <stdio.h>
+
+
+/* Windows has no snprintf, only _snprintf. */
+#define snprintf _snprintf
+
+
+typedef struct {
+  HANDLE process;
+  HANDLE stdio_in;
+  HANDLE stdio_out;
+  char *name;
+} process_info_t;

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

@@ -0,0 +1,311 @@
+/* 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 <string.h>
+
+#include "runner.h"
+#include "task.h"
+
+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,
+      passed, failed, name);
+}
+
+
+int run_tests(int timeout, int benchmark_output) {
+  int total, passed, failed;
+  task_entry_t* task;
+
+  /* Count the number of tests. */
+  total = 0;
+  for (task = TASKS; task->main; task++) {
+    if (!task->is_helper) {
+      total++;
+    }
+  }
+
+  /* Run all tests. */
+  passed = 0;
+  failed = 0;
+  for (task = TASKS; task->main; task++) {
+    if (task->is_helper) {
+      continue;
+    }
+
+    rewind_cursor();
+    if (!benchmark_output) {
+      log_progress(total, passed, failed, task->task_name);
+    }
+
+    if (run_test(task->task_name, timeout, benchmark_output) == 0) {
+      passed++;
+    } else {
+      failed++;
+    }
+  }
+
+  rewind_cursor();
+
+  if (!benchmark_output) {
+    log_progress(total, passed, failed, "Done.\n");
+  }
+
+  return 0;
+}
+
+
+int run_test(const char* test, int timeout, int benchmark_output) {
+  char errmsg[1024] = "no error";
+  process_info_t processes[1024];
+  process_info_t *main_proc;
+  task_entry_t* task;
+  int process_count;
+  int result;
+  int status;
+  int i;
+
+  status = 255;
+  process_count = 0;
+
+  /* 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) {
+      return task->main();
+    }
+  }
+
+  /* Start the helpers first. */
+  for (task = TASKS; task->main; task++) {
+    if (strcmp(test, task->task_name) != 0) {
+      continue;
+    }
+
+    /* Skip the test itself. */
+    if (!task->is_helper) {
+      continue;
+    }
+
+    if (process_start(task->task_name,
+                      task->process_name,
+                      &processes[process_count]) == -1) {
+      snprintf(errmsg,
+               sizeof errmsg,
+               "Process `%s` failed to start.",
+               task->process_name);
+      goto out;
+    }
+
+    process_count++;
+  }
+
+  /* Give the helpers time to settle. Race-y, fix this. */
+  uv_sleep(250);
+
+  /* Now start the test itself. */
+  for (main_proc = NULL, task = TASKS; task->main; task++) {
+    if (strcmp(test, task->task_name) != 0) {
+      continue;
+    }
+
+    if (task->is_helper) {
+      continue;
+    }
+
+    if (process_start(task->task_name,
+                      task->process_name,
+                      &processes[process_count]) == -1) {
+      snprintf(errmsg,
+               sizeof errmsg,
+               "Process `%s` failed to start.",
+               task->process_name);
+      goto out;
+    }
+
+    main_proc = &processes[process_count];
+    process_count++;
+    break;
+  }
+
+  if (main_proc == NULL) {
+    snprintf(errmsg,
+             sizeof errmsg,
+             "No test with that name: %s",
+             test);
+    goto out;
+  }
+
+  result = process_wait(main_proc, 1, timeout);
+  if (result == -1) {
+    FATAL("process_wait failed");
+  } else if (result == -2) {
+    /* Don't have to clean up the process, process_wait() has killed it. */
+    snprintf(errmsg,
+             sizeof errmsg,
+             "timeout");
+    goto out;
+  }
+
+  status = process_reap(main_proc);
+  if (status != 0) {
+    snprintf(errmsg,
+             sizeof errmsg,
+             "exit code %d",
+             status);
+    goto out;
+  }
+
+  if (benchmark_output) {
+    /* Give the helpers time to clean up their act. */
+    uv_sleep(1000);
+  }
+
+out:
+  /* Reap running processes except the main process, it's already dead. */
+  for (i = 0; i < process_count - 1; i++) {
+    process_terminate(&processes[i]);
+  }
+
+  if (process_wait(processes, process_count - 1, -1) < 0) {
+    FATAL("process_wait failed");
+  }
+
+  /* Show error and output from processes if the test failed. */
+  if (status != 0) {
+    LOGF("\n`%s` failed: %s\n", test, errmsg);
+
+    for (i = 0; i < process_count; i++) {
+      switch (process_output_size(&processes[i])) {
+       case -1:
+        LOGF("Output from process `%s`: (unavailable)\n",
+             process_get_name(&processes[i]));
+        break;
+
+       case 0:
+        LOGF("Output from process `%s`: (no output)\n",
+             process_get_name(&processes[i]));
+        break;
+
+       default:
+        LOGF("Output from process `%s`:\n", process_get_name(&processes[i]));
+        process_copy_output(&processes[i], fileno(stderr));
+        break;
+      }
+    }
+    LOG("=============================================================\n");
+
+  /* In benchmark mode show concise output from the main process. */
+  } else if (benchmark_output) {
+    switch (process_output_size(main_proc)) {
+     case -1:
+      LOGF("%s: (unavailabe)\n", test);
+      break;
+
+     case 0:
+      LOGF("%s: (no output)\n", test);
+      break;
+
+     default:
+      for (i = 0; i < process_count; i++) {
+        process_copy_output(&processes[i], fileno(stderr));
+      }
+      break;
+    }
+  }
+
+  /* Clean up all process handles. */
+  for (i = 0; i < process_count; i++) {
+    process_cleanup(&processes[i]);
+  }
+
+  return status;
+}
+
+
+/* Returns the status code of the task part
+ * or 255 if no matching task was not found.
+ */
+int run_test_part(const char* test, const char* part) {
+  task_entry_t* task;
+
+  for (task = TASKS; task->main; task++) {
+    if (strcmp(test, task->task_name) == 0
+        && strcmp(part, task->process_name) == 0) {
+      return task->main();
+    }
+  }
+
+  LOGF("No test part with that name: %s:%s\n", test, part);
+  return 255;
+}
+
+
+static int compare_task(const void* va, const void* vb) {
+  const task_entry_t* a = va;
+  const task_entry_t* b = vb;
+  return strcmp(a->task_name, b->task_name);
+}
+
+
+static int find_helpers(const task_entry_t* task, const task_entry_t** helpers) {
+  const task_entry_t* helper;
+  int n_helpers;
+
+  for (n_helpers = 0, helper = TASKS; helper->main; helper++) {
+    if (helper->is_helper && strcmp(helper->task_name, task->task_name) == 0) {
+      *helpers++ = helper;
+      n_helpers++;
+    }
+  }
+
+  return n_helpers;
+}
+
+
+void print_tests(FILE* stream) {
+  const task_entry_t* helpers[1024];
+  const task_entry_t* task;
+  int n_helpers;
+  int n_tasks;
+  int i;
+
+  for (n_tasks = 0, task = TASKS; task->main; n_tasks++, task++);
+  qsort(TASKS, n_tasks, sizeof(TASKS[0]), compare_task);
+
+  for (task = TASKS; task->main; task++) {
+    if (task->is_helper) {
+      continue;
+    }
+
+    n_helpers = find_helpers(task, helpers);
+    if (n_helpers) {
+      printf("%-25s (helpers:", task->task_name);
+      for (i = 0; i < n_helpers; i++) {
+        printf(" %s", helpers[i]->process_name);
+      }
+      printf(")\n");
+    } else {
+      printf("%s\n", task->task_name);
+    }
+  }
+}