noderb 0.0.3 → 0.0.4

data/ext/noderb_extension/libuv/src/win/pipe.c

@@ -56,9 +56,9 @@ int uv_pipe_init_with_handle(uv_pipe_t* handle, HANDLE pipeHandle) {
   int err = uv_pipe_init(handle);
 
   if (!err) {
-    /* 
+    /*
      * At this point we don't know whether the pipe will be used as a client
-     * or a server.  So, we assume that it will be a client until 
+     * or a server.  So, we assume that it will be a client until
      * uv_listen is called.
      */
     handle->handle = pipeHandle;
@@ -144,23 +144,92 @@ static int uv_set_pipe_handle(uv_pipe_t* handle, HANDLE pipeHandle) {
 }
 
 
+static DWORD WINAPI pipe_shutdown_thread_proc(void* parameter) {
+  int errno;
+  uv_pipe_t* handle;
+  uv_shutdown_t* req;
+
+  req = (uv_shutdown_t*) parameter;
+  assert(req);
+  handle = (uv_pipe_t*) req->handle;
+  assert(handle);
+
+  FlushFileBuffers(handle->handle);
+
+  /* Post completed */
+  if (!PostQueuedCompletionStatus(LOOP->iocp,
+                                0,
+                                0,
+                                &req->overlapped)) {
+    uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
+  }
+
+  return 0;
+}
+
+
 void uv_pipe_endgame(uv_pipe_t* handle) {
   uv_err_t err;
   int status;
   unsigned int uv_alloced;
+  DWORD result;
+  uv_shutdown_t* req;
+  NTSTATUS nt_status;
+  IO_STATUS_BLOCK io_status;
+  FILE_PIPE_LOCAL_INFORMATION pipe_info;
+
 
   if (handle->flags & UV_HANDLE_SHUTTING &&
       !(handle->flags & UV_HANDLE_SHUT) &&
       handle->write_reqs_pending == 0) {
-    close_pipe(handle, &status, &err);
+    req = handle->shutdown_req;
+
+    /* Try to avoid flushing the pipe buffer in the thread pool. */
+    nt_status = pNtQueryInformationFile(handle->handle,
+                                        &io_status,
+                                        &pipe_info,
+                                        sizeof pipe_info,
+                                        FilePipeLocalInformation);
+
+    if (nt_status != STATUS_SUCCESS) {
+      /* Failure */
+      handle->flags &= ~UV_HANDLE_SHUTTING;
+      if (req->cb) {
+        uv_set_sys_error(pRtlNtStatusToDosError(nt_status));
+        req->cb(req, -1);
+      }
+      DECREASE_PENDING_REQ_COUNT(handle);
+      return;
+    }
 
-    if (handle->shutdown_req->cb) {
-      if (status == -1) {
-        LOOP->last_error = err;
+    if (pipe_info.OutboundQuota == pipe_info.WriteQuotaAvailable) {
+      /* Short-circuit, no need to call FlushFileBuffers. */
+      handle->flags |= UV_HANDLE_SHUT;
+      if (req->cb) {
+        req->cb(req, 0);
       }
-      handle->shutdown_req->cb(handle->shutdown_req, status);
+      DECREASE_PENDING_REQ_COUNT(handle);
+      return;
+    }
+
+    /* Run FlushFileBuffers in the thhead pool. */
+    result = QueueUserWorkItem(pipe_shutdown_thread_proc,
+                               req,
+                               WT_EXECUTELONGFUNCTION);
+    if (result) {
+      /* Mark the handle as shut now to avoid going through this again. */
+      handle->flags |= UV_HANDLE_SHUT;
+
+    } else {
+      /* Failure. */
+      handle->flags &= ~UV_HANDLE_SHUTTING;
+      if (req->cb) {
+        uv_set_sys_error(GetLastError());
+        req->cb(req, -1);
+      }
+      DECREASE_PENDING_REQ_COUNT(handle);
+      return;
     }
-    handle->reqs_pending--;
   }
 
   if (handle->flags & UV_HANDLE_CLOSING &&
@@ -298,6 +367,8 @@ static DWORD WINAPI pipe_connect_thread_proc(void* parameter) {
     if (pipeHandle != INVALID_HANDLE_VALUE) {
       break;
     }
+
+    SwitchToThread();
   }
 
   if (pipeHandle != INVALID_HANDLE_VALUE && !uv_set_pipe_handle(handle, pipeHandle)) {
@@ -317,8 +388,6 @@ static DWORD WINAPI pipe_connect_thread_proc(void* parameter) {
     uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");
   }
 
-  handle->reqs_pending++;
-
   return 0;
 }
 
@@ -363,6 +432,8 @@ int uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
         goto error;
       }
 
+      handle->reqs_pending++;
+
       return 0;
     }
 
@@ -518,7 +589,7 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
     return -1;
   }
 
-  if (!(handle->flags & UV_HANDLE_BOUND) && 
+  if (!(handle->flags & UV_HANDLE_BOUND) &&
       !(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
     uv_set_error(UV_EINVAL, 0);
     return -1;
@@ -530,7 +601,7 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
     return -1;
   }
 
-  if (!(handle->flags & UV_HANDLE_PIPESERVER) && 
+  if (!(handle->flags & UV_HANDLE_PIPESERVER) &&
       !(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
     uv_set_error(UV_ENOTSUP, 0);
     return -1;
@@ -718,7 +789,10 @@ void uv_process_pipe_read_req(uv_pipe_t* handle, uv_req_t* req) {
         break;
       }
 
-      /* TODO: do we need to check avail > 0? */
+      if (avail == 0) {
+        /* There is nothing to read after all. */
+        break;
+      }
 
       buf = handle->alloc_cb((uv_stream_t*)handle, avail);
       assert(buf.len > 0);
@@ -728,20 +802,10 @@ void uv_process_pipe_read_req(uv_pipe_t* handle, uv_req_t* req) {
                    buf.len,
                    &bytes,
                    NULL)) {
-        if (bytes > 0) {
-          /* Successful read */
-          handle->read_cb((uv_stream_t*)handle, bytes, buf);
-          /* Read again only if bytes == buf.len */
-          if (bytes <= buf.len) {
-            break;
-          }
-        } else {
-          /* Connection closed */
-          handle->flags &= ~UV_HANDLE_READING;
-          handle->flags |= UV_HANDLE_EOF;
-          LOOP->last_error.code = UV_EOF;
-          LOOP->last_error.sys_errno_ = ERROR_SUCCESS;
-          handle->read_cb((uv_stream_t*)handle, -1, buf);
+        /* Successful read */
+        handle->read_cb((uv_stream_t*)handle, bytes, buf);
+        /* Read again only if bytes == buf.len */
+        if (bytes <= buf.len) {
           break;
         }
       } else {
@@ -826,3 +890,17 @@ void uv_process_pipe_connect_req(uv_pipe_t* handle, uv_connect_t* req) {
 
   DECREASE_PENDING_REQ_COUNT(handle);
 }
+
+
+void uv_process_pipe_shutdown_req(uv_pipe_t* handle, uv_shutdown_t* req) {
+  assert(handle->type == UV_NAMED_PIPE);
+
+  CloseHandle(handle->handle);
+  handle->handle = INVALID_HANDLE_VALUE;
+
+  if (req->cb) {
+    req->cb(req, 0);
+  }
+
+  DECREASE_PENDING_REQ_COUNT(handle);
+}

data/ext/noderb_extension/libuv/src/win/process.c

@@ -28,6 +28,16 @@
 #include <stdlib.h>
 #include <windows.h>
 
+typedef struct env_var {
+  const char* narrow;
+  const wchar_t* wide;
+  int len; /* including null or '=' */
+  int supplied;
+  int value_len;
+} env_var_t;
+
+#define E_V(str) { str "=", L##str, sizeof(str), 0, 0 }
+
 #define UTF8_TO_UTF16(s, t)                               \
   size = uv_utf8_to_utf16(s, NULL, 0) * sizeof(wchar_t);  \
   t = (wchar_t*)malloc(size);                             \
@@ -361,6 +371,7 @@ static wchar_t* search_path(const wchar_t *file,
   return result;
 }
 
+
 /*
  * Quotes command line arguments
  * Returns a pointer to the end (next char to be written) of the buffer
@@ -437,6 +448,7 @@ wchar_t* quote_cmd_arg(const wchar_t *source, wchar_t *target) {
   return target;
 }
 
+
 wchar_t* make_program_args(char** args, int verbatim_arguments) {
   wchar_t* dst;
   wchar_t* ptr;
@@ -494,23 +506,69 @@ error:
   return NULL;
 }
 
+
+/*
+ * If we learn that people are passing in huge environment blocks
+ * then we should probably qsort() the array and then bsearch()
+ * to see if it contains this variable. But there are ownership
+ * issues associated with that solution; this is the caller's 
+ * char**, and modifying it is rude.
+ */
+static void check_required_vars_contains_var(env_var_t* required, int size, const char* var) {
+  int i;
+  for (i = 0; i < size; ++i) {
+    if (_strnicmp(required[i].narrow, var, required[i].len) == 0) {
+      required[i].supplied =  1;
+      return;
+    }
+  }
+}
+
+
 /*
-  * The way windows takes environment variables is different than what C does;
-  * Windows wants a contiguous block of null-terminated strings, terminated
-  * with an additional null.
-  */
+ * The way windows takes environment variables is different than what C does;
+ * Windows wants a contiguous block of null-terminated strings, terminated
+ * with an additional null.
+ * 
+ * Windows has a few "essential" environment variables. winsock will fail
+ * to initialize if SYSTEMROOT is not defined; some APIs make reference to
+ * TEMP. SYSTEMDRIVE is probably also important. We therefore ensure that
+ * these get defined if the input environment block does not contain any
+ * values for them.
+ */
 wchar_t* make_program_env(char** env_block) {
   wchar_t* dst;
   wchar_t* ptr;
   char** env;
   int env_len = 1 * sizeof(wchar_t); /* room for closing null */
   int len;
+  int i;
+  DWORD var_size;
+
+  env_var_t required_vars[] = {
+    E_V("SYSTEMROOT"),
+    E_V("SYSTEMDRIVE"),
+    E_V("TEMP"),
+  };
 
   for (env = env_block; *env; env++) {
+    check_required_vars_contains_var(required_vars, COUNTOF(required_vars), *env);
     env_len += (uv_utf8_to_utf16(*env, NULL, 0) * sizeof(wchar_t));
   }
 
-  dst = (wchar_t*)malloc(env_len);
+  for (i = 0; i < COUNTOF(required_vars); ++i) {
+    if (!required_vars[i].supplied) {
+      env_len += required_vars[i].len * sizeof(wchar_t);
+      var_size = GetEnvironmentVariableW(required_vars[i].wide, NULL, 0);
+      if (var_size == 0) {
+        uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
+      }
+      required_vars[i].value_len = (int)var_size;
+      env_len += (int)var_size * sizeof(wchar_t);
+    }
+  }
+
+  dst = malloc(env_len);
   if (!dst) {
     uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
   }
@@ -525,6 +583,19 @@ wchar_t* make_program_env(char** env_block) {
     }
   }
 
+  for (i = 0; i < COUNTOF(required_vars); ++i) {
+    if (!required_vars[i].supplied) {
+      wcscpy(ptr, required_vars[i].wide);
+      ptr += required_vars[i].len - 1;
+      *ptr++ = L'=';
+      var_size = GetEnvironmentVariableW(required_vars[i].wide, ptr, required_vars[i].value_len);
+      if (var_size == 0) {
+        uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
+      }
+      ptr += required_vars[i].value_len;
+    }
+  }
+
   *ptr = L'\0';
   return dst;
 }

data/ext/noderb_extension/libuv/src/win/req.c

@@ -110,6 +110,13 @@ void uv_process_reqs() {
         DELEGATE_STREAM_REQ((uv_connect_t*) req, connect, handle);
         break;
 
+      case UV_SHUTDOWN:
+        /* Tcp shutdown requests don't come here. */
+        assert(((uv_shutdown_t*) req)->handle->type == UV_NAMED_PIPE);
+        uv_process_pipe_shutdown_req(
+            (uv_pipe_t*) ((uv_shutdown_t*) req)->handle, req);
+        break;
+
       case UV_WAKEUP:
         uv_process_async_wakeup_req((uv_async_t*) req->data, req);
         break;

data/ext/noderb_extension/libuv/src/win/winapi.c

@@ -0,0 +1,52 @@
+/* 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 <assert.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+sRtlNtStatusToDosError pRtlNtStatusToDosError;
+sNtQueryInformationFile pNtQueryInformationFile;
+
+
+void uv_winapi_init() {
+  HMODULE module;
+
+  module = GetModuleHandleA("ntdll.dll");
+  if (module == NULL) {
+    uv_fatal_error(GetLastError(), "GetModuleHandleA");
+  }
+
+  pRtlNtStatusToDosError = (sRtlNtStatusToDosError) GetProcAddress(module,
+      "RtlNtStatusToDosError");
+  if (pRtlNtStatusToDosError == NULL) {
+    uv_fatal_error(GetLastError(), "GetProcAddress");
+  }
+
+  pNtQueryInformationFile = (sNtQueryInformationFile) GetProcAddress(module,
+      "NtQueryInformationFile");
+  if (pNtQueryInformationFile == NULL) {
+    uv_fatal_error(GetLastError(), "GetProcAddress");
+  }
+}

data/ext/noderb_extension/libuv/test/benchmark-pound.c

@@ -22,6 +22,12 @@
 #include "task.h"
 #include "uv.h"
 
+/* Update this is you're going to run > 1000 concurrent requests. */
+#define MAX_CONNS 1000
+
+#undef NANOSEC
+#define NANOSEC ((uint64_t)10e8)
+
 /* Base class for tcp_conn_rec and pipe_conn_rec.
  * The ordering of fields matters!
  */
@@ -45,8 +51,13 @@ typedef struct {
 
 static char buffer[] = "QS";
 
-static int64_t start_time, end_time;
-static int closed_streams, concurrency;
+static tcp_conn_rec tcp_conns[MAX_CONNS];
+static pipe_conn_rec pipe_conns[MAX_CONNS];
+
+static uint64_t start_time;
+static uint64_t end_time;
+static int closed_streams;
+static int conns_failed;
 
 typedef void *(*setup_fn)(int num, void* arg);
 typedef int (*connect_fn)(int num, void* handles, void* arg);
@@ -71,6 +82,12 @@ static void connect_cb(uv_connect_t* req, int status) {
   uv_buf_t buf;
   int r;
 
+  if (status != 0) {
+    uv_close((uv_handle_t*)req->handle, close_cb);
+    conns_failed++;
+    return;
+  }
+
   ASSERT(req != NULL);
   ASSERT(status == 0);
 
@@ -98,63 +115,34 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
 static void close_cb(uv_handle_t* handle) {
   ASSERT(handle != NULL);
   closed_streams++;
-
-  if (closed_streams == concurrency) {
-    uv_update_time();
-    end_time = uv_now();
-  }
 }
 
 
 static void* tcp_do_setup(int num, void* arg) {
-  tcp_conn_rec* conns;
   tcp_conn_rec* pe;
   tcp_conn_rec* p;
   int r;
 
-  concurrency = num;
-  closed_streams = 0;
-
-  conns = calloc(num, sizeof(tcp_conn_rec));
-  ASSERT(conns != NULL);
-
-  for (p = conns, pe = p + num; p < pe; p++) {
+  for (p = tcp_conns, pe = p + num; p < pe; p++) {
     r = uv_tcp_init(&p->stream);
     ASSERT(r == 0);
-    p->stream.data = p;
-    p->conn_req.data = p;
-    p->write_req.data = p;
-    p->conn_req.handle = (uv_stream_t*)&p->stream;
-    p->write_req.handle = (uv_stream_t*)&p->stream;
   }
 
-  return conns;
+  return tcp_conns;
 }
 
 
 static void* pipe_do_setup(int num, void* arg) {
-  pipe_conn_rec* conns;
   pipe_conn_rec* pe;
   pipe_conn_rec* p;
   int r;
 
-  concurrency = num;
-  closed_streams = 0;
-
-  conns = calloc(num, sizeof(pipe_conn_rec));
-  ASSERT(conns != NULL);
-
-  for (p = conns, pe = p + num; p < pe; p++) {
+  for (p = pipe_conns, pe = p + num; p < pe; p++) {
     r = uv_pipe_init(&p->stream);
     ASSERT(r == 0);
-    p->stream.data = p;
-    p->conn_req.data = p;
-    p->write_req.data = p;
-    p->conn_req.handle = (uv_stream_t*)&p->stream;
-    p->write_req.handle = (uv_stream_t*)&p->stream;
   }
 
-  return conns;
+  return pipe_conns;
 }
 
 
@@ -165,9 +153,11 @@ static int tcp_do_connect(int num, void* conns, void* arg) {
   int r;
 
   addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
-  for (p = conns, pe = p + num; p < pe; p++) {
+  for (p = tcp_conns, pe = p + num; p < pe; p++) {
     r = uv_tcp_connect(&p->conn_req, &p->stream, addr, connect_cb);
     ASSERT(r == 0);
+
+    p->conn_req.data = p;
   }
 
   return 0;
@@ -179,9 +169,11 @@ static int pipe_do_connect(int num, void* conns, void* arg) {
   pipe_conn_rec* p;
   int r;
 
-  for (p = conns, pe = p + num; p < pe; p++) {
+  for (p = pipe_conns, pe = p + num; p < pe; p++) {
     r = uv_pipe_connect(&p->conn_req, &p->stream, TEST_PIPENAME, connect_cb);
     ASSERT(r == 0);
+
+    p->conn_req.data = p;
   }
 
   return 0;
@@ -193,25 +185,35 @@ static int pound_it(int concurrency,
                     setup_fn do_setup,
                     connect_fn do_connect,
                     void* arg) {
+  double secs;
   void* state;
   int r;
 
   uv_init();
 
-  state = do_setup(concurrency, arg);
-  ASSERT(state != NULL);
+  /* Run benchmark for at least five seconds. */
+  start_time = uv_hrtime();
+  do {
+    state = do_setup(concurrency, arg);
+    ASSERT(state != NULL);
 
-  uv_update_time();
-  start_time = uv_now();
+    r = do_connect(concurrency, state, arg);
+    ASSERT(!r);
 
-  r = do_connect(concurrency, state, arg);
-  ASSERT(!r);
+    uv_run();
 
-  uv_run();
+    end_time = uv_hrtime();
+  }
+  while ((end_time - start_time) < 5 * NANOSEC);
 
-  LOGF("%s-conn-pound-%d: %.0f accepts/s\n",
-       type, concurrency, 
-       (double) concurrency / (double) (end_time - start_time) * 1000.0);
+  /* Number of fractional seconds it took to run the benchmark. */
+  secs = (double)(end_time - start_time) / NANOSEC;
+
+  LOGF("%s-conn-pound-%d: %.0f accepts/s (%d failed)\n",
+       type,
+       concurrency,
+       closed_streams / secs,
+       conns_failed);
 
   return 0;
 }
@@ -234,4 +236,4 @@ BENCHMARK_IMPL(pipe_pound_100) {
 
 BENCHMARK_IMPL(pipe_pound_1000) {
   return pound_it(1000, "pipe", pipe_do_setup, pipe_do_connect, NULL);
-}
+}

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

@@ -90,7 +90,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
     return;
   }
 
-  /* 
+  /*
    * Scan for the letter Q which signals that we should quit the server.
    * If we get QS it means close the stream.
    */
@@ -99,7 +99,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
       if (buf.base[i] == 'Q') {
         if (i + 1 < nread && buf.base[i + 1] == 'S') {
           free(buf.base);
-          uv_close((uv_handle_t*)handle, NULL);
+          uv_close((uv_handle_t*)handle, on_close);
           return;
         } else {
           uv_close(server, on_server_close);

data/ext/noderb_extension/libuv/test/test-list.h

@@ -70,6 +70,7 @@ TEST_DECLARE   (spawn_and_kill)
 #ifdef _WIN32
 TEST_DECLARE   (spawn_detect_pipe_name_collisions_on_windows)
 TEST_DECLARE   (argument_escaping)
+TEST_DECLARE   (environment_creation)
 #endif
 HELPER_DECLARE (tcp4_echo_server)
 HELPER_DECLARE (tcp6_echo_server)
@@ -155,6 +156,7 @@ TASK_LIST_START
 #ifdef _WIN32
   TEST_ENTRY  (spawn_detect_pipe_name_collisions_on_windows)
   TEST_ENTRY  (argument_escaping)
+  TEST_ENTRY  (environment_creation)
 #endif
 
 #if 0

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

@@ -340,6 +340,53 @@ TEST_IMPL(argument_escaping) {
   ASSERT(wcscmp(verbatim_output, L"cmd.exe /c c:\\path\\to\\node.exe --eval \"require('c:\\\\path\\\\to\\\\test.js')\"") == 0);
   ASSERT(wcscmp(non_verbatim_output, L"cmd.exe /c \"c:\\path\\to\\node.exe --eval \\\"require('c:\\\\path\\\\to\\\\test.js')\\\"\"") == 0);
 
+  free(verbatim_output);
+  free(non_verbatim_output);
+
   return 0;
 }
-#endif
+
+wchar_t* make_program_env(char** env_block);
+
+TEST_IMPL(environment_creation) {
+  int i;
+  char* environment[] = {
+    "FOO=BAR",
+    "SYSTEM=ROOT", /* substring of a supplied var name */
+    "SYSTEMROOTED=OMG", /* supplied var name is a substring */
+    "TEMP=C:\\Temp",
+    "BAZ=QUX",
+    NULL
+  };
+
+  wchar_t expected[512];
+  wchar_t* ptr = expected;
+  wchar_t* result;
+  wchar_t* str;
+
+  for (i = 0; i < sizeof(environment) / sizeof(environment[0]) - 1; i++) {
+    ptr += uv_utf8_to_utf16(environment[i], ptr, expected + sizeof(expected) - ptr);
+  }
+
+  memcpy(ptr, L"SYSTEMROOT=", sizeof(L"SYSTEMROOT="));
+  ptr += sizeof(L"SYSTEMROOT=")/sizeof(wchar_t) - 1;
+  ptr += GetEnvironmentVariableW(L"SYSTEMROOT", ptr, expected + sizeof(expected) - ptr);
+  ++ptr;
+
+  memcpy(ptr, L"SYSTEMDRIVE=", sizeof(L"SYSTEMDRIVE="));
+  ptr += sizeof(L"SYSTEMDRIVE=")/sizeof(wchar_t) - 1;
+  ptr += GetEnvironmentVariableW(L"SYSTEMDRIVE", ptr, expected + sizeof(expected) - ptr);
+  ++ptr;
+  *ptr = '\0';
+  
+  result = make_program_env(environment);
+
+  for (str = result; *str; str += wcslen(str) + 1) {
+    wprintf(L"%s\n", str);
+  }
+
+  ASSERT(wcscmp(expected, result) == 0);
+ 
+  return 0;
+}
+#endif