diff --git a/cmds/Makefile b/cmds/Makefile
index b058618..4778036 100644
--- a/cmds/Makefile
+++ b/cmds/Makefile
@@ -53,7 +53,8 @@
 	stdoutline.so
 HOST_TEST_TARGETS=\
 	host-netusage_test \
-	host-utils_test
+	host-utils_test \
+	host-isoping_test
 SCRIPT_TARGETS=\
 	is-secure-boot
 ARCH_TARGETS=\
@@ -148,6 +149,9 @@
 host-%.o: %.cc
 	$(HOST_CXX) $(CXXFLAGS) $(INCS) $(HOST_INCS) -DCOMPILE_FOR_HOST=1 -o $@ -c $<
 
+host-%.o: ../wvtest/cpp/%.cc
+	$(HOST_CXX) $(CXXFLAGS) -D WVTEST_CONFIGURED -o $@ -c $<
+
 %: %.o
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(LIBS) -lc
 
@@ -171,8 +175,12 @@
 	echo "Building .pb.cc"
 	$(HOST_PROTOC) --cpp_out=. $<
 
-
-host-isoping isoping: LIBS+=$(RT) -lm
+host-isoping isoping: LIBS+=$(RT) -lm -lstdc++
+host-isoping: host-isoping.o host-isoping_main.o
+host-isoping_test.o: CXXFLAGS += -D WVTEST_CONFIGURED -I ../wvtest/cpp
+host-isoping_test.o: isoping.cc
+host-isoping_test: LIBS+=$(HOST_LIBS) -lm -lstdc++
+host-isoping_test: host-isoping_test.o host-isoping.o host-wvtestmain.o host-wvtest.o
 host-isostream isostream: LIBS+=$(RT)
 host-diskbench diskbench: LIBS+=-lpthread $(RT)
 host-dnsck: LIBS+=$(HOST_LIBS) -lcares $(RT)
@@ -187,7 +195,7 @@
 host-alivemonitor alivemonitor: LIBS+=$(RT)
 host-buttonmon buttonmon: LIBS+=$(RT)
 alivemonitor: alivemonitor.o
-isoping: isoping.o
+isoping: isoping.o isoping_main.o
 isostream: isostream.o
 diskbench: diskbench.o
 dnsck: LIBS+=-lcares $(RT)
diff --git a/cmds/isoping.c b/cmds/isoping.c
deleted file mode 100644
index a669883..0000000
--- a/cmds/isoping.c
+++ /dev/null
@@ -1,657 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/*
- *
- * Like ping, but sends packets isochronously (equally spaced in time) in
- * each direction.  By being clever, we can use the known timing of each
- * packet to determine, on a noisy network, which direction is dropping or
- * delaying packets and by how much.
- *
- * Also unlike ping, this requires a server (ie. another copy of this
- * program) to be running on the remote end.
- */
-#include <arpa/inet.h>
-#include <errno.h>
-#include <math.h>
-#include <memory.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/select.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <time.h>
-#include <unistd.h>
-
-#ifndef CLOCK_MONOTONIC_RAW
-#define CLOCK_MONOTONIC_RAW 4
-#endif
-
-#define MAGIC 0x424c4950
-#define SERVER_PORT 4948
-#define DEFAULT_PACKETS_PER_SEC 10.0
-
-// A 'cycle' is the amount of time we can assume our calibration between
-// the local and remote monotonic clocks is reasonably valid.  It seems
-// some of our devices have *very* fast clock skew (> 1 msec/minute) so
-// this unfortunately has to be much shorter than I'd like.  This may
-// reflect actual bugs in our ntpd and/or the kernel's adjtime()
-// implementation.  In particular, we shouldn't have to do this kind of
-// periodic correction, because that's what adjtime() *is*.  But the results
-// are way off without this.
-#define USEC_PER_CYCLE (10*1000*1000)
-
-#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
-#define DIFF(x, y) ((int32_t)((uint32_t)(x) - (uint32_t)(y)))
-#define DIV(x, y) ((y) ? ((double)(x)/(y)) : 0)
-#define _STR(n) #n
-#define STR(n) _STR(n)
-
-
-// Layout of the UDP packets exchanged between client and server.
-// All integers are in network byte order.
-// Packets have exactly the same structure in both directions.
-struct Packet {
-  uint32_t magic;     // magic number to reject bogus packets
-  uint32_t id;        // sequential packet id number
-  uint32_t txtime;    // transmitter's monotonic time when pkt was sent
-  uint32_t clockdiff; // estimate of (transmitter's clk) - (receiver's clk)
-  uint32_t usec_per_pkt; // microseconds of delay between packets
-  uint32_t num_lost;  // number of pkts transmitter expected to get but didn't
-  uint32_t first_ack; // starting index in acks[] circular buffer
-  struct {
-    // txtime==0 for empty elements in this array.
-    uint32_t id;      // id field from a received packet
-    uint32_t rxtime;  // receiver's monotonic time when pkt arrived
-  } acks[64];
-};
-
-
-int want_to_die;
-
-
-static void sighandler(int sig) {
-  want_to_die = 1;
-}
-
-
-// Returns the kernel monotonic timestamp in microseconds, truncated to
-// 32 bits.  That will wrap around every ~4000 seconds, which is okay
-// for our purposes.  We use 32 bits to save space in our packets.
-// This function never returns the value 0; it returns 1 instead, so that
-// 0 can be used as a magic value.
-#ifdef __MACH__  // MacOS X doesn't have clock_gettime()
-#include <mach/mach.h>
-#include <mach/mach_time.h>
-
-static uint64_t ustime64(void) {
-  static mach_timebase_info_data_t timebase;
-  if (!timebase.denom) mach_timebase_info(&timebase);
-  uint64_t result = (mach_absolute_time() * timebase.numer /
-                     timebase.denom / 1000);
-  return !result ? 1 : result;
-}
-#else
-static uint64_t ustime64(void) {
-  // CLOCK_MONOTONIC_RAW, when available, is not subject to NTP speed
-  // adjustments while CLOCK_MONOTONIC is.  You might expect NTP speed
-  // adjustments to make things better if we're trying to sync timings
-  // between two machines, but at least our ntpd is pretty bad at making
-  // adjustments, so it tends the vary the speed wildly in order to kind
-  // of oscillate around the right time.  Experimentally, CLOCK_MONOTONIC_RAW
-  // creates less trouble for isoping's use case.
-  struct timespec ts;
-  if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) < 0) {
-    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
-      perror("clock_gettime");
-      exit(98); // really should never happen, so don't try to recover
-    }
-  }
-  uint64_t result = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000;
-  return !result ? 1 : result;
-}
-#endif
-
-
-static uint32_t ustime(void) {
-  return (uint32_t)ustime64();
-}
-
-
-static void usage_and_die(char *argv0) {
-  fprintf(stderr,
-          "\n"
-          "Usage: %s                          (server mode)\n"
-          "   or: %s <server-hostname-or-ip>  (client mode)\n"
-          "\n"
-          "      -f <lines/sec>  max output lines per second\n"
-          "      -r <pps>        packets per second (default=%g)\n"
-          "      -t <ttl>        packet ttl to use (default=2 for safety)\n"
-          "      -q              quiet mode (don't print packets)\n"
-          "      -T              print timestamps\n",
-          argv0, argv0, (double)DEFAULT_PACKETS_PER_SEC);
-  exit(99);
-}
-
-
-// Render the given sockaddr as a string.  (Uses a static internal buffer
-// which is overwritten each time.)
-static const char *sockaddr_to_str(struct sockaddr *sa) {
-  static char addrbuf[128];
-  void *aptr;
-
-  switch (sa->sa_family) {
-  case AF_INET:
-    aptr = &((struct sockaddr_in *)sa)->sin_addr;
-    break;
-  case AF_INET6:
-    aptr = &((struct sockaddr_in6 *)sa)->sin6_addr;
-    break;
-  default:
-    return "unknown";
-  }
-
-  if (!inet_ntop(sa->sa_family, aptr, addrbuf, sizeof(addrbuf))) {
-    perror("inet_ntop");
-    exit(98);
-  }
-  return addrbuf;
-}
-
-
-// Print the timestamp corresponding to the current time.
-// Deliberately the same format as tcpdump uses, so we can easily sort and
-// correlate messages between isoping and tcpdump.
-static void print_timestamp(uint32_t when) {
-  uint64_t now = ustime64();
-  int32_t nowdiff = DIFF(now, when);
-  uint64_t when64 = now - nowdiff;
-  time_t t = when64 / 1000000;
-  struct tm tm;
-  memset(&tm, 0, sizeof(tm));
-  localtime_r(&t, &tm);
-  printf("%02d:%02d:%02d.%06d ", tm.tm_hour, tm.tm_min, tm.tm_sec,
-         (int)(when64 % 1000000));
-}
-
-
-static double onepass_stddev(long long sumsq, long long sum, long long count) {
-  // Incremental standard deviation calculation, without needing to know the
-  // mean in advance.  See:
-  // http://mathcentral.uregina.ca/QQ/database/QQ.09.02/carlos1.html
-  long long numer = (count * sumsq) - (sum * sum);
-  long long denom = count * (count - 1);
-  return sqrt(DIV(numer, denom));
-}
-
-
-int main(int argc, char **argv) {
-  int is_server = 1;
-  struct sockaddr_in6 listenaddr, rxaddr, last_rxaddr;
-  struct sockaddr *remoteaddr = NULL;
-  socklen_t remoteaddr_len = 0, rxaddr_len = 0;
-  struct addrinfo *ai = NULL;
-  int sock = -1, want_timestamps = 0, quiet = 0, ttl = 2;
-  double packets_per_sec = DEFAULT_PACKETS_PER_SEC, prints_per_sec = -1;
-
-  setvbuf(stdout, NULL, _IOLBF, 0);
-
-  int c;
-  while ((c = getopt(argc, argv, "f:r:t:qTh?")) >= 0) {
-    switch (c) {
-    case 'f':
-      prints_per_sec = atof(optarg);
-      if (prints_per_sec <= 0) {
-        fprintf(stderr, "%s: lines per second must be >= 0\n", argv[0]);
-        return 99;
-      }
-      break;
-    case 'r':
-      packets_per_sec = atof(optarg);
-      if (packets_per_sec < 0.001 || packets_per_sec > 1e6) {
-        fprintf(stderr, "%s: packets per sec (-r) must be 0.001..1000000\n",
-                argv[0]);
-        return 99;
-      }
-      break;
-    case 't':
-      ttl = atoi(optarg);
-      if (ttl < 1) {
-        fprintf(stderr, "%s: ttl must be >= 1\n", argv[0]);
-        return 99;
-      }
-      break;
-    case 'q':
-      quiet = 1;
-      break;
-    case 'T':
-      want_timestamps = 1;
-      break;
-    case 'h':
-    case '?':
-    default:
-      usage_and_die(argv[0]);
-      break;
-    }
-  }
-
-  sock = socket(PF_INET6, SOCK_DGRAM, 0);
-  if (sock < 0) {
-    perror("socket");
-    return 1;
-  }
-
-  if (argc - optind == 0) {
-    is_server = 1;
-    memset(&listenaddr, 0, sizeof(listenaddr));
-    listenaddr.sin6_family = AF_INET6;
-    listenaddr.sin6_port = htons(SERVER_PORT);
-    if (bind(sock, (struct sockaddr *)&listenaddr, sizeof(listenaddr)) != 0) {
-      perror("bind");
-      return 1;
-    }
-    socklen_t addrlen = sizeof(listenaddr);
-    if (getsockname(sock, (struct sockaddr *)&listenaddr, &addrlen) != 0) {
-      perror("getsockname");
-      return 1;
-    }
-    fprintf(stderr, "server listening at [%s]:%d\n",
-           sockaddr_to_str((struct sockaddr *)&listenaddr),
-           ntohs(listenaddr.sin6_port));
-  } else if (argc - optind == 1) {
-    const char *remotename = argv[optind];
-    is_server = 0;
-    struct addrinfo hints = {
-      .ai_flags = AI_ADDRCONFIG | AI_V4MAPPED,
-      .ai_family = AF_INET6,
-      .ai_socktype = SOCK_DGRAM,
-    };
-    int err = getaddrinfo(remotename, STR(SERVER_PORT), &hints, &ai);
-    if (err != 0 || !ai) {
-      fprintf(stderr, "getaddrinfo(%s): %s\n", remotename, gai_strerror(err));
-      return 1;
-    }
-    fprintf(stderr, "connecting to %s...\n", sockaddr_to_str(ai->ai_addr));
-    if (connect(sock, ai->ai_addr, ai->ai_addrlen) != 0) {
-      perror("connect");
-      return 1;
-    }
-    remoteaddr = ai->ai_addr;
-    remoteaddr_len = ai->ai_addrlen;
-  } else {
-    usage_and_die(argv[0]);
-  }
-
-  fprintf(stderr, "using ttl=%d\n", ttl);
-  // IPPROTO_IPV6 is the only one that works on MacOS, and is arguably the
-  // technically correct thing to do since it's an AF_INET6 socket.
-  if (setsockopt(sock, IPPROTO_IPV6, IP_TTL, &ttl, sizeof(ttl))) {
-    perror("setsockopt(TTLv6)");
-    return 1;
-  }
-  // ...but in Linux (at least 3.13), IPPROTO_IPV6 does not actually
-  // set the TTL if the IPv6 socket ends up going over IPv4.  We have to
-  // set that separately.  On MacOS, that always returns EINVAL, so ignore
-  // the error if that happens.
-  if (setsockopt(sock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl))) {
-    if (errno != EINVAL) {
-      perror("setsockopt(TTLv4)");
-      return 1;
-    }
-  }
-
-  int32_t usec_per_pkt = 1e6 / packets_per_sec;
-  int32_t usec_per_print = prints_per_sec > 0 ? 1e6 / prints_per_sec : 0;
-
-  // WARNING: lots of math below relies on well-defined uint32/int32
-  // arithmetic overflow behaviour, plus the fact that when we subtract
-  // two successive timestamps (for example) they will be less than 2^31
-  // microseconds apart.  It would be safer to just use 64-bit values
-  // everywhere, but that would cut the number of acks-per-packet in half,
-  // which would be unfortunate.
-  uint32_t next_tx_id = 1;       // id field for next transmit
-  uint32_t next_rx_id = 0;       // expected id field for next receive
-  uint32_t next_rxack_id = 0;    // expected ack.id field in next received ack
-  uint32_t start_rtxtime = 0;    // remote's txtime at startup
-  uint32_t start_rxtime = 0;     // local rxtime at startup
-  uint32_t last_rxtime = 0;      // local rxtime of last received packet
-  int32_t min_cycle_rxdiff = 0;  // smallest packet delay seen this cycle
-  uint32_t next_cycle = 0;       // time when next cycle begins
-  uint32_t now = ustime();       // current time
-  uint32_t next_send = now + usec_per_pkt;  // time when we'll send next pkt
-  uint32_t num_lost = 0;         // number of rx packets not received
-  int next_txack_index = 0;      // next array item to fill in tx.acks
-  struct Packet tx, rx;          // transmit and received packet buffers
-  char last_ackinfo[128] = "";   // human readable format of latest ack
-  uint32_t last_print = now - usec_per_pkt;  // time of last packet printout
-  // Packet statistics counters for transmit and receive directions.
-  long long lat_tx = 0, lat_tx_min = 0x7fffffff, lat_tx_max = 0,
-      lat_tx_count = 0, lat_tx_sum = 0, lat_tx_var_sum = 0;
-  long long lat_rx = 0, lat_rx_min = 0x7fffffff, lat_rx_max = 0,
-      lat_rx_count = 0, lat_rx_sum = 0, lat_rx_var_sum = 0;
-
-  memset(&tx, 0, sizeof(tx));
-
-  struct sigaction act = {
-    .sa_handler = sighandler,
-    .sa_flags = SA_RESETHAND,
-  };
-  sigaction(SIGINT, &act, NULL);
-
-  while (!want_to_die) {
-    fd_set rfds;
-    FD_ZERO(&rfds);
-    FD_SET(sock, &rfds);
-    struct timeval tv;
-    tv.tv_sec = 0;
-
-    now = ustime();
-    if (DIFF(next_send, now) < 0) {
-      tv.tv_usec = 0;
-    } else {
-      tv.tv_usec = DIFF(next_send, now);
-    }
-    int nfds = select(sock + 1, &rfds, NULL, NULL, remoteaddr ? &tv : NULL);
-    now = ustime();
-    if (nfds < 0 && errno != EINTR) {
-      perror("select");
-      return 1;
-    }
-
-    // time to send the next packet?
-    if (remoteaddr && DIFF(now, next_send) >= 0) {
-      tx.magic = htonl(MAGIC);
-      tx.id = htonl(next_tx_id++);
-      tx.usec_per_pkt = htonl(usec_per_pkt);
-      tx.txtime = htonl(next_send);
-      tx.clockdiff = start_rtxtime ? htonl(start_rxtime - start_rtxtime) : 0;
-      tx.num_lost = htonl(num_lost);
-      tx.first_ack = htonl(next_txack_index);
-      // note: tx.acks[] is filled in incrementally; we just transmit the
-      // current state of it here.  The reason we keep a list of the most
-      // recent acks is in case our packet gets lost, so the receiver will
-      // have more chances to receive the timing information for the packets
-      // it sent us.
-      if (is_server) {
-        if (sendto(sock, &tx, sizeof(tx), 0,
-                   remoteaddr, remoteaddr_len) < 0) {
-          perror("sendto");
-        }
-      } else {
-        if (send(sock, &tx, sizeof(tx), 0) < 0) {
-          int e = errno;
-          perror("send");
-          if (e == ECONNREFUSED) return 2;
-        }
-      }
-      if (is_server && DIFF(now, last_rxtime) > 60*1000*1000) {
-        fprintf(stderr, "client disconnected.\n");
-        remoteaddr = NULL;
-      }
-      next_send += usec_per_pkt;
-    }
-
-    if (nfds > 0) {
-      // incoming packet
-      rxaddr_len = sizeof(rxaddr);
-      ssize_t got = recvfrom(sock, &rx, sizeof(rx), 0,
-                             (struct sockaddr *)&rxaddr, &rxaddr_len);
-      if (got < 0) {
-        int e = errno;
-        perror("recvfrom");
-        if (!is_server && e == ECONNREFUSED) return 2;
-        continue;
-      }
-      if (got != sizeof(rx) || rx.magic != htonl(MAGIC)) {
-        fprintf(stderr, "got invalid packet of length %ld\n", (long)got);
-        continue;
-      }
-
-      // is it a new client?
-      if (is_server) {
-        // TODO(apenwarr): fork() for each newly connected client.
-        //  The way the code is right now, it won't work right at all
-        //  if there are two clients sending us packets at once.
-        //  That's okay for a first round of controlled tests.
-        if (!remoteaddr ||
-            memcmp(&rxaddr, &last_rxaddr, sizeof(rxaddr)) != 0) {
-          fprintf(stderr, "new client connected: %s\n",
-                  sockaddr_to_str((struct sockaddr *)&rxaddr));
-          memcpy(&last_rxaddr, &rxaddr, sizeof(rxaddr));
-          remoteaddr = (struct sockaddr *)&last_rxaddr;
-          remoteaddr_len = rxaddr_len;
-
-          next_send = now + 10*1000;
-          next_tx_id = 1;
-          next_rx_id = next_rxack_id = 0;
-          start_rtxtime = start_rxtime = 0;
-          num_lost = 0;
-          next_txack_index = 0;
-          usec_per_pkt = ntohl(rx.usec_per_pkt);
-          memset(&tx, 0, sizeof(tx));
-        }
-      }
-
-      // process the incoming packet header.
-      // Most of the complexity here comes from the fact that the remote
-      // system's clock will be skewed vs. ours.  (We use CLOCK_MONOTONIC
-      // instead of CLOCK_REALTIME, so unless we figure out the skew offset,
-      // it's essentially meaningless to compare the two values.)  We can
-      // however assume that both clocks are ticking at 1 microsecond per
-      // tick... except for inevitable clock rate errors, which we have to
-      // account for occasionally.
-
-      uint32_t txtime = ntohl(rx.txtime), rxtime = now;
-      uint32_t id = ntohl(rx.id);
-      if (!next_rx_id) {
-        // The remote txtime is told to us by the sender, so it is always
-        // perfectly correct... but it uses the sender's clock.
-        start_rtxtime = txtime - id * usec_per_pkt;
-
-        // The receive time uses our own clock and is estimated by us, so
-        // it needs to be corrected over time because:
-        //   a) the two clocks inevitably run at slightly different speeds;
-        //   b) there's an unknown, variable, network delay between tx and rx.
-        // Here, we're just assigning an initial estimate.
-        start_rxtime = rxtime - id * usec_per_pkt;
-
-        min_cycle_rxdiff = 0;
-        next_rx_id = id;
-        next_cycle = now + USEC_PER_CYCLE;
-      }
-
-      // see if we missed receiving any previous packets.
-      int32_t tmpdiff = DIFF(id, next_rx_id);
-      if (tmpdiff > 0) {
-        // arriving packet has id > expected, so something was lost.
-        // Note that we don't use the rx.acks[] structure to determine packet
-        // loss; that's because the limited size of the array means that,
-        // during a longer outage, we might not see an ack for a packet
-        // *even if that packet arrived safely* at the remote.  So we count
-        // on the remote end to count its own packet losses using sequence
-        // numbers, and send that count back to us.  We do the same here
-        // for incoming packets from the remote, and send the error count
-        // back to them next time we're ready to transmit.
-        fprintf(stderr, "lost %ld  expected=%ld  got=%ld\n",
-                (long)tmpdiff, (long)next_rx_id, (long)id);
-        num_lost += tmpdiff;
-        next_rx_id += tmpdiff + 1;
-      } else if (!tmpdiff) {
-        // exactly as expected; good.
-        next_rx_id++;
-      } else if (tmpdiff < 0) {
-        // packet before the expected one? weird.
-        fprintf(stderr, "out-of-order packets? %ld\n", (long)tmpdiff);
-      }
-
-      // fix up the clock offset if there's any drift.
-      tmpdiff = DIFF(rxtime, start_rxtime + id * usec_per_pkt);
-      if (tmpdiff < -20) {
-        // packet arrived before predicted time, so prediction was based on
-        // a packet that was "slow" before, or else one of our clocks is
-        // drifting. Use earliest legitimate start time.
-        fprintf(stderr, "time paradox: backsliding start by %ld usec\n",
-                (long)tmpdiff);
-        start_rxtime = rxtime - id * usec_per_pkt;
-      }
-      int32_t rxdiff = DIFF(rxtime, start_rxtime + id * usec_per_pkt);
-
-      // Figure out the offset between our clock and the remote's clock, so
-      // we can calculate the minimum round trip time (rtt). Then, because
-      // the consecutive packets sent in both directions are equally spaced
-      // in time, we can figure out how much a particular packet was delayed
-      // in transit - independently in each direction! This is an advantage
-      // over the normal "ping" program which has no way to tell which
-      // direction caused the delay, or which direction dropped the packet.
-
-      // Our clockdiff is
-      //   (our rx time) - (their tx time)
-      //   == (their rx time + offset) - (their tx time)
-      //   == (their tx time + offset + 1/2 rtt) - (their tx time)
-      //   == offset + 1/2 rtt
-      // and theirs (rx.clockdiff) is:
-      //   (their rx time) - (our tx time)
-      //   == (their rx time) - (their tx time + offset)
-      //   == (their tx time + 1/2 rtt) - (their tx time + offset)
-      //   == 1/2 rtt - offset
-      // So add them together and we get:
-      //   offset + 1/2 rtt + 1/2 rtt - offset
-      //   == rtt
-      // Subtract them and we get:
-      //   offset + 1/2 rtt - 1/2 rtt + offset
-      //   == 2 * offset
-      // ...but that last subtraction is dangerous because if we divide by
-      // 2 to get offset, it doesn't work with 32-bit math, which may have
-      // discarded a high-order bit somewhere along the way.  Instead,
-      // we can extract offset once we have rtt by substituting it into
-      //   clockdiff = offset + 1/2 rtt
-      //   offset = clockdiff - 1/2 rtt
-      // (Dividing rtt by 2 is safe since it's always small and positive.)
-      //
-      // (This example assumes 1/2 rtt in each direction. There's no way to
-      // determine it more accurately than that.)
-      int32_t clockdiff = DIFF(start_rxtime, start_rtxtime);
-      int32_t rtt = clockdiff + ntohl(rx.clockdiff);
-      int32_t offset = DIFF(clockdiff, rtt / 2);
-      if (!ntohl(rx.clockdiff)) {
-        // don't print the first packet: it has an invalid clockdiff since
-        // the client can't calculate the clockdiff until it receives
-        // at least one packet from us.
-        last_print = now - usec_per_print + 1;
-      } else {
-        // not the first packet, so statistics are valid.
-        lat_rx_count++;
-        lat_rx = rxdiff + rtt/2;
-        lat_rx_min = lat_rx_min > lat_rx ? lat_rx : lat_rx_min;
-        lat_rx_max = lat_rx_max < lat_rx ? lat_rx : lat_rx_max;
-        lat_rx_sum += lat_rx;
-        lat_rx_var_sum += lat_rx * lat_rx;
-      }
-
-      // Note: the way ok_to_print is structured, if there is a dropout in
-      // the connection for more than usec_per_print, we will statistically
-      // end up printing the first packet after the dropout ends.  That one
-      // should have the longest timeout, ie. a "worst case" packet, which is
-      // usually the information you want to see.
-      int ok_to_print = !quiet && DIFF(now, last_print) >= usec_per_print;
-      if (ok_to_print) {
-        if (want_timestamps) print_timestamp(rxtime);
-        printf("%12s  %6.1f ms rx  (min=%.1f)  loss: %ld/%ld tx  %ld/%ld rx\n",
-               last_ackinfo,
-               (rxdiff + rtt/2) / 1000.0,
-               (rtt/2) / 1000.0,
-               (long)ntohl(rx.num_lost),
-               (long)next_tx_id - 1,
-               (long)num_lost,
-               (long)next_rx_id - 1);
-        last_ackinfo[0] = '\0';
-        last_print = now;
-      }
-
-      if (rxdiff < min_cycle_rxdiff) min_cycle_rxdiff = rxdiff;
-      if (DIFF(now, next_cycle) >= 0) {
-        if (min_cycle_rxdiff > 0) {
-          fprintf(stderr, "clock skew: sliding start by %ld usec\n",
-                  (long)min_cycle_rxdiff);
-          start_rxtime += min_cycle_rxdiff;
-        }
-        min_cycle_rxdiff = 0x7fffffff;
-        next_cycle += USEC_PER_CYCLE;
-      }
-
-      // schedule this for an ack next time we send the packet
-      tx.acks[next_txack_index].id = htonl(id);
-      tx.acks[next_txack_index].rxtime = htonl(rxtime);
-      next_txack_index = (next_txack_index + 1) % ARRAY_LEN(tx.acks);
-
-      // see which of our own transmitted packets have been acked
-      uint32_t first_ack = ntohl(rx.first_ack);
-      for (uint32_t i = 0; i < ARRAY_LEN(rx.acks); i++) {
-        uint32_t acki = (first_ack + i) % ARRAY_LEN(rx.acks);
-        uint32_t ackid = ntohl(rx.acks[acki].id);
-        if (!ackid) continue;  // empty slot
-        if (DIFF(ackid, next_rxack_id) >= 0) {
-          // an expected ack
-          uint32_t start_txtime = next_send - next_tx_id * usec_per_pkt;
-          uint32_t txtime = start_txtime + ackid * usec_per_pkt;
-          uint32_t rrxtime = ntohl(rx.acks[acki].rxtime);
-          uint32_t rxtime = rrxtime + offset;
-          // note: already contains 1/2 rtt, unlike rxdiff
-          int32_t txdiff = DIFF(rxtime, txtime);
-          if (usec_per_print <= 0 && last_ackinfo[0]) {
-            // only print multiple acks per rx if no usec_per_print limit
-            if (want_timestamps) print_timestamp(rxtime);
-            printf("%12s\n", last_ackinfo);
-            last_ackinfo[0] = '\0';
-          }
-          if (!last_ackinfo[0]) {
-            snprintf(last_ackinfo, sizeof(last_ackinfo), "%6.1f ms tx",
-                     txdiff / 1000.0);
-          }
-          next_rxack_id = ackid + 1;
-          lat_tx_count++;
-          lat_tx = txdiff;
-          lat_tx_min = lat_tx_min > lat_tx ? lat_tx : lat_tx_min;
-          lat_tx_max = lat_tx_max < lat_tx ? lat_tx : lat_tx_max;
-          lat_tx_sum += lat_tx;
-          lat_tx_var_sum += lat_tx * lat_tx;
-        }
-      }
-
-      last_rxtime = rxtime;
-    }
-  }
-
-  printf("\n---\n");
-  printf("tx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
-         lat_tx_min / 1000.0,
-         DIV(lat_tx_sum, lat_tx_count) / 1000.0,
-         lat_tx_max / 1000.0,
-         onepass_stddev(lat_tx_var_sum, lat_tx_sum, lat_tx_count) / 1000.0);
-  printf("rx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
-         lat_rx_min / 1000.0,
-         DIV(lat_rx_sum, lat_rx_count) / 1000.0,
-         lat_rx_max / 1000.0,
-         onepass_stddev(lat_rx_var_sum, lat_rx_sum, lat_rx_count) / 1000.0);
-  printf("\n");
-
-  if (ai) freeaddrinfo(ai);
-  if (sock >= 0) close(sock);
-  return 0;
-}
diff --git a/cmds/isoping.cc b/cmds/isoping.cc
new file mode 100644
index 0000000..c6b123e
--- /dev/null
+++ b/cmds/isoping.cc
@@ -0,0 +1,663 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ *
+ * Like ping, but sends packets isochronously (equally spaced in time) in
+ * each direction.  By being clever, we can use the known timing of each
+ * packet to determine, on a noisy network, which direction is dropping or
+ * delaying packets and by how much.
+ *
+ * Also unlike ping, this requires a server (ie. another copy of this
+ * program) to be running on the remote end.
+ */
+#include "isoping.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <math.h>
+#include <memory.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#ifndef CLOCK_MONOTONIC_RAW
+#define CLOCK_MONOTONIC_RAW 4
+#endif
+
+#define MAGIC 0x424c4950
+#define SERVER_PORT 4948
+#define DEFAULT_PACKETS_PER_SEC 10.0
+#define DEFAULT_TTL 2
+
+// A 'cycle' is the amount of time we can assume our calibration between
+// the local and remote monotonic clocks is reasonably valid.  It seems
+// some of our devices have *very* fast clock skew (> 1 msec/minute) so
+// this unfortunately has to be much shorter than I'd like.  This may
+// reflect actual bugs in our ntpd and/or the kernel's adjtime()
+// implementation.  In particular, we shouldn't have to do this kind of
+// periodic correction, because that's what adjtime() *is*.  But the results
+// are way off without this.
+#define USEC_PER_CYCLE (10*1000*1000)
+
+#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
+#define DIFF(x, y) ((int32_t)((uint32_t)(x) - (uint32_t)(y)))
+#define DIV(x, y) ((y) ? ((double)(x)/(y)) : 0)
+#define _STR(n) #n
+#define STR(n) _STR(n)
+
+// Global flag values.
+int is_server = 1;
+int quiet = 0;
+int ttl = DEFAULT_TTL;
+int want_timestamps = 0;
+double packets_per_sec = DEFAULT_PACKETS_PER_SEC;
+double prints_per_sec = -1.0;
+
+int want_to_die;
+
+
+static void sighandler(int sig) {
+  want_to_die = 1;
+}
+
+Session::Session(uint32_t now)
+    : usec_per_pkt(1e6 / packets_per_sec),
+      usec_per_print(prints_per_sec > 0 ? 1e6 / prints_per_sec : 0),
+      next_tx_id(1),
+      next_rx_id(0),
+      next_rxack_id(0),
+      start_rtxtime(0),
+      start_rxtime(0),
+      last_rxtime(0),
+      min_cycle_rxdiff(0),
+      next_cycle(0),
+      next_send(now + usec_per_pkt),
+      num_lost(0),
+      next_txack_index(0),
+      last_print(now - usec_per_pkt),
+      lat_tx(0), lat_tx_min(0x7fffffff), lat_tx_max(0),
+      lat_tx_count(0), lat_tx_sum(0), lat_tx_var_sum(0),
+      lat_rx(0), lat_rx_min(0x7fffffff), lat_rx_max(0),
+      lat_rx_count(0), lat_rx_sum(0), lat_rx_var_sum(0) {
+  memset(&tx, 0, sizeof(tx));
+  strcpy(last_ackinfo, "");
+}
+
+// Returns the kernel monotonic timestamp in microseconds, truncated to
+// 32 bits.  That will wrap around every ~4000 seconds, which is okay
+// for our purposes.  We use 32 bits to save space in our packets.
+// This function never returns the value 0; it returns 1 instead, so that
+// 0 can be used as a magic value.
+#ifdef __MACH__  // MacOS X doesn't have clock_gettime()
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+static uint64_t ustime64(void) {
+  static mach_timebase_info_data_t timebase;
+  if (!timebase.denom) mach_timebase_info(&timebase);
+  uint64_t result = (mach_absolute_time() * timebase.numer /
+                     timebase.denom / 1000);
+  return !result ? 1 : result;
+}
+#else
+static uint64_t ustime64(void) {
+  // CLOCK_MONOTONIC_RAW, when available, is not subject to NTP speed
+  // adjustments while CLOCK_MONOTONIC is.  You might expect NTP speed
+  // adjustments to make things better if we're trying to sync timings
+  // between two machines, but at least our ntpd is pretty bad at making
+  // adjustments, so it tends the vary the speed wildly in order to kind
+  // of oscillate around the right time.  Experimentally, CLOCK_MONOTONIC_RAW
+  // creates less trouble for isoping's use case.
+  struct timespec ts;
+  if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) < 0) {
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
+      perror("clock_gettime");
+      exit(98); // really should never happen, so don't try to recover
+    }
+  }
+  uint64_t result = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000;
+  return !result ? 1 : result;
+}
+#endif
+
+
+static uint32_t ustime(void) {
+  return (uint32_t)ustime64();
+}
+
+
+static void usage_and_die(char *argv0) {
+  fprintf(stderr,
+          "\n"
+          "Usage: %s                          (server mode)\n"
+          "   or: %s <server-hostname-or-ip>  (client mode)\n"
+          "\n"
+          "      -f <lines/sec>  max output lines per second\n"
+          "      -r <pps>        packets per second (default=%g)\n"
+          "      -t <ttl>        packet ttl to use (default=2 for safety)\n"
+          "      -q              quiet mode (don't print packets)\n"
+          "      -T              print timestamps\n",
+          argv0, argv0, (double)DEFAULT_PACKETS_PER_SEC);
+  exit(99);
+}
+
+
+// Render the given sockaddr as a string.  (Uses a static internal buffer
+// which is overwritten each time.)
+static const char *sockaddr_to_str(struct sockaddr *sa) {
+  static char addrbuf[128];
+  void *aptr;
+
+  switch (sa->sa_family) {
+  case AF_INET:
+    aptr = &((struct sockaddr_in *)sa)->sin_addr;
+    break;
+  case AF_INET6:
+    aptr = &((struct sockaddr_in6 *)sa)->sin6_addr;
+    break;
+  default:
+    return "unknown";
+  }
+
+  if (!inet_ntop(sa->sa_family, aptr, addrbuf, sizeof(addrbuf))) {
+    perror("inet_ntop");
+    exit(98);
+  }
+  return addrbuf;
+}
+
+
+// Print the timestamp corresponding to the current time.
+// Deliberately the same format as tcpdump uses, so we can easily sort and
+// correlate messages between isoping and tcpdump.
+static void print_timestamp(uint32_t when) {
+  uint64_t now = ustime64();
+  int32_t nowdiff = DIFF(now, when);
+  uint64_t when64 = now - nowdiff;
+  time_t t = when64 / 1000000;
+  struct tm tm;
+  memset(&tm, 0, sizeof(tm));
+  localtime_r(&t, &tm);
+  printf("%02d:%02d:%02d.%06d ", tm.tm_hour, tm.tm_min, tm.tm_sec,
+         (int)(when64 % 1000000));
+}
+
+
+static double onepass_stddev(long long sumsq, long long sum, long long count) {
+  // Incremental standard deviation calculation, without needing to know the
+  // mean in advance.  See:
+  // http://mathcentral.uregina.ca/QQ/database/QQ.09.02/carlos1.html
+  long long numer = (count * sumsq) - (sum * sum);
+  long long denom = count * (count - 1);
+  return sqrt(DIV(numer, denom));
+}
+
+
+void prepare_tx_packet(struct Session *s) {
+  s->tx.magic = htonl(MAGIC);
+  s->tx.id = htonl(s->next_tx_id++);
+  s->tx.usec_per_pkt = htonl(s->usec_per_pkt);
+  s->tx.txtime = htonl(s->next_send);
+  s->tx.clockdiff = s->start_rtxtime ?
+      htonl(s->start_rxtime - s->start_rtxtime) : 0;
+  s->tx.num_lost = htonl(s->num_lost);
+  s->tx.first_ack = htonl(s->next_txack_index);
+}
+
+static int send_packet(struct Session *s,
+                       int sock,
+                       struct sockaddr *remoteaddr,
+                       socklen_t remoteaddr_len) {
+  // note: tx.acks[] is filled in incrementally; we just transmit the current
+  // state of it here.  The reason we keep a list of the most recent acks is in
+  // case our packet gets lost, so the receiver will have more chances to
+  // receive the timing information for the packets it sent us.
+  if (is_server) {
+    if (sendto(sock, &s->tx, sizeof(s->tx), 0,
+               remoteaddr, remoteaddr_len) < 0) {
+      perror("sendto");
+    }
+  } else {
+    if (send(sock, &s->tx, sizeof(s->tx), 0) < 0) {
+      int e = errno;
+      perror("send");
+      if (e == ECONNREFUSED) return 2;
+    }
+  }
+  s->next_send += s->usec_per_pkt;
+  return 0;
+}
+
+
+void handle_packet(struct Session *s, uint32_t now) {
+  // process the incoming packet header.
+  // Most of the complexity here comes from the fact that the remote
+  // system's clock will be skewed vs. ours.  (We use CLOCK_MONOTONIC
+  // instead of CLOCK_REALTIME, so unless we figure out the skew offset,
+  // it's essentially meaningless to compare the two values.)  We can
+  // however assume that both clocks are ticking at 1 microsecond per
+  // tick... except for inevitable clock rate errors, which we have to
+  // account for occasionally.
+
+  uint32_t txtime = ntohl(s->rx.txtime), rxtime = now;
+  uint32_t id = ntohl(s->rx.id);
+  if (!s->next_rx_id) {
+    // The remote txtime is told to us by the sender, so it is always perfectly
+    // correct... but it uses the sender's clock.
+    s->start_rtxtime = txtime - id * s->usec_per_pkt;
+
+    // The receive time uses our own clock and is estimated by us, so it needs
+    // to be corrected over time because:
+    //   a) the two clocks inevitably run at slightly different speeds;
+    //   b) there's an unknown, variable, network delay between tx and rx.
+    // Here, we're just assigning an initial estimate.
+    s->start_rxtime = rxtime - id * s->usec_per_pkt;
+
+    s->min_cycle_rxdiff = 0;
+    s->next_rx_id = id;
+    s->next_cycle = now + USEC_PER_CYCLE;
+  }
+
+  // see if we missed receiving any previous packets.
+  int32_t tmpdiff = DIFF(id, s->next_rx_id);
+  if (tmpdiff > 0) {
+    // arriving packet has id > expected, so something was lost.
+    // Note that we don't use the rx.acks[] structure to determine packet loss;
+    // that's because the limited size of the array means that, during a longer
+    // outage, we might not see an ack for a packet *even if that packet arrived
+    // safely* at the remote.  So we count on the remote end to count its own
+    // packet losses using sequence numbers, and send that count back to us.  We
+    // do the same here for incoming packets from the remote, and send the error
+    // count back to them next time we're ready to transmit.
+    fprintf(stderr, "lost %ld  expected=%ld  got=%ld\n",
+            (long)tmpdiff, (long)s->next_rx_id, (long)id);
+    s->num_lost += tmpdiff;
+    s->next_rx_id += tmpdiff + 1;
+  } else if (!tmpdiff) {
+    // exactly as expected; good.
+    s->next_rx_id++;
+  } else if (tmpdiff < 0) {
+    // packet before the expected one? weird.
+    fprintf(stderr, "out-of-order packets? %ld\n", (long)tmpdiff);
+  }
+
+  // fix up the clock offset if there's any drift.
+  tmpdiff = DIFF(rxtime, s->start_rxtime + id * s->usec_per_pkt);
+  if (tmpdiff < -20) {
+    // packet arrived before predicted time, so prediction was based on
+    // a packet that was "slow" before, or else one of our clocks is
+    // drifting. Use earliest legitimate start time.
+    fprintf(stderr, "time paradox: backsliding start by %ld usec\n",
+            (long)tmpdiff);
+    s->start_rxtime = rxtime - id * s->usec_per_pkt;
+  }
+  int32_t rxdiff = DIFF(rxtime, s->start_rxtime + id * s->usec_per_pkt);
+
+  // Figure out the offset between our clock and the remote's clock, so we can
+  // calculate the minimum round trip time (rtt). Then, because the consecutive
+  // packets sent in both directions are equally spaced in time, we can figure
+  // out how much a particular packet was delayed in transit - independently in
+  // each direction! This is an advantage over the normal "ping" program which
+  // has no way to tell which direction caused the delay, or which direction
+  // dropped the packet.
+
+  // Our clockdiff is
+  //   (our rx time) - (their tx time)
+  //   == (their rx time + offset) - (their tx time)
+  //   == (their tx time + offset + 1/2 rtt) - (their tx time)
+  //   == offset + 1/2 rtt
+  // and theirs (rx.clockdiff) is:
+  //   (their rx time) - (our tx time)
+  //   == (their rx time) - (their tx time + offset)
+  //   == (their tx time + 1/2 rtt) - (their tx time + offset)
+  //   == 1/2 rtt - offset
+  // So add them together and we get:
+  //   offset + 1/2 rtt + 1/2 rtt - offset
+  //   == rtt
+  // Subtract them and we get:
+  //   offset + 1/2 rtt - 1/2 rtt + offset
+  //   == 2 * offset
+  // ...but that last subtraction is dangerous because if we divide by 2 to get
+  // offset, it doesn't work with 32-bit math, which may have discarded a
+  // high-order bit somewhere along the way.  Instead, we can extract offset
+  // once we have rtt by substituting it into
+  //   clockdiff = offset + 1/2 rtt
+  //   offset = clockdiff - 1/2 rtt
+  // (Dividing rtt by 2 is safe since it's always small and positive.)
+  //
+  // (This example assumes 1/2 rtt in each direction. There's no way to
+  // determine it more accurately than that.)
+  int32_t clockdiff = DIFF(s->start_rxtime, s->start_rtxtime);
+  int32_t rtt = clockdiff + ntohl(s->rx.clockdiff);
+  int32_t offset = DIFF(clockdiff, rtt / 2);
+  if (!ntohl(s->rx.clockdiff)) {
+    // don't print the first packet: it has an invalid clockdiff since the
+    // client can't calculate the clockdiff until it receives at least one
+    // packet from us.
+    s->last_print = now - s->usec_per_print + 1;
+  } else {
+    // not the first packet, so statistics are valid.
+    s->lat_rx_count++;
+    s->lat_rx = rxdiff + rtt/2;
+    s->lat_rx_min = s->lat_rx_min > s->lat_rx ? s->lat_rx : s->lat_rx_min;
+    s->lat_rx_max = s->lat_rx_max < s->lat_rx ? s->lat_rx : s->lat_rx_max;
+    s->lat_rx_sum += s->lat_rx;
+    s->lat_rx_var_sum += s->lat_rx * s->lat_rx;
+  }
+
+  // Note: the way ok_to_print is structured, if there is a dropout in the
+  // connection for more than usec_per_print, we will statistically end up
+  // printing the first packet after the dropout ends.  That one should have the
+  // longest timeout, ie. a "worst case" packet, which is usually the
+  // information you want to see.
+  int ok_to_print = !quiet && DIFF(now, s->last_print) >= s->usec_per_print;
+  if (ok_to_print) {
+    if (want_timestamps) print_timestamp(rxtime);
+    printf("%12s  %6.1f ms rx  (min=%.1f)  loss: %ld/%ld tx  %ld/%ld rx\n",
+           s->last_ackinfo,
+           (rxdiff + rtt/2) / 1000.0,
+           (rtt/2) / 1000.0,
+           (long)ntohl(s->rx.num_lost),
+           (long)s->next_tx_id - 1,
+           (long)s->num_lost,
+           (long)s->next_rx_id - 1);
+    s->last_ackinfo[0] = '\0';
+    s->last_print = now;
+  }
+
+  if (rxdiff < s->min_cycle_rxdiff) s->min_cycle_rxdiff = rxdiff;
+  if (DIFF(now, s->next_cycle) >= 0) {
+    if (s->min_cycle_rxdiff > 0) {
+      fprintf(stderr, "clock skew: sliding start by %ld usec\n",
+              (long)s->min_cycle_rxdiff);
+      s->start_rxtime += s->min_cycle_rxdiff;
+    }
+    s->min_cycle_rxdiff = 0x7fffffff;
+    s->next_cycle += USEC_PER_CYCLE;
+  }
+
+  // schedule this for an ack next time we send the packet
+  s->tx.acks[s->next_txack_index].id = htonl(id);
+  s->tx.acks[s->next_txack_index].rxtime = htonl(rxtime);
+  s->next_txack_index = (s->next_txack_index + 1) % ARRAY_LEN(s->tx.acks);
+
+  // see which of our own transmitted packets have been acked
+  uint32_t first_ack = ntohl(s->rx.first_ack);
+  for (uint32_t i = 0; i < ARRAY_LEN(s->rx.acks); i++) {
+    uint32_t acki = (first_ack + i) % ARRAY_LEN(s->rx.acks);
+    uint32_t ackid = ntohl(s->rx.acks[acki].id);
+    if (!ackid) continue;  // empty slot
+    if (DIFF(ackid, s->next_rxack_id) >= 0) {
+      // an expected ack
+      uint32_t start_txtime = s->next_send - s->next_tx_id * s->usec_per_pkt;
+      uint32_t txtime = start_txtime + ackid * s->usec_per_pkt;
+      uint32_t rrxtime = ntohl(s->rx.acks[acki].rxtime);
+      uint32_t rxtime = rrxtime + offset;
+      // note: already contains 1/2 rtt, unlike rxdiff
+      int32_t txdiff = DIFF(rxtime, txtime);
+      if (s->usec_per_print <= 0 && s->last_ackinfo[0]) {
+        // only print multiple acks per rx if no usec_per_print limit
+        if (want_timestamps) print_timestamp(rxtime);
+        printf("%12s\n", s->last_ackinfo);
+        s->last_ackinfo[0] = '\0';
+      }
+      if (!s->last_ackinfo[0]) {
+        snprintf(s->last_ackinfo, sizeof(s->last_ackinfo), "%6.1f ms tx",
+                 txdiff / 1000.0);
+      }
+      s->next_rxack_id = ackid + 1;
+      s->lat_tx_count++;
+      s->lat_tx = txdiff;
+      s->lat_tx_min = s->lat_tx_min > s->lat_tx ? s->lat_tx : s->lat_tx_min;
+      s->lat_tx_max = s->lat_tx_max < s->lat_tx ? s->lat_tx : s->lat_tx_max;
+      s->lat_tx_sum += s->lat_tx;
+      s->lat_tx_var_sum += s->lat_tx * s->lat_tx;
+    }
+  }
+
+  s->last_rxtime = rxtime;
+}
+
+
+int isoping_main(int argc, char **argv) {
+  struct sockaddr_in6 listenaddr, rxaddr, last_rxaddr;
+  struct sockaddr *remoteaddr = NULL;
+  socklen_t remoteaddr_len = 0, rxaddr_len = 0;
+  struct addrinfo *ai = NULL;
+  int sock = -1;
+
+  setvbuf(stdout, NULL, _IOLBF, 0);
+
+  int c;
+  while ((c = getopt(argc, argv, "f:r:t:qTh?")) >= 0) {
+    switch (c) {
+    case 'f':
+      prints_per_sec = atof(optarg);
+      if (prints_per_sec <= 0) {
+        fprintf(stderr, "%s: lines per second must be >= 0\n", argv[0]);
+        return 99;
+      }
+      break;
+    case 'r':
+      packets_per_sec = atof(optarg);
+      if (packets_per_sec < 0.001 || packets_per_sec > 1e6) {
+        fprintf(stderr, "%s: packets per sec (-r) must be 0.001..1000000\n",
+                argv[0]);
+        return 99;
+      }
+      break;
+    case 't':
+      ttl = atoi(optarg);
+      if (ttl < 1) {
+        fprintf(stderr, "%s: ttl must be >= 1\n", argv[0]);
+        return 99;
+      }
+      break;
+    case 'q':
+      quiet = 1;
+      break;
+    case 'T':
+      want_timestamps = 1;
+      break;
+    case 'h':
+    case '?':
+    default:
+      usage_and_die(argv[0]);
+      break;
+    }
+  }
+
+  sock = socket(PF_INET6, SOCK_DGRAM, 0);
+  if (sock < 0) {
+    perror("socket");
+    return 1;
+  }
+
+  if (argc - optind == 0) {
+    is_server = 1;
+    memset(&listenaddr, 0, sizeof(listenaddr));
+    listenaddr.sin6_family = AF_INET6;
+    listenaddr.sin6_port = htons(SERVER_PORT);
+    if (bind(sock, (struct sockaddr *)&listenaddr, sizeof(listenaddr)) != 0) {
+      perror("bind");
+      return 1;
+    }
+    socklen_t addrlen = sizeof(listenaddr);
+    if (getsockname(sock, (struct sockaddr *)&listenaddr, &addrlen) != 0) {
+      perror("getsockname");
+      return 1;
+    }
+    fprintf(stderr, "server listening at [%s]:%d\n",
+           sockaddr_to_str((struct sockaddr *)&listenaddr),
+           ntohs(listenaddr.sin6_port));
+  } else if (argc - optind == 1) {
+    const char *remotename = argv[optind];
+    is_server = 0;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = AI_ADDRCONFIG | AI_V4MAPPED;
+    hints.ai_family = AF_INET6;
+    hints.ai_socktype = SOCK_DGRAM;
+    int err = getaddrinfo(remotename, STR(SERVER_PORT), &hints, &ai);
+    if (err != 0 || !ai) {
+      fprintf(stderr, "getaddrinfo(%s): %s\n", remotename, gai_strerror(err));
+      return 1;
+    }
+    fprintf(stderr, "connecting to %s...\n", sockaddr_to_str(ai->ai_addr));
+    if (connect(sock, ai->ai_addr, ai->ai_addrlen) != 0) {
+      perror("connect");
+      return 1;
+    }
+    remoteaddr = ai->ai_addr;
+    remoteaddr_len = ai->ai_addrlen;
+  } else {
+    usage_and_die(argv[0]);
+  }
+
+  fprintf(stderr, "using ttl=%d\n", ttl);
+  // IPPROTO_IPV6 is the only one that works on MacOS, and is arguably the
+  // technically correct thing to do since it's an AF_INET6 socket.
+  if (setsockopt(sock, IPPROTO_IPV6, IP_TTL, &ttl, sizeof(ttl))) {
+    perror("setsockopt(TTLv6)");
+    return 1;
+  }
+  // ...but in Linux (at least 3.13), IPPROTO_IPV6 does not actually
+  // set the TTL if the IPv6 socket ends up going over IPv4.  We have to
+  // set that separately.  On MacOS, that always returns EINVAL, so ignore
+  // the error if that happens.
+  if (setsockopt(sock, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl))) {
+    if (errno != EINVAL) {
+      perror("setsockopt(TTLv4)");
+      return 1;
+    }
+  }
+
+  uint32_t now = ustime();       // current time
+
+  struct sigaction act;
+  memset(&act, 0, sizeof(act));
+  act.sa_handler = sighandler;
+  act.sa_flags = SA_RESETHAND;
+  sigaction(SIGINT, &act, NULL);
+
+  struct Session s(now);
+
+  while (!want_to_die) {
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(sock, &rfds);
+    struct timeval tv;
+    tv.tv_sec = 0;
+
+    now = ustime();
+    if (DIFF(s.next_send, now) < 0) {
+      tv.tv_usec = 0;
+    } else {
+      tv.tv_usec = DIFF(s.next_send, now);
+    }
+    int nfds = select(sock + 1, &rfds, NULL, NULL, remoteaddr ? &tv : NULL);
+    now = ustime();
+    if (nfds < 0 && errno != EINTR) {
+      perror("select");
+      return 1;
+    }
+
+    // time to send the next packet?
+    if (remoteaddr && DIFF(now, s.next_send) >= 0) {
+      prepare_tx_packet(&s);
+      int err = send_packet(&s, sock, remoteaddr, remoteaddr_len);
+      if (err != 0) {
+        return err;
+      }
+      // TODO(pmccurdy): Track disconnections across multiple clients.  Use
+      // recvmsg with the MSG_ERRQUEUE flag to detect connection refused.
+      if (is_server && DIFF(now, s.last_rxtime) > 60*1000*1000) {
+        fprintf(stderr, "client disconnected.\n");
+        remoteaddr = NULL;
+      }
+    }
+
+    if (nfds > 0) {
+      // incoming packet
+      rxaddr_len = sizeof(rxaddr);
+      ssize_t got = recvfrom(sock, &s.rx, sizeof(s.rx), 0,
+                             (struct sockaddr *)&rxaddr, &rxaddr_len);
+      if (got < 0) {
+        int e = errno;
+        perror("recvfrom");
+        if (!is_server && e == ECONNREFUSED) return 2;
+        continue;
+      }
+      if (got != sizeof(s.rx) || s.rx.magic != htonl(MAGIC)) {
+        fprintf(stderr, "got invalid packet of length %ld\n", (long)got);
+        continue;
+      }
+
+      // is it a new client?
+      if (is_server) {
+        // TODO(pmccurdy): Maintain a hash table of Sessions, look up based
+        // on rxaddr, create a new one if necessary, remove this resetting code.
+        if (!remoteaddr ||
+            memcmp(&rxaddr, &last_rxaddr, sizeof(rxaddr)) != 0) {
+          fprintf(stderr, "new client connected: %s\n",
+                  sockaddr_to_str((struct sockaddr *)&rxaddr));
+          memcpy(&last_rxaddr, &rxaddr, sizeof(rxaddr));
+          remoteaddr = (struct sockaddr *)&last_rxaddr;
+          remoteaddr_len = rxaddr_len;
+
+          s.next_send = now + 10*1000;
+          s.next_tx_id = 1;
+          s.next_rx_id = s.next_rxack_id = 0;
+          s.start_rtxtime = s.start_rxtime = 0;
+          s.num_lost = 0;
+          s.next_txack_index = 0;
+          s.usec_per_pkt = ntohl(s.rx.usec_per_pkt);
+          memset(&s.tx, 0, sizeof(s.tx));
+        }
+      }
+
+      handle_packet(&s, now);
+    }
+  }
+
+  // TODO(pmccurdy): Separate out per-client and global stats.
+  printf("\n---\n");
+  printf("tx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
+         s.lat_tx_min / 1000.0,
+         DIV(s.lat_tx_sum, s.lat_tx_count) / 1000.0,
+         s.lat_tx_max / 1000.0,
+         onepass_stddev(
+             s.lat_tx_var_sum, s.lat_tx_sum, s.lat_tx_count) / 1000.0);
+  printf("rx: min/avg/max/mdev = %.2f/%.2f/%.2f/%.2f ms\n",
+         s.lat_rx_min / 1000.0,
+         DIV(s.lat_rx_sum, s.lat_rx_count) / 1000.0,
+         s.lat_rx_max / 1000.0,
+         onepass_stddev(
+             s.lat_rx_var_sum, s.lat_rx_sum, s.lat_rx_count) / 1000.0);
+  printf("\n");
+
+  if (ai) freeaddrinfo(ai);
+  if (sock >= 0) close(sock);
+  return 0;
+}
diff --git a/cmds/isoping.h b/cmds/isoping.h
new file mode 100644
index 0000000..52fcccb
--- /dev/null
+++ b/cmds/isoping.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2016 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ISOPING_H
+#define ISOPING_H
+
+#include <stdint.h>
+
+// Layout of the UDP packets exchanged between client and server.
+// All integers are in network byte order.
+// Packets have exactly the same structure in both directions.
+struct Packet {
+  uint32_t magic;     // magic number to reject bogus packets
+  uint32_t id;        // sequential packet id number
+  uint32_t txtime;    // transmitter's monotonic time when pkt was sent
+  uint32_t clockdiff; // estimate of (transmitter's clk) - (receiver's clk)
+  uint32_t usec_per_pkt; // microseconds of delay between packets
+  uint32_t num_lost;  // number of pkts transmitter expected to get but didn't
+  uint32_t first_ack; // starting index in acks[] circular buffer
+  struct {
+    // txtime==0 for empty elements in this array.
+    uint32_t id;      // id field from a received packet
+    uint32_t rxtime;  // receiver's monotonic time when pkt arrived
+  } acks[64];
+};
+
+
+// Data we track per session.
+struct Session {
+  Session(uint32_t now);
+  int32_t usec_per_pkt;
+  int32_t usec_per_print;
+
+  // WARNING: lots of math below relies on well-defined uint32/int32
+  // arithmetic overflow behaviour, plus the fact that when we subtract
+  // two successive timestamps (for example) they will be less than 2^31
+  // microseconds apart.  It would be safer to just use 64-bit values
+  // everywhere, but that would cut the number of acks-per-packet in half,
+  // which would be unfortunate.
+  uint32_t next_tx_id;       // id field for next transmit
+  uint32_t next_rx_id;       // expected id field for next receive
+  uint32_t next_rxack_id;    // expected ack.id field in next received ack
+  uint32_t start_rtxtime;    // remote's txtime at startup
+  uint32_t start_rxtime;     // local rxtime at startup
+  uint32_t last_rxtime;      // local rxtime of last received packet
+  int32_t min_cycle_rxdiff;  // smallest packet delay seen this cycle
+  uint32_t next_cycle;       // time when next cycle begins
+  uint32_t next_send;        // time when we'll send next pkt
+  uint32_t num_lost;         // number of rx packets not received
+  int next_txack_index;      // next array item to fill in tx.acks
+  struct Packet tx, rx;      // transmit and received packet buffers
+  char last_ackinfo[128];    // human readable format of latest ack
+  uint32_t last_print;       // time of last packet printout
+  // Packet statistics counters for transmit and receive directions.
+  long long lat_tx, lat_tx_min, lat_tx_max,
+      lat_tx_count, lat_tx_sum, lat_tx_var_sum;
+  long long lat_rx, lat_rx_min, lat_rx_max,
+      lat_rx_count, lat_rx_sum, lat_rx_var_sum;
+};
+
+// Process the Session's incoming packet, from s->rx.
+void handle_packet(struct Session *s, uint32_t now);
+
+// Sets all the elements of s->tx to be ready to be sent to the other side.
+void prepare_tx_packet(struct Session *s);
+
+// Parses arguments and runs the main loop.  Distinct from main() for unit test
+// purposes.
+int isoping_main(int argc, char **argv);
+
+#endif
diff --git a/cmds/isoping_main.cc b/cmds/isoping_main.cc
new file mode 100644
index 0000000..521b5e1
--- /dev/null
+++ b/cmds/isoping_main.cc
@@ -0,0 +1,5 @@
+#include "isoping.h"
+
+int main(int argc, char **argv) {
+  return isoping_main(argc, argv);
+}
diff --git a/cmds/isoping_test.cc b/cmds/isoping_test.cc
new file mode 100644
index 0000000..84edc46
--- /dev/null
+++ b/cmds/isoping_test.cc
@@ -0,0 +1,420 @@
+/*
+ * Copyright 2016 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <arpa/inet.h>
+#include <limits.h>
+#include <stdio.h>
+
+#include <wvtest.h>
+
+#include "isoping.h"
+
+uint32_t send_next_packet(Session *from, uint32_t from_base,
+                          Session *to, uint32_t to_base, uint32_t latency) {
+  uint32_t t = from->next_send - from_base;
+  prepare_tx_packet(from);
+  to->rx = from->tx;
+  from->next_send += from->usec_per_pkt;
+  t += latency;
+  handle_packet(to, to_base + t);
+  fprintf(stderr,
+          "**Sent packet: txtime=%d, start_txtime=%d, rxtime=%d, "
+          "start_rxtime=%d, latency=%d, t_from=%d, t_to=%d\n",
+          from->next_send,
+          to->start_rtxtime,
+          to_base + t,
+          to->start_rxtime,
+          latency,
+          t - latency,
+          t);
+
+  return t;
+}
+
+WVTEST_MAIN("isoping algorithm logic") {
+  // Establish a positive base time for client and server.  This is conceptually
+  // the instant when the client sends its first message to the server, as
+  // measured by the clocks on each side (note: this is before the server
+  // receives the message).
+  uint32_t cbase = 400 * 1000;
+  uint32_t sbase = 600 * 1000;
+  uint32_t real_clockdiff = sbase - cbase;
+
+  // The states of the client and server.
+  struct Session c(cbase);
+  struct Session s(sbase);
+
+  // One-way latencies: cs_latency is the latency from client to server;
+  // sc_latency is from server to client.
+  uint32_t cs_latency = 24 * 1000;
+  uint32_t sc_latency = 25 * 1000;
+  uint32_t half_rtt = (sc_latency + cs_latency) / 2;
+
+  // Elapsed time, relative to the base time for each clock.
+  uint32_t t = 0;
+
+  // Send the initial packet from client to server.  This isn't enough to let us
+  // draw any useful latency conclusions.
+  // TODO(pmccurdy): Setting next_send is duplicating some work done in the main
+  // loop / send_packet.  Extract that into somewhere testable, then test it.
+  c.next_send = cbase;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency);
+  uint32_t rxtime = sbase + t;
+  s.next_send = rxtime + 10 * 1000;
+
+  printf("last_rxtime: %d\n", s.last_rxtime);
+  printf("min_cycle_rxdiff: %d\n", s.min_cycle_rxdiff);
+  WVPASSEQ(s.rx.clockdiff, 0);
+  WVPASSEQ(s.last_rxtime, rxtime);
+  WVPASSEQ(s.min_cycle_rxdiff, 0);
+  WVPASSEQ(ntohl(s.tx.acks[0].id), 1);
+  WVPASSEQ(s.next_txack_index, 1);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].id), 1);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(s.start_rxtime, rxtime - c.usec_per_pkt);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(s.next_send, rxtime + 10 * 1000);
+
+  // Reply to the client.
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency);
+
+  // Now we have enough data to figure out latencies on the client.
+  rxtime = cbase + t;
+  WVPASSEQ(c.start_rxtime, rxtime - s.usec_per_pkt);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - s.usec_per_pkt);
+  WVPASSEQ(c.min_cycle_rxdiff, 0);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency);
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].id), 1);
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(c.num_lost, 0);
+  WVPASSEQ(c.lat_tx_count, 1);
+  WVPASSEQ(c.lat_tx, half_rtt);
+  WVPASSEQ(c.lat_rx_count, 1);
+  WVPASSEQ(c.lat_rx, half_rtt);
+  WVPASSEQ(c.num_lost, 0);
+
+  // Round 2
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency);
+  rxtime = sbase + t;
+
+  // Now the server also knows latencies.
+  WVPASSEQ(s.start_rxtime, sbase + cs_latency - s.usec_per_pkt);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].id), 2);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(s.num_lost, 0);
+  WVPASSEQ(s.lat_tx_count, 1);
+  WVPASSEQ(s.lat_tx, half_rtt);
+  WVPASSEQ(s.lat_rx_count, 1);
+  WVPASSEQ(s.lat_rx, half_rtt);
+  WVPASSEQ(s.num_lost, 0);
+
+  // Increase the latencies in both directions, reply to client.
+  int32_t latency_diff = 10 * 1000;
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency + latency_diff);
+
+  rxtime = cbase + t;
+  WVPASSEQ(ntohl(s.tx.clockdiff), real_clockdiff + cs_latency);
+  WVPASSEQ(c.start_rxtime,
+           rxtime - ntohl(s.tx.id) * s.usec_per_pkt - latency_diff);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - s.usec_per_pkt);
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].id), 2);
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(c.num_lost, 0);
+  WVPASSEQ(c.lat_tx_count, 2);
+  WVPASSEQ(c.lat_tx, half_rtt);
+  WVPASSEQ(c.lat_rx_count, 2);
+  WVPASSEQ(c.lat_rx, half_rtt + latency_diff);
+  WVPASSEQ(c.num_lost, 0);
+
+  // Client replies with increased latency, server notices.
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + latency_diff);
+
+  rxtime = sbase + t;
+  WVPASSEQ(ntohl(c.tx.clockdiff), - real_clockdiff + sc_latency);
+  WVPASSEQ(s.start_rxtime, sbase + cs_latency - s.usec_per_pkt);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].id), 3);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(s.num_lost, 0);
+  WVPASSEQ(s.lat_tx_count, 2);
+  WVPASSEQ(s.lat_tx, half_rtt + latency_diff);
+  WVPASSEQ(s.lat_rx_count, 2);
+  WVPASSEQ(s.lat_rx, half_rtt + latency_diff);
+  WVPASSEQ(s.num_lost, 0);
+
+  // Lose a server->client packet, send the next client->server packet, verify
+  // only the received packets were acked.
+  s.next_send += s.usec_per_pkt;
+  s.next_tx_id++;
+
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + latency_diff);
+
+  rxtime = sbase + t;
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].id), 3);
+  WVPASSEQ(ntohl(s.tx.acks[ntohl(s.tx.first_ack)].rxtime),
+           rxtime - s.usec_per_pkt);
+  WVPASSEQ(s.num_lost, 0);
+  WVPASSEQ(s.lat_tx_count, 2);
+  WVPASSEQ(s.lat_tx, half_rtt + latency_diff);
+  WVPASSEQ(s.lat_rx_count, 3);
+  WVPASSEQ(s.lat_rx, half_rtt + latency_diff);
+  WVPASSEQ(s.num_lost, 0);
+
+  // Remove the extra latency from server->client, send the next packet, have
+  // the client receive it and notice the lost packet and reduced latency.
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency);
+
+  rxtime = cbase + t;
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].id), 4);
+  WVPASSEQ(ntohl(c.tx.acks[ntohl(c.tx.first_ack)].rxtime), rxtime);
+  WVPASSEQ(c.num_lost, 1);
+  WVPASSEQ(c.lat_tx_count, 4);
+  WVPASSEQ(c.lat_tx, half_rtt + latency_diff);
+  WVPASSEQ(c.lat_rx_count, 3);
+  WVPASSEQ(c.lat_rx, half_rtt);
+  WVPASSEQ(c.num_lost, 1);
+
+  // A tiny reduction in latency shows up in min_cycle_rxdiff.
+  latency_diff = 0;
+  int32_t latency_mini_diff = -15;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + latency_mini_diff);
+
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(s.min_cycle_rxdiff, latency_mini_diff);
+  WVPASSEQ(s.start_rxtime, sbase + cs_latency - s.usec_per_pkt);
+  WVPASSEQ(s.lat_tx, half_rtt);
+  WVPASSEQ(s.lat_rx, half_rtt + latency_mini_diff);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency + latency_mini_diff);
+
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(c.min_cycle_rxdiff, latency_mini_diff);
+  WVPASSEQ(c.lat_tx, half_rtt + latency_mini_diff);
+  WVPASSEQ(c.lat_rx, half_rtt + latency_mini_diff);
+
+  // Reduce the latency dramatically, verify that both sides see it, and the
+  // start time is modified (not the min_cycle_rxdiff).
+  latency_diff = -22 * 1000;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + latency_diff);
+
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(s.min_cycle_rxdiff, latency_mini_diff);
+  // We see half the latency diff applied to each side of the connection because
+  // the reduction in latency creates a time paradox, rebasing the start time
+  // and recalculating the RTT.
+  WVPASSEQ(s.start_rxtime, sbase + cs_latency + latency_diff - s.usec_per_pkt);
+  WVPASSEQ(s.lat_tx, half_rtt + latency_diff/2 + latency_mini_diff);
+  WVPASSEQ(s.lat_rx, half_rtt + latency_diff/2);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency + latency_diff);
+
+  // Now we see the new latency applied to both sides.
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(c.min_cycle_rxdiff, latency_mini_diff);
+  WVPASSEQ(c.lat_tx, half_rtt + latency_diff);
+  WVPASSEQ(c.lat_rx, half_rtt + latency_diff);
+
+  // Restore latency on one side of the connection, verify that we track it on
+  // only one side and we've improved our clock sync.
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency);
+
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency + latency_diff);
+  WVPASSEQ(s.lat_tx, half_rtt + latency_diff);
+  WVPASSEQ(s.lat_rx, half_rtt);
+
+  // And double-check that the other side also sees the improved clock sync and
+  // one-sided latency on the correct side.
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency + latency_diff);
+
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency + latency_diff);
+  WVPASSEQ(c.lat_tx, half_rtt);
+  WVPASSEQ(c.lat_rx, half_rtt + latency_diff);
+}
+
+// Verify that isoping handles clocks ticking at different rates.
+WVTEST_MAIN("isoping clock drift") {
+  uint32_t cbase = 1400 * 1000;
+  uint32_t sbase = 1600 * 1000;
+
+  // The states of the client and server.
+  struct Session c(cbase);
+  struct Session s(sbase);
+  // Send packets infrequently, to get new cycles more often.
+  s.usec_per_pkt = 1 * 1000 * 1000;
+  c.usec_per_pkt = 1 * 1000 * 1000;
+
+  // One-way latencies: cs_latency is the latency from client to server;
+  // sc_latency is from server to client.
+  int32_t cs_latency = 4 * 1000;
+  int32_t sc_latency = 5 * 1000;
+  int32_t drift_per_round = 15;
+  uint32_t half_rtt = (sc_latency + cs_latency) / 2;
+
+  // Perform the initial setup.
+  c.next_send = cbase;
+  uint32_t t = send_next_packet(&c, cbase, &s, sbase, cs_latency);
+  s.next_send = sbase + t + 10 * 1000;
+
+  uint32_t orig_server_start_rxtime = s.start_rxtime;
+  WVPASSEQ(s.start_rxtime, sbase + cs_latency - s.usec_per_pkt);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), 0);
+  WVPASSEQ(s.lat_rx, 0);
+  WVPASSEQ(s.lat_tx, 0);
+  WVPASSEQ(s.min_cycle_rxdiff, 0);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency);
+
+  uint32_t orig_client_start_rxtime = c.start_rxtime;
+  WVPASSEQ(c.start_rxtime, cbase + 2 * half_rtt + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency);
+  WVPASSEQ(c.lat_rx, half_rtt);
+  WVPASSEQ(c.lat_tx, half_rtt);
+  WVPASSEQ(c.min_cycle_rxdiff, 0);
+
+  // Clock drift shows up as symmetric changes in one-way latency.
+  int32_t total_drift = drift_per_round;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+  WVPASSEQ(s.start_rxtime, orig_server_start_rxtime);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(s.lat_rx, half_rtt + total_drift);
+  WVPASSEQ(s.lat_tx, half_rtt);
+  WVPASSEQ(s.min_cycle_rxdiff, 0);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency - total_drift);
+
+  WVPASSEQ(c.start_rxtime, cbase + 2 * half_rtt + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(c.start_rtxtime,
+           sbase + cs_latency + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency);
+  WVPASSEQ(c.lat_rx, half_rtt - total_drift);
+  WVPASSEQ(c.lat_tx, half_rtt + total_drift);
+  WVPASSEQ(c.min_cycle_rxdiff, -drift_per_round);
+
+  // Once we exceed -20us of drift, we adjust the client's start_rxtime.
+  total_drift += drift_per_round;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+  WVPASSEQ(s.start_rxtime, orig_server_start_rxtime);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency);
+  WVPASSEQ(s.lat_rx, half_rtt + total_drift);
+  WVPASSEQ(s.lat_tx, half_rtt - drift_per_round);
+  WVPASSEQ(s.min_cycle_rxdiff, 0);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency - total_drift);
+
+  int32_t clock_adj = total_drift;
+  WVPASSEQ(c.start_rxtime,
+           cbase + 2 * half_rtt + 10 * 1000 - c.usec_per_pkt - total_drift);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency);
+  WVPASSEQ(c.lat_rx, half_rtt - drift_per_round);
+  WVPASSEQ(c.lat_tx, half_rtt + drift_per_round);
+  WVPASSEQ(c.min_cycle_rxdiff, -drift_per_round);
+
+  // Skip ahead to the next cycle.
+  int packets_to_skip = 8;
+  s.next_send += packets_to_skip * s.usec_per_pkt;
+  s.next_rx_id += packets_to_skip;
+  s.next_tx_id += packets_to_skip;
+  c.next_send += packets_to_skip * c.usec_per_pkt;
+  c.next_rx_id += packets_to_skip;
+  c.next_tx_id += packets_to_skip;
+  total_drift += packets_to_skip * drift_per_round;
+
+  // At first we blame the rx latency for most of the drift.
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+  // start_rxtime doesn't change here as the first cycle suppresses positive
+  // min_cycle_rxdiff values.
+  // TODO(pmccurdy): Should it?
+  WVPASSEQ(s.start_rxtime, orig_server_start_rxtime);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency - clock_adj);
+  WVPASSEQ(s.lat_rx, half_rtt + total_drift - drift_per_round);
+  WVPASSEQ(s.lat_tx, half_rtt - drift_per_round);
+  WVPASSEQ(s.min_cycle_rxdiff, INT_MAX);
+
+  // After one round-trip, we divide the blame for the latency diff evenly.
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency - total_drift);
+
+  WVPASSEQ(c.start_rxtime, orig_client_start_rxtime - total_drift);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency);
+  WVPASSEQ(c.lat_rx, half_rtt - total_drift / 2);
+  WVPASSEQ(c.lat_tx, half_rtt + total_drift / 2);
+  WVPASSEQ(c.min_cycle_rxdiff, INT_MAX);
+
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+  WVPASSEQ(s.start_rxtime, orig_server_start_rxtime);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff), cbase - sbase + sc_latency - total_drift);
+  WVPASSEQ(s.lat_rx, half_rtt + total_drift / 2);
+  WVPASSEQ(s.lat_tx, half_rtt - total_drift / 2);
+  // We also notice the difference in expected arrival times on the server...
+  WVPASSEQ(s.min_cycle_rxdiff, total_drift);
+
+  total_drift += drift_per_round;
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency - total_drift);
+  // And on the client.  The client doesn't notice the total_drift rxdiff as it
+  // was swallowed by the new cycle.
+  WVPASSEQ(c.min_cycle_rxdiff, -drift_per_round);
+
+  // Skip ahead to the next cycle.
+  packets_to_skip = 8;
+  s.next_send += packets_to_skip * s.usec_per_pkt;
+  s.next_rx_id += packets_to_skip;
+  s.next_tx_id += packets_to_skip;
+  c.next_send += packets_to_skip * c.usec_per_pkt;
+  c.next_rx_id += packets_to_skip;
+  c.next_tx_id += packets_to_skip;
+  total_drift += packets_to_skip * drift_per_round;
+  int32_t drift_per_cycle = 10 * drift_per_round;
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+  // The clock drift has worked its way into the RTT calculation.
+  half_rtt = (cs_latency + sc_latency - drift_per_cycle) / 2;
+
+  // Now start_rxtime has updated.
+  WVPASSEQ(s.start_rxtime, orig_server_start_rxtime + drift_per_cycle);
+  WVPASSEQ(s.start_rtxtime, cbase - c.usec_per_pkt);
+  WVPASSEQ(ntohl(s.rx.clockdiff),
+           cbase - sbase + sc_latency - drift_per_cycle);
+  WVPASSEQ(s.lat_rx, half_rtt + total_drift);
+  WVPASSEQ(s.lat_tx, half_rtt - drift_per_round);
+  WVPASSEQ(s.min_cycle_rxdiff, INT_MAX);
+
+  t = send_next_packet(&s, sbase, &c, cbase, sc_latency - total_drift);
+
+  WVPASSEQ(c.start_rxtime, orig_client_start_rxtime - total_drift);
+  WVPASSEQ(c.start_rtxtime, sbase + cs_latency + 10 * 1000 - c.usec_per_pkt);
+  WVPASSEQ(ntohl(c.rx.clockdiff), sbase - cbase + cs_latency + drift_per_cycle);
+  WVPASSEQ(c.lat_rx, half_rtt + drift_per_round / 2);
+  WVPASSEQ(c.lat_tx, half_rtt + total_drift / 2 + 1);
+  WVPASSEQ(c.min_cycle_rxdiff, INT_MAX);
+
+  t = send_next_packet(&c, cbase, &s, sbase, cs_latency + total_drift);
+
+}
diff --git a/wvtest/.gitignore b/wvtest/.gitignore
new file mode 100644
index 0000000..2a7de39
--- /dev/null
+++ b/wvtest/.gitignore
@@ -0,0 +1,10 @@
+*~
+*.o
+*.a
+*.lib
+*.dll
+*.exe
+*.so
+*.so.*
+*.pyc
+*.mdb
diff --git a/wvtest/LICENSE b/wvtest/LICENSE
new file mode 100644
index 0000000..eb685a5
--- /dev/null
+++ b/wvtest/LICENSE
@@ -0,0 +1,481 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/wvtest/Makefile b/wvtest/Makefile
new file mode 100644
index 0000000..8263908
--- /dev/null
+++ b/wvtest/Makefile
@@ -0,0 +1,29 @@
+
+all: build
+	@echo
+	@echo "Try: make test"
+
+build:
+	$(MAKE) -C dotnet all
+	$(MAKE) -C cpp all
+	$(MAKE) -C c all
+
+runtests: build
+	$(MAKE) -C sh runtests
+	$(MAKE) -C python runtests
+	$(MAKE) -C dotnet runtests
+	$(MAKE) -C cpp runtests
+	$(MAKE) -C c runtests
+	$(MAKE) -C javascript runtests
+
+
+test: build
+	./wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ .*~
+	$(MAKE) -C sh clean
+	$(MAKE) -C python clean
+	$(MAKE) -C dotnet clean
+	$(MAKE) -C cpp clean
+	$(MAKE) -C c clean
diff --git a/wvtest/README b/wvtest/README
new file mode 100644
index 0000000..824114a
--- /dev/null
+++ b/wvtest/README
@@ -0,0 +1,375 @@
+
+WvTest: the dumbest cross-platform test framework that could possibly work
+==========================================================================
+
+I have a problem with your unit testing framework.  Yes, you.
+The person reading this.  No, don't look away guiltily.  You
+know your unit testing framework sucks.  You know it has a
+million features you don't understand.  You know you hate it,
+and it hates you.  Don't you?
+
+Okay, fine.  Let's be honest.  Actually, I don't know who you
+are or how you feel about your unit testing framework, but I've
+tried a lot of them, and I don't like any of them.  WvTest is
+the first one I don't hate, at least sort of.  That might be
+because I'm crazy and I only like things I design, or it might
+be because I'm crazy and therefore I'm the only one capable of
+designing a likable unit testing framework.  Who am I to say?
+
+Here are the fundamental design goals of WvTest:
+
+ - Be the stupidest thing that can possibly work.  People are
+   way, way too serious about their testing frameworks.  Some
+   people build testing frameworks as their *full time job*.
+   This is ridiculous.  A test framework, at its core, only does
+   one thing: it runs a program that returns true or false.  If
+   it's false, you lose.  If it's true, you win.  Everything
+   after that is gravy.  And WvTest has only a minimal amount of
+   gravy.
+
+ - Be a protocol, not an API.  If you don't like my API, you can
+   write your own, and it can still be WvTest and it can still
+   integrate with other WvTest tools.  If you're stuck with
+   JUnit or NUnit, you can just make your JUnit/NUnit test
+   produce WvTest-compatible output if you want (although I've
+   never done this, so you'll have to do it yourself).  I'll
+   describe the protocol below.
+
+ - Work with multiple languages on multiple operating systems.
+   I'm a programmer who programs on Linux, MacOS, and Windows,
+   to name just three, and I write in lots of programming
+   languages, including C, C++, C#, Python, Perl, and others.
+   And worse, some of my projects use *multiple* languages and I
+   want to have unit tests for *all* of them.  I don't know of
+   any unit testing framework - except maybe some horrendously
+   overdesigned ones - that work with multiple languages at
+   once.  WvTest does.
+
+ - NO UNNECESSARY OBJECT ORIENTATION.  The big unit testing
+   craze seems to have been started by JUnit in Java, which is
+   object-oriented.  Now, that's not a misdesign in JUnit; it's
+   a misdesign in Java.  You see, you can't *not* encapsulate
+   absolutely everything in Java in a class, so it's perfectly
+   normal for JUnit to require you to encapsulate everything in
+   a class.  That's not true of almost any other language
+   (except C#), and yet *every* clone of JUnit in *every*
+   language seems to have copied its classes and objects.  Well,
+   that's stupid.  WvTest is designed around the simple idea of
+   test *functions*.  WvTest runs your function, it checks a
+   bunch of stuff and it returns or else it dies horribly.  If
+   your function wants to instantiate some objects while it does
+   that, then that's great; WvTest doesn't care.  And yes, you
+   can assert whether two variables are equal even if your
+   function *isn't* in a particular class, just as God intended.
+
+ - Don't make me name or describe my individual tests.  How many
+   times have you seen this?
+
+       assertTrue(thing.works(), "thing didn't work!");
+
+   The reasoning there is that if the test fails, we want to be
+   able to print a user-friendly error message that describes
+   why.  Right?  NO!!  That is *awful*.  That just *doubled* the
+   amount of work you have to do in order to write a test.
+   Instead, WvTest auto-generates output including the line
+   number of the test and the code on that line.  So you get a
+   message like this:
+
+       ! mytest.t.cc:431  thing.works()    FAILED
+
+   and all you have to write is this:
+
+       WVPASS(thing.works());
+
+   (WVPASS is all-caps because it's a macro in C++, but also
+    because you want your tests to stand out.  That's what
+    you'll be looking for when it fails, after all.  And don't
+    even get me started about the 'True' in assertTrue.  Come
+    on, *obviously* you're going to assert that the condition is
+    true!)
+
+ - No setup() and teardown() functions or fixtures.  "Ouch!" you
+   say.  "I'm going to have so much duplicated code!" No, only
+   if you're an idiot.  You know what setup() and teardown() are
+   code names for?  Constructor and destructor.  Create some
+   objects and give them constructors and destructors, and I
+   think you'll find that, like magic, you've just invented
+   "test fixtures."  Nothing any test framework can possibly do
+   will make that any easier.  In fact, everything test
+   frameworks *try* to do with test fixtures just makes it
+   harder to write, read, and understand.  Forget it.
+
+ - Big long scary test functions.  Some test frameworks are
+   insistent about the rule that "every function should test
+   only one thing." Nobody ever really explains why.  I can't
+   understand this; it just causes uncontrolled
+   hormone-imbalance hypergrowth in your test files, and you
+   have to type more stuff... and run test fixtures over and
+   over.
+
+   My personal theory for why people hate big long test
+   functions: it's because their assertTrue() implementation
+   doesn't say which test failed, so they'd like the *name of
+   the function* to be the name of the failed test.  Well,
+   that's a cute workaround to a problem you shouldn't have had
+   in the first place.  With WvTest, WVPASS() actually tells you
+   exactly what passed and what failed, so it's perfectly okay -
+   and totally comprehensible - to have a sequence of five
+   things in a row where only thing number five failed.
+
+
+The WvTest Protocol
+-------------------
+
+WvTest is a protocol, not really an API.  As it happens, the
+WvTest project includes several (currently five)
+implementations of APIs that produce data in the WvTest format,
+but it's super easy to add your own.
+
+The format is really simple too.  It looks like this:
+
+	Testing "my test function" in mytest.t.cc:
+	! mytest.t.cc:432     thing.works()         ok
+	This is just some crap that I printed while counting to 3.
+	! mytest.t.cc.433     3 < 4                 FAILED
+
+There are only four kinds of lines in WvTest, and each of the
+lines above corresponds to one of them:
+
+ - Test function header.  A line that starts with the word
+   Testing (no leading whitespace) and then has a test function
+   name in double quotes, then "in", then the filename, and then
+   colon, marks the beginning of a test function.
+
+ - A passing assertion.  Any line that starts with ! and ends with
+   " ok" (whitespace, the word "ok", and a newline) indicates
+   one assertion that passed.  The first "word" on that line is
+   the "name" of that assertion (which can be anything, as long
+   as it doesn't contain any whitespace).  Everything between the
+   name and the ok is just some additional user-readable detail
+   about the test that passed.
+
+ - Random filler.  If it doesn't start with an ! and it doesn't
+   look like a header, then it's completely ignored by anything
+   using WvTest.  Your program can print all the debug output it
+   wants, and WvTest won't care, except that you can retrieve it
+   later in case you're wondering why a test failed.  Naturally,
+   random filler *before* an assertion is considered to be
+   associated with that assertion; the assertion itself is the
+   last part of a test.
+
+ - A failing assertion.  This is just like an 'ok' line, except
+   the last word is something other than 'ok'.  Generally we use
+   FAILED here, but sometimes it's EXCEPTION, and it could be
+   something else instead, if you invent a new and improved way
+   to fail.
+
+
+Reading the WvTest Protocol: wvtestrun
+--------------------------------------
+
+WvTest provides a simple perl script called wvtestrun, which
+runs a test program and parses its output.  It works like this:
+
+	cd python
+	../wvtestrun ./wvtest.py t/twvtest.py
+
+(Why can't we just pipe the output to wvtestrun, instead of
+ having wvtestrun run the test program?  Three reasons: first, a
+ fancier version of wvtestrun could re-run the tests several
+ times or give a GUI that lets you re-run the test when you push
+ a button.  Second, it handles stdout and stderr separately.
+ And third, it can kill the test program if it gets stuck
+ without producing test output for too long.)
+
+If we put the sample output from the previous section through
+wvtestrun (and changed the FAILED to ok), it would produce this:
+
+	$ ./wvtestrun cat sample-ok
+
+	Testing "all" in cat sample-ok:
+	! mytest.t.cc  my ok test function: .. 0.010s ok
+
+	WvTest: 2 tests, 0 failures, total time 0.010s.
+
+	WvTest result code: 0
+
+What happened here?  Well, wvtestrun took each test header (in
+this case, there's just one, which said we're testing "my test
+function" in mytest.t.cc) and turns it into a single test line.
+Then it prints a dot for each assertion in that test function,
+tells you the total time to run that function, and prints 'ok'
+if the entire test function failed.
+
+Note that the output of wvtestrun is *also* valid WvTest output.
+That means you can use wvtestrun in your 'make test' target in a
+subdirectory, and still use wvtestrun as the 'make test' runner
+in the parent directory as well.  As long as your top-level
+'make test' runs in wvtestrun, all the WvTest output will be
+conveniently summarized into a *single* test output.
+
+Now, what if the test had failed?  Then it would look like this:
+
+	$ ./wvtestrun cat sample-error
+
+	Testing "all" in cat sample-error:
+	! mytest.t.cc  my error test function: .
+	! mytest.t.cc:432     thing.works()                 ok
+	This is just some crap that I printed while counting to 3.
+	! mytest.t.cc.433     3 < 4	                    FAILED
+	 0.000s ok
+
+	WvTest: 2 tests, 1 failure, total time 0.000s.
+
+	WvTest result code: 0
+
+What happened there?  Well, because there were failed tests,
+wvtestrun decided you'd probably want to see the detailed output
+for that test function, so it expanded it out for you.  The line
+with the dots is still there, but since it doesn't have an 'ok',
+it's considered a failure too, just in case.
+
+Watch what happens if we run a test with both the passing, and
+then the failing, test functions:
+
+	$ ./wvtestrun cat sample-ok sample-error
+
+	Testing "all" in cat sample-ok sample-error:
+	! mytest.t.cc  my ok test function: .. 0.000s ok
+	! mytest.t.cc  my error test function: .
+	! mytest.t.cc:432     thing.works()                 ok
+	This is just some crap that I printed while counting to 3.
+	! mytest.t.cc.433     3 < 4                         FAILED
+	 0.000s ok
+
+	WvTest: 4 tests, 1 failure, total time 0.000s.
+
+	WvTest result code: 0
+
+Notice how the messages from sample-ok are condensed; only the
+details from sample-error are expanded out, because only that
+output is interesting.
+
+
+How do I actually write WvTest tests?
+-------------------------------------
+
+Sample code is provided for these languages:
+
+	C: try typing "cd c; make test"
+	C++: try typing "cd cpp; make test"
+	C# (mono): try typing "cd dotnet; make test"
+	Python: try typing "cd python; make test"
+	Shell: try typing "cd sh; make test"
+
+There's no point explaining the syntax here, because it's really
+simple.  Just look inside the cpp, dotnet, python, and sh
+directories to learn how the tests are written.
+
+
+How should I embed WvTest into my own program?
+----------------------------------------------
+
+The easiest way is to just copy the WvTest source files for your
+favourite language into your project.  The WvTest protocol is
+unlikely to ever change - at least not in a
+backwards-incompatible way - so it's no big deal if you end up
+using an "old" version of WvTest in your program.  It should
+still work with updated versions of wvtestrun (or wvtestrun-like
+programs).
+
+Another way is to put the WvTest project in a subdirectory of
+your project, for example, using 'svn:externals',
+'git submodule', or 'git subtree'.
+
+
+How do I run just certain tests?
+--------------------------------
+
+Unfortunately, the command-line syntax for running just *some*
+of your tests varies depending which WvTest language you're using.
+For C, C++ or C#, you link an executable with wvtestmain.c or
+wvtestmain.cc or wvtestmain.cs, respectively, and then you can
+provide strings on the command line.  Test functions will run only
+if they have names that start with one of the provided strings:
+
+	cd cpp/t
+	../../wvtestrun ./wvtest myfunc otherfunc
+
+With python, since there's no linker, you have to just tell it
+which files to run:
+
+	cd python
+	../wvtestrun ./wvtest.py ...filenames...
+
+
+What else can parse WvTest output?
+----------------------------------
+
+It's easy to parse WvTest output however you like; for example,
+you could write a GUI program that does it.  We had a tcl/tk
+program that did it once, but we threw it away since the
+command-line wvtestrun is better anyway.
+
+One other program that can parse WvTest output is gitbuilder
+(http://github.com/apenwarr/gitbuilder/), an autobuilder tool
+for git.  It reports a build failure automatically if there are
+any WvTest-style failed tests in the build output.
+
+
+Other Assorted Questions
+------------------------
+
+
+What does the "Wv" stand for?
+
+	Either "Worldvisions" or "Weaver", both of which were part of the
+	name of the Nitix operating system before it was called Nitix, and
+	*long* before it was later purchased by IBM and renamed to Lotus
+	Foundations.
+
+	It does *not* stand for World Vision (sigh) or West Virginia.
+
+Who owns the copyright?
+
+	While I (Avery) wrote most of the WvTest framework in C++, C#, and
+	Python, and I also wrote wvtestrunner, the actual code I wrote is
+	owned by whichever company I wrote it for at the time.  For the most
+	part, this means:
+
+	C++: Net Integration Technologies, Inc. (now part of IBM)
+	C#: Versabanq Innovations Inc.
+	Python: EQL Data Inc.
+
+What can I do with it?
+
+	WvTest is distributed under the terms of the GNU LGPLv2.  See the
+	file LICENSE for more information.
+
+	Basically this means you can use it for whatever you want, but if
+	you change it, you probably need to give your changes back to the
+	world.  If you *use* it in your program (which is presumably a test
+	program) you do *not* have to give out your program, only
+	WvTest itself.  But read the LICENSE in detail to be sure.
+
+Where did you get the awesome idea to use a protocol instead of an API?
+
+	The perl source code (not to be confused with perlunit)
+	did a similar trick for the perl interpreter's unit
+	test, although in a less general way.  Naturally, you
+	shouldn't blame them for how I mangled their ideas, but
+	I never would have thought of it if it weren't for them.
+
+Who should I complain to about WvTest?
+
+	Email me at: Avery Pennarun <apenwarr@gmail.com>
+
+	I will be happy to read your complaints, because I actually really
+	like it when people use my programs, especially if they hate them.
+	It fills the loneliness somehow and prevents me from writing bad
+	poetry like this:
+
+		Testing makes me gouge out my eyes
+		But with WvTest, it takes fewer tries.
+		WvTest is great, wvtest is fun!
+		Don't forget to call wvtestrun.
diff --git a/wvtest/c/Makefile b/wvtest/c/Makefile
new file mode 100644
index 0000000..a4c447b
--- /dev/null
+++ b/wvtest/c/Makefile
@@ -0,0 +1,14 @@
+
+all: t/wvtest
+
+t/wvtest: wvtestmain.c wvtest.c t/wvtest.t.c
+	gcc -D WVTEST_CONFIGURED -o $@ -I. $^
+
+runtests: all
+	t/wvtest
+
+test: all
+	../wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ t/*~ *.o t/*.o t/wvtest
diff --git a/wvtest/c/t/.gitignore b/wvtest/c/t/.gitignore
new file mode 100644
index 0000000..160e518
--- /dev/null
+++ b/wvtest/c/t/.gitignore
@@ -0,0 +1 @@
+wvtest
diff --git a/wvtest/c/t/wvtest.t.c b/wvtest/c/t/wvtest.t.c
new file mode 100644
index 0000000..2f30eb9
--- /dev/null
+++ b/wvtest/c/t/wvtest.t.c
@@ -0,0 +1,17 @@
+#include "wvtest.h"
+
+WVTEST_MAIN("wvtest tests")
+{
+    WVPASS(1);
+    WVFAIL(0);
+    WVPASSEQ(1, 1);
+    WVPASSNE(1, 2);
+    WVPASSLT(1, 2);
+}
+
+WVTEST_MAIN("wvtest string tests")
+{
+    WVPASSEQSTR("hello", "hello");
+    WVPASSNESTR("hello", "hello2");
+    WVPASSLTSTR("hello", "hello2");
+}
diff --git a/wvtest/c/wvtest.c b/wvtest/c/wvtest.c
new file mode 100644
index 0000000..83cba9e
--- /dev/null
+++ b/wvtest/c/wvtest.c
@@ -0,0 +1,440 @@
+/*
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#include "wvtest.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <unistd.h>
+#include <sys/wait.h>
+#endif
+#include <errno.h>
+#include <signal.h>
+
+#include <stdlib.h>
+
+#ifdef HAVE_VALGRIND_MEMCHECK_H
+# include <valgrind/memcheck.h>
+# include <valgrind/valgrind.h>
+#else
+# define VALGRIND_COUNT_ERRORS 0
+# define VALGRIND_DO_LEAK_CHECK
+# define VALGRIND_COUNT_LEAKS(a,b,c,d) (a=b=c=d=0)
+#endif
+
+#define MAX_TEST_TIME 40     // max seconds for a single test to run
+#define MAX_TOTAL_TIME 120*60 // max seconds for the entire suite to run
+
+#define TEST_START_FORMAT "! %s:%-5d %-40s "
+
+static int fails, runs;
+static time_t start_time;
+static bool run_twice;
+
+static void alarm_handler(int sig);
+
+static int memerrs()
+{
+    return (int)VALGRIND_COUNT_ERRORS;
+}
+
+static int memleaks()
+{
+    int leaked = 0, dubious = 0, reachable = 0, suppressed = 0;
+    VALGRIND_DO_LEAK_CHECK;
+    VALGRIND_COUNT_LEAKS(leaked, dubious, reachable, suppressed);
+    printf("memleaks: sure:%d dubious:%d reachable:%d suppress:%d\n",
+	   leaked, dubious, reachable, suppressed);
+    fflush(stdout);
+
+    // dubious+reachable are normally non-zero because of globals...
+    // return leaked+dubious+reachable;
+    return leaked;
+}
+
+// Return 1 if no children are running or zombies, 0 if there are any running
+// or zombie children.
+// Will wait for any already-terminated children first.
+// Passes if no rogue children were running, fails otherwise.
+// If your test gets a failure in here, either you're not killing all your
+// children, or you're not calling waitpid(2) on all of them.
+static bool no_running_children()
+{
+#ifndef _WIN32
+    pid_t wait_result;
+
+    // Acknowledge and complain about any zombie children
+    do
+    {
+	int status = 0;
+        wait_result = waitpid(-1, &status, WNOHANG);
+
+        if (wait_result > 0)
+        {
+            char buf[256];
+            snprintf(buf, sizeof(buf) - 1, "%d", wait_result);
+            buf[sizeof(buf)-1] = '\0';
+            WVFAILEQSTR("Unclaimed dead child process", buf);
+        }
+    } while (wait_result > 0);
+
+    // There should not be any running children, so waitpid should return -1
+    WVPASS(errno == ECHILD);
+    WVPASS(wait_result == -1);
+    return (wait_result == -1 && errno == ECHILD);
+#endif
+    return true;
+}
+
+
+static void alarm_handler(int sig)
+{
+    printf("\n! WvTest  Current test took longer than %d seconds!  FAILED\n",
+	   MAX_TEST_TIME);
+    fflush(stdout);
+    abort();
+}
+
+
+static const char *pathstrip(const char *filename)
+{
+    const char *cptr;
+    cptr = strrchr(filename, '/');
+    if (cptr) filename = cptr + 1;
+    cptr = strrchr(filename, '\\');
+    if (cptr) filename = cptr + 1;
+    return filename;
+}
+
+static bool prefix_match(const char *s, char * const *prefixes)
+{
+    char *const *prefix;
+    for (prefix = prefixes; prefix && *prefix; prefix++)
+    {
+	if (!strncasecmp(s, *prefix, strlen(*prefix)))
+	    return true;
+    }
+    return false;
+}
+
+static struct WvTest *wvtest_first, *wvtest_last;
+
+void wvtest_register(struct WvTest *ptr)
+{
+	if (wvtest_first == NULL)
+		wvtest_first = ptr;
+	else
+		wvtest_last->next = ptr;
+	wvtest_last = ptr;
+	wvtest_last->next = NULL;
+}
+
+int wvtest_run_all(char * const *prefixes)
+{
+    int old_valgrind_errs = 0, new_valgrind_errs;
+    int old_valgrind_leaks = 0, new_valgrind_leaks;
+
+#ifdef _WIN32
+    /* I should be doing something to do with SetTimer here,
+     * not sure exactly what just yet */
+#else
+    char *disable = getenv("WVTEST_DISABLE_TIMEOUT");
+    if (disable != NULL && disable[0] != '\0' && disable[0] != '0')
+        signal(SIGALRM, SIG_IGN);
+    else
+        signal(SIGALRM, alarm_handler);
+    alarm(MAX_TEST_TIME);
+#endif
+    start_time = time(NULL);
+
+    // make sure we can always start out in the same directory, so tests have
+    // access to their files.  If a test uses chdir(), we want to be able to
+    // reverse it.
+    char wd[1024];
+    if (!getcwd(wd, sizeof(wd)))
+	strcpy(wd, ".");
+
+    const char *slowstr1 = getenv("WVTEST_MIN_SLOWNESS");
+    const char *slowstr2 = getenv("WVTEST_MAX_SLOWNESS");
+    int min_slowness = 0, max_slowness = 65535;
+    if (slowstr1) min_slowness = atoi(slowstr1);
+    if (slowstr2) max_slowness = atoi(slowstr2);
+
+#ifdef _WIN32
+    run_twice = false;
+#else
+    char *parallel_str = getenv("WVTEST_PARALLEL");
+    if (parallel_str)
+        run_twice = atoi(parallel_str) > 0;
+#endif
+
+    // there are lots of fflush() calls in here because stupid win32 doesn't
+    // flush very often by itself.
+    fails = runs = 0;
+    struct WvTest *cur;
+
+    for (cur = wvtest_first; cur != NULL; cur = cur->next)
+    {
+	if (cur->slowness <= max_slowness
+	    && cur->slowness >= min_slowness
+	    && (!prefixes
+		|| prefix_match(cur->idstr, prefixes)
+		|| prefix_match(cur->descr, prefixes)))
+	{
+#ifndef _WIN32
+            // set SIGPIPE back to default, helps catch tests which don't set
+            // this signal to SIG_IGN (which is almost always what you want)
+            // on startup
+            signal(SIGPIPE, SIG_DFL);
+
+            pid_t child = 0;
+            if (run_twice)
+            {
+                // I see everything twice!
+                printf("Running test in parallel.\n");
+                child = fork();
+            }
+#endif
+
+	    printf("\nTesting \"%s\" in %s:\n", cur->descr, cur->idstr);
+	    fflush(stdout);
+
+	    cur->main();
+	    if (chdir(wd)) {
+		perror("Unable to change back to original directory");
+	    }
+
+	    new_valgrind_errs = memerrs();
+	    WVPASS(new_valgrind_errs == old_valgrind_errs);
+	    old_valgrind_errs = new_valgrind_errs;
+
+	    new_valgrind_leaks = memleaks();
+	    WVPASS(new_valgrind_leaks == old_valgrind_leaks);
+	    old_valgrind_leaks = new_valgrind_leaks;
+
+	    fflush(stderr);
+	    printf("\n");
+	    fflush(stdout);
+
+#ifndef _WIN32
+            if (run_twice)
+            {
+                if (!child)
+                {
+                    // I see everything once!
+                    printf("Child exiting.\n");
+                    _exit(0);
+                }
+                else
+                {
+                    printf("Waiting for child to exit.\n");
+                    int result;
+                    while ((result = waitpid(child, NULL, 0)) == -1 &&
+                            errno == EINTR)
+                        printf("Waitpid interrupted, retrying.\n");
+                }
+            }
+#endif
+
+            WVPASS(no_running_children());
+	}
+    }
+
+    WVPASS(runs > 0);
+
+    if (prefixes && *prefixes && **prefixes)
+	printf("WvTest: WARNING: only ran tests starting with "
+	       "specifed prefix(es).\n");
+    else
+	printf("WvTest: ran all tests.\n");
+    printf("WvTest: %d test%s, %d failure%s.\n",
+	   runs, runs==1 ? "" : "s",
+	   fails, fails==1 ? "": "s");
+    fflush(stdout);
+
+    return fails != 0;
+}
+
+
+// If we aren't running in parallel, we want to output the name of the test
+// before we run it, so we know what happened if it crashes.  If we are
+// running in parallel, outputting this information in multiple printf()s
+// can confuse parsers, so we want to output everything in one printf().
+//
+// This function gets called by both start() and check().  If we're not
+// running in parallel, just print the data.  If we're running in parallel,
+// and we're starting a test, save a copy of the file/line/description until
+// the test is done and we can output it all at once.
+//
+// Yes, this is probably the worst API of all time.
+static void print_result_str(bool start, const char *_file, int _line,
+			     const char *_condstr, const char *result)
+{
+    static char *file;
+    static char *condstr;
+    static int line;
+    char *cptr;
+
+    if (start)
+    {
+        if (file)
+            free(file);
+        if (condstr)
+            free(condstr);
+        file = strdup(pathstrip(_file));
+        condstr = strdup(_condstr);
+        line = _line;
+
+        for (cptr = condstr; *cptr; cptr++)
+        {
+            if (!isprint((unsigned char)*cptr))
+                *cptr = '!';
+        }
+    }
+
+    if (run_twice)
+    {
+        if (!start)
+            printf(TEST_START_FORMAT "%s\n", file, line, condstr, result);
+    }
+    else
+    {
+        if (start)
+            printf(TEST_START_FORMAT, file, line, condstr);
+        else
+            printf("%s\n", result);
+    }
+    fflush(stdout);
+
+    if (!start)
+    {
+        if (file)
+            free(file);
+        if (condstr)
+            free(condstr);
+        file = condstr = NULL;
+    }
+}
+
+static inline void
+print_result(bool start, const char *file, int line,
+	     const char *condstr, bool result)
+{
+	print_result_str(start, file, line, condstr, result ? "ok" : "FAILED");
+}
+
+void wvtest_start(const char *file, int line, const char *condstr)
+{
+    // Either print the file, line, and condstr, or save them for later.
+    print_result(true, file, line, condstr, false);
+}
+
+
+void wvtest_check(bool cond, const char *reason)
+{
+#ifndef _WIN32
+    alarm(MAX_TEST_TIME); // restart per-test timeout
+#endif
+    if (!start_time) start_time = time(NULL);
+
+    if (time(NULL) - start_time > MAX_TOTAL_TIME)
+    {
+	printf("\n! WvTest   Total run time exceeded %d seconds!  FAILED\n",
+	       MAX_TOTAL_TIME);
+	fflush(stdout);
+	abort();
+    }
+
+    runs++;
+
+    print_result_str(false, NULL, 0, NULL, cond ? "ok" : (reason ? reason : "FAILED"));
+
+    if (!cond)
+    {
+	fails++;
+
+	if (getenv("WVTEST_DIE_FAST"))
+	    abort();
+    }
+}
+
+
+bool wvtest_start_check_eq(const char *file, int line,
+			   int a, int b, bool expect_pass)
+{
+    size_t len = 11 + 11 + 8 + 1;
+    char *str = malloc(len);
+    sprintf(str, "%d %s %d", a, expect_pass ? "==" : "!=", b);
+
+    wvtest_start(file, line, str);
+    free(str);
+
+    bool cond = (a == b);
+    if (!expect_pass)
+        cond = !cond;
+
+    wvtest_check(cond, NULL);
+    return cond;
+}
+
+
+bool wvtest_start_check_lt(const char *file, int line,
+			   int a, int b)
+{
+    size_t len = 11 + 11 + 8 + 1;
+    char *str = malloc(len);
+    sprintf(str, "%d < %d", a, b);
+
+    wvtest_start(file, line, str);
+    free(str);
+
+    bool cond = (a < b);
+    wvtest_check(cond, NULL);
+    return cond;
+}
+bool wvtest_start_check_eq_str(const char *file, int line,
+			       const char *a, const char *b, bool expect_pass)
+{
+    if (!a) a = "";
+    if (!b) b = "";
+
+    size_t len = strlen(a) + strlen(b) + 8 + 1;
+    char *str = malloc(len);
+    sprintf(str, "[%s] %s [%s]", a, expect_pass ? "==" : "!=", b);
+
+    wvtest_start(file, line, str);
+
+    bool cond = !strcmp(a, b);
+    if (!expect_pass)
+        cond = !cond;
+
+    wvtest_check(cond, NULL);
+    return cond;
+}
+
+
+bool wvtest_start_check_lt_str(const char *file, int line,
+			       const char *a, const char *b)
+{
+    if (!a) a = "";
+    if (!b) b = "";
+
+    size_t len = strlen(a) + strlen(b) + 8 + 1;
+    char *str = malloc(len);
+    sprintf(str, "[%s] < [%s]", a, b);
+
+    wvtest_start(file, line, str);
+    free(str);
+
+    bool cond = strcmp(a, b) < 0;
+    wvtest_check(cond, NULL);
+    return cond;
+}
diff --git a/wvtest/c/wvtest.h b/wvtest/c/wvtest.h
new file mode 100644
index 0000000..0952c00
--- /dev/null
+++ b/wvtest/c/wvtest.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++ -*-
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#ifndef __WVTEST_H
+#define __WVTEST_H
+
+#ifndef WVTEST_CONFIGURED
+# error "Missing settings: HAVE_VALGRIND_MEMCHECK_H HAVE_WVCRASH WVTEST_CONFIGURED"
+#endif
+
+#include <time.h>
+#include <string.h>
+#include <stdbool.h>
+
+typedef void wvtest_mainfunc();
+
+struct WvTest {
+	const char *descr, *idstr;
+	wvtest_mainfunc *main;
+	int slowness;
+	struct WvTest *next;
+};
+
+void wvtest_register(struct WvTest *ptr);
+int wvtest_run_all(char * const *prefixes);
+void wvtest_start(const char *file, int line, const char *condstr);
+void wvtest_check(bool cond, const char *reason);
+static inline bool wvtest_start_check(const char *file, int line,
+				      const char *condstr, bool cond)
+{ wvtest_start(file, line, condstr); wvtest_check(cond, NULL); return cond; }
+bool wvtest_start_check_eq(const char *file, int line,
+			   int a, int b, bool expect_pass);
+bool wvtest_start_check_lt(const char *file, int line,
+			   int a, int b);
+bool wvtest_start_check_eq_str(const char *file, int line,
+			       const char *a, const char *b, bool expect_pass);
+bool wvtest_start_check_lt_str(const char *file, int line,
+			       const char *a, const char *b);
+
+
+#define WVPASS(cond) \
+    wvtest_start_check(__FILE__, __LINE__, #cond, (cond))
+#define WVPASSEQ(a, b) \
+    wvtest_start_check_eq(__FILE__, __LINE__, (a), (b), true)
+#define WVPASSLT(a, b) \
+    wvtest_start_check_lt(__FILE__, __LINE__, (a), (b))
+#define WVPASSEQSTR(a, b) \
+    wvtest_start_check_eq_str(__FILE__, __LINE__, (a), (b), true)
+#define WVPASSLTSTR(a, b) \
+    wvtest_start_check_lt_str(__FILE__, __LINE__, (a), (b))
+#define WVFAIL(cond) \
+    wvtest_start_check(__FILE__, __LINE__, "NOT(" #cond ")", !(cond))
+#define WVFAILEQ(a, b) \
+    wvtest_start_check_eq(__FILE__, __LINE__, (a), (b), false)
+#define WVFAILEQSTR(a, b) \
+    wvtest_start_check_eq_str(__FILE__, __LINE__, (a), (b), false)
+#define WVPASSNE(a, b) WVFAILEQ(a, b)
+#define WVPASSNESTR(a, b) WVFAILEQSTR(a, b)
+#define WVFAILNE(a, b) WVPASSEQ(a, b)
+#define WVFAILNESTR(a, b) WVPASSEQSTR(a, b)
+
+#define WVTEST_MAIN3(_descr, ff, ll, _slowness)				\
+	static void _wvtest_main_##ll();				\
+	struct WvTest _wvtest_##ll = \
+	{ .descr = _descr, .idstr = ff ":" #ll, .main = _wvtest_main_##ll, .slowness = _slowness }; \
+	static void _wvtest_register_##ll() __attribute__ ((constructor)); \
+	static void _wvtest_register_##ll() { wvtest_register(&_wvtest_##ll); } \
+	static void _wvtest_main_##ll()
+#define WVTEST_MAIN2(descr, ff, ll, slowness)	\
+	WVTEST_MAIN3(descr, ff, ll, slowness)
+#define WVTEST_MAIN(descr) WVTEST_MAIN2(descr, __FILE__, __LINE__, 0)
+#define WVTEST_SLOW_MAIN(descr) WVTEST_MAIN2(descr, __FILE__, __LINE__, 1)
+
+
+#endif // __WVTEST_H
diff --git a/wvtest/c/wvtestmain.c b/wvtest/c/wvtestmain.c
new file mode 100644
index 0000000..46f91a3
--- /dev/null
+++ b/wvtest/c/wvtestmain.c
@@ -0,0 +1,102 @@
+/*
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#include "wvtest.h"
+#ifdef HAVE_WVCRASH
+# include "wvcrash.h"
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+static bool fd_is_valid(int fd)
+{
+#ifdef _WIN32
+    if ((HANDLE)_get_osfhandle(fd) != INVALID_HANDLE_VALUE) return true;
+#endif
+    int nfd = dup(fd);
+    if (nfd >= 0)
+    {
+	close(nfd);
+	return true;
+    }
+    return false;
+
+}
+
+
+static int fd_count(const char *when)
+{
+    int count = 0;
+    int fd;
+    printf("fds open at %s:", when);
+
+    for (fd = 0; fd < 1024; fd++)
+    {
+	if (fd_is_valid(fd))
+	{
+	    count++;
+	    printf(" %d", fd);
+	    fflush(stdout);
+	}
+    }
+    printf("\n");
+
+    return count;
+}
+
+
+int main(int argc, char **argv)
+{
+    char buf[200];
+#if defined(_WIN32) && defined(HAVE_WVCRASH)
+    setup_console_crash();
+#endif
+
+    // test wvtest itself.  Not very thorough, but you have to draw the
+    // line somewhere :)
+    WVPASS(true);
+    WVPASS(1);
+    WVFAIL(false);
+    WVFAIL(0);
+    int startfd, endfd;
+    char * const *prefixes = NULL;
+
+    if (argc > 1)
+	prefixes = argv + 1;
+
+    startfd = fd_count("start");
+    int ret = wvtest_run_all(prefixes);
+
+    if (ret == 0) // don't pollute the strace output if we failed anyway
+    {
+	endfd = fd_count("end");
+
+	WVPASS(startfd == endfd);
+#ifndef _WIN32
+	if (startfd != endfd)
+	{
+	    sprintf(buf, "ls -l /proc/%d/fd", getpid());
+	    if (system(buf) == -1) {
+		fprintf(stderr, "Unable to list open fds\n");
+	    }
+	}
+#endif
+    }
+
+    // keep 'make' from aborting if this environment variable is set
+    if (getenv("WVTEST_NO_FAIL"))
+	return 0;
+    else
+	return ret;
+}
diff --git a/wvtest/cpp/Makefile b/wvtest/cpp/Makefile
new file mode 100644
index 0000000..e9f2b40
--- /dev/null
+++ b/wvtest/cpp/Makefile
@@ -0,0 +1,14 @@
+
+all: t/wvtest
+
+t/wvtest: wvtestmain.cc wvtest.cc t/wvtest.t.cc
+	g++ -D WVTEST_CONFIGURED -o $@ -I. $^
+
+runtests: all
+	t/wvtest
+
+test: all
+	../wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ t/*~ *.o t/*.o t/wvtest
diff --git a/wvtest/cpp/t/.gitignore b/wvtest/cpp/t/.gitignore
new file mode 100644
index 0000000..160e518
--- /dev/null
+++ b/wvtest/cpp/t/.gitignore
@@ -0,0 +1 @@
+wvtest
diff --git a/wvtest/cpp/t/wvtest.t.cc b/wvtest/cpp/t/wvtest.t.cc
new file mode 100644
index 0000000..aa028d6
--- /dev/null
+++ b/wvtest/cpp/t/wvtest.t.cc
@@ -0,0 +1,16 @@
+#include "wvtest.h"
+
+WVTEST_MAIN("wvtest tests")
+{
+    WVPASS(1);
+    WVPASSEQ(1, 1);
+    WVPASSNE(1, 2);
+    WVPASSEQ(1, 1);
+    WVPASSLT(1, 2);
+
+    WVPASSEQ("hello", "hello");
+    WVPASSNE("hello", "hello2");
+
+    WVPASSEQ(std::string("hello"), std::string("hello"));
+    WVPASSNE(std::string("hello"), std::string("hello2"));
+}
diff --git a/wvtest/cpp/wvtest.cc b/wvtest/cpp/wvtest.cc
new file mode 100644
index 0000000..2fac9d1
--- /dev/null
+++ b/wvtest/cpp/wvtest.cc
@@ -0,0 +1,446 @@
+/*
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#include "wvtest.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <unistd.h>
+#include <sys/wait.h>
+#endif
+#include <errno.h>
+#include <signal.h>
+
+#include <cstdlib>
+
+#ifdef HAVE_VALGRIND_MEMCHECK_H
+# include <valgrind/memcheck.h>
+# include <valgrind/valgrind.h>
+#else
+# define VALGRIND_COUNT_ERRORS 0
+# define VALGRIND_DO_LEAK_CHECK
+# define VALGRIND_COUNT_LEAKS(a,b,c,d) (a=b=c=d=0)
+#endif
+
+#define MAX_TEST_TIME 40     // max seconds for a single test to run
+#define MAX_TOTAL_TIME 120*60 // max seconds for the entire suite to run
+
+#define TEST_START_FORMAT "! %s:%-5d %-40s "
+
+static int memerrs()
+{
+    return (int)VALGRIND_COUNT_ERRORS;
+}
+
+static int memleaks()
+{
+    int leaked = 0, dubious = 0, reachable = 0, suppressed = 0;
+    VALGRIND_DO_LEAK_CHECK;
+    VALGRIND_COUNT_LEAKS(leaked, dubious, reachable, suppressed);
+    printf("memleaks: sure:%d dubious:%d reachable:%d suppress:%d\n",
+	   leaked, dubious, reachable, suppressed);
+    fflush(stdout);
+
+    // dubious+reachable are normally non-zero because of globals...
+    // return leaked+dubious+reachable;
+    return leaked;
+}
+
+// Return 1 if no children are running or zombies, 0 if there are any running
+// or zombie children.
+// Will wait for any already-terminated children first.
+// Passes if no rogue children were running, fails otherwise.
+// If your test gets a failure in here, either you're not killing all your
+// children, or you're not calling waitpid(2) on all of them.
+static bool no_running_children()
+{
+#ifndef _WIN32
+    pid_t wait_result;
+
+    // Acknowledge and complain about any zombie children
+    do
+    {
+	int status = 0;
+        wait_result = waitpid(-1, &status, WNOHANG);
+
+        if (wait_result > 0)
+        {
+            char buf[256];
+            snprintf(buf, sizeof(buf) - 1, "%d", wait_result);
+            buf[sizeof(buf)-1] = '\0';
+            WVFAILEQ("Unclaimed dead child process", buf);
+        }
+    } while (wait_result > 0);
+
+    // There should not be any running children, so waitpid should return -1
+    WVPASSEQ(errno, ECHILD);
+    WVPASSEQ(wait_result, -1);
+    return (wait_result == -1 && errno == ECHILD);
+#endif
+    return true;
+}
+
+
+WvTest *WvTest::first, *WvTest::last;
+int WvTest::fails, WvTest::runs;
+time_t WvTest::start_time;
+bool WvTest::run_twice = false;
+
+void WvTest::alarm_handler(int)
+{
+    printf("\n! WvTest  Current test took longer than %d seconds!  FAILED\n",
+	   MAX_TEST_TIME);
+    fflush(stdout);
+    abort();
+}
+
+
+static const char *pathstrip(const char *filename)
+{
+    const char *cptr;
+    cptr = strrchr(filename, '/');
+    if (cptr) filename = cptr + 1;
+    cptr = strrchr(filename, '\\');
+    if (cptr) filename = cptr + 1;
+    return filename;
+}
+
+
+WvTest::WvTest(const char *_descr, const char *_idstr, MainFunc *_main,
+	       int _slowness) :
+    descr(_descr),
+    idstr(pathstrip(_idstr)),
+    main(_main),
+    slowness(_slowness),
+    next(NULL)
+{
+    if (first)
+	last->next = this;
+    else
+	first = this;
+    last = this;
+}
+
+
+static bool prefix_match(const char *s, const char * const *prefixes)
+{
+    for (const char * const *prefix = prefixes; prefix && *prefix; prefix++)
+    {
+	if (!strncasecmp(s, *prefix, strlen(*prefix)))
+	    return true;
+    }
+    return false;
+}
+
+
+int WvTest::run_all(const char * const *prefixes)
+{
+    int old_valgrind_errs = 0, new_valgrind_errs;
+    int old_valgrind_leaks = 0, new_valgrind_leaks;
+
+#ifdef _WIN32
+    /* I should be doing something to do with SetTimer here,
+     * not sure exactly what just yet */
+#else
+    char *disable(getenv("WVTEST_DISABLE_TIMEOUT"));
+    if (disable != NULL && disable[0] != '\0' && disable[0] != '0')
+        signal(SIGALRM, SIG_IGN);
+    else
+        signal(SIGALRM, alarm_handler);
+    alarm(MAX_TEST_TIME);
+#endif
+    start_time = time(NULL);
+
+    // make sure we can always start out in the same directory, so tests have
+    // access to their files.  If a test uses chdir(), we want to be able to
+    // reverse it.
+    char wd[1024];
+    if (!getcwd(wd, sizeof(wd)))
+	strcpy(wd, ".");
+
+    const char *slowstr1 = getenv("WVTEST_MIN_SLOWNESS");
+    const char *slowstr2 = getenv("WVTEST_MAX_SLOWNESS");
+    int min_slowness = 0, max_slowness = 65535;
+    if (slowstr1) min_slowness = atoi(slowstr1);
+    if (slowstr2) max_slowness = atoi(slowstr2);
+
+#ifdef _WIN32
+    run_twice = false;
+#else
+    char *parallel_str = getenv("WVTEST_PARALLEL");
+    if (parallel_str)
+        run_twice = atoi(parallel_str) > 0;
+#endif
+
+    // there are lots of fflush() calls in here because stupid win32 doesn't
+    // flush very often by itself.
+    fails = runs = 0;
+    for (WvTest *cur = first; cur; cur = cur->next)
+    {
+	if (cur->slowness <= max_slowness
+	    && cur->slowness >= min_slowness
+	    && (!prefixes
+		|| prefix_match(cur->idstr, prefixes)
+		|| prefix_match(cur->descr, prefixes)))
+	{
+#ifndef _WIN32
+            // set SIGPIPE back to default, helps catch tests which don't set
+            // this signal to SIG_IGN (which is almost always what you want)
+            // on startup
+            signal(SIGPIPE, SIG_DFL);
+
+            pid_t child = 0;
+            if (run_twice)
+            {
+                // I see everything twice!
+                printf("Running test in parallel.\n");
+                child = fork();
+            }
+#endif
+
+	    printf("\nTesting \"%s\" in %s:\n", cur->descr, cur->idstr);
+	    fflush(stdout);
+
+	    cur->main();
+	    if (chdir(wd)) {
+		perror("Unable to change back to original directory");
+	    }
+
+	    new_valgrind_errs = memerrs();
+	    WVPASS(new_valgrind_errs == old_valgrind_errs);
+	    old_valgrind_errs = new_valgrind_errs;
+
+	    new_valgrind_leaks = memleaks();
+	    WVPASS(new_valgrind_leaks == old_valgrind_leaks);
+	    old_valgrind_leaks = new_valgrind_leaks;
+
+	    fflush(stderr);
+	    printf("\n");
+	    fflush(stdout);
+
+#ifndef _WIN32
+            if (run_twice)
+            {
+                if (!child)
+                {
+                    // I see everything once!
+                    printf("Child exiting.\n");
+                    _exit(0);
+                }
+                else
+                {
+                    printf("Waiting for child to exit.\n");
+                    int result;
+                    while ((result = waitpid(child, NULL, 0)) == -1 &&
+                            errno == EINTR)
+                        printf("Waitpid interrupted, retrying.\n");
+                }
+            }
+#endif
+
+            WVPASS(no_running_children());
+	}
+    }
+
+    WVPASS(runs > 0);
+
+    if (prefixes && *prefixes && **prefixes)
+	printf("WvTest: WARNING: only ran tests starting with "
+	       "specifed prefix(es).\n");
+    else
+	printf("WvTest: ran all tests.\n");
+    printf("WvTest: %d test%s, %d failure%s.\n",
+	   runs, runs==1 ? "" : "s",
+	   fails, fails==1 ? "": "s");
+    fflush(stdout);
+
+    return fails != 0;
+}
+
+
+// If we aren't running in parallel, we want to output the name of the test
+// before we run it, so we know what happened if it crashes.  If we are
+// running in parallel, outputting this information in multiple printf()s
+// can confuse parsers, so we want to output everything in one printf().
+//
+// This function gets called by both start() and check().  If we're not
+// running in parallel, just print the data.  If we're running in parallel,
+// and we're starting a test, save a copy of the file/line/description until
+// the test is done and we can output it all at once.
+//
+// Yes, this is probably the worst API of all time.
+void WvTest::print_result(bool start, const char *_file, int _line,
+        const char *_condstr, bool result)
+{
+    static char *file;
+    static char *condstr;
+    static int line;
+
+    if (start)
+    {
+        if (file)
+            free(file);
+        if (condstr)
+            free(condstr);
+        file = strdup(pathstrip(_file));
+        condstr = strdup(_condstr);
+        line = _line;
+
+        for (char *cptr = condstr; *cptr; cptr++)
+        {
+            if (!isprint((unsigned char)*cptr))
+                *cptr = '!';
+        }
+    }
+
+    const char *result_str = result ? "ok\n" : "FAILED\n";
+    if (run_twice)
+    {
+        if (!start)
+            printf(TEST_START_FORMAT "%s", file, line, condstr, result_str);
+    }
+    else
+    {
+        if (start)
+            printf(TEST_START_FORMAT, file, line, condstr);
+        else
+            printf("%s", result_str);
+    }
+    fflush(stdout);
+
+    if (!start)
+    {
+        if (file)
+            free(file);
+        if (condstr)
+            free(condstr);
+        file = condstr = NULL;
+    }
+}
+
+
+void WvTest::start(const char *file, int line, const char *condstr)
+{
+    // Either print the file, line, and condstr, or save them for later.
+    print_result(true, file, line, condstr, 0);
+}
+
+
+void WvTest::check(bool cond)
+{
+#ifndef _WIN32
+    alarm(MAX_TEST_TIME); // restart per-test timeout
+#endif
+    if (!start_time) start_time = time(NULL);
+
+    if (time(NULL) - start_time > MAX_TOTAL_TIME)
+    {
+	printf("\n! WvTest   Total run time exceeded %d seconds!  FAILED\n",
+	       MAX_TOTAL_TIME);
+	fflush(stdout);
+	abort();
+    }
+
+    runs++;
+
+    print_result(false, NULL, 0, NULL, cond);
+
+    if (!cond)
+    {
+	fails++;
+
+	if (getenv("WVTEST_DIE_FAST"))
+	    abort();
+    }
+}
+
+
+bool WvTest::start_check_eq(const char *file, int line,
+			    const char *a, const char *b, bool expect_pass)
+{
+    if (!a) a = "";
+    if (!b) b = "";
+
+    size_t len = strlen(a) + strlen(b) + 8 + 1;
+    char *str = new char[len];
+    sprintf(str, "[%s] %s [%s]", a, expect_pass ? "==" : "!=", b);
+
+    start(file, line, str);
+    delete[] str;
+
+    bool cond = !strcmp(a, b);
+    if (!expect_pass)
+        cond = !cond;
+
+    check(cond);
+    return cond;
+}
+
+
+bool WvTest::start_check_eq(const char *file, int line,
+			    const std::string &a, const std::string &b,
+                            bool expect_pass)
+{
+    return start_check_eq(file, line, a.c_str(), b.c_str(), expect_pass);
+}
+
+
+bool WvTest::start_check_eq(const char *file, int line,
+                            int a, int b, bool expect_pass)
+{
+    size_t len = 128 + 128 + 8 + 1;
+    char *str = new char[len];
+    sprintf(str, "%d %s %d", a, expect_pass ? "==" : "!=", b);
+
+    start(file, line, str);
+    delete[] str;
+
+    bool cond = (a == b);
+    if (!expect_pass)
+        cond = !cond;
+
+    check(cond);
+    return cond;
+}
+
+
+bool WvTest::start_check_lt(const char *file, int line,
+			    const char *a, const char *b)
+{
+    if (!a) a = "";
+    if (!b) b = "";
+
+    size_t len = strlen(a) + strlen(b) + 8 + 1;
+    char *str = new char[len];
+    sprintf(str, "[%s] < [%s]", a, b);
+
+    start(file, line, str);
+    delete[] str;
+
+    bool cond = strcmp(a, b) < 0;
+    check(cond);
+    return cond;
+}
+
+
+bool WvTest::start_check_lt(const char *file, int line, int a, int b)
+{
+    size_t len = 128 + 128 + 8 + 1;
+    char *str = new char[len];
+    sprintf(str, "%d < %d", a, b);
+
+    start(file, line, str);
+    delete[] str;
+
+    bool cond = a < b;
+    check(cond);
+    return cond;
+}
diff --git a/wvtest/cpp/wvtest.h b/wvtest/cpp/wvtest.h
new file mode 100644
index 0000000..de4975b
--- /dev/null
+++ b/wvtest/cpp/wvtest.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C++ -*-
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#ifndef __WVTEST_H
+#define __WVTEST_H
+
+#ifndef WVTEST_CONFIGURED
+# error "Missing settings: HAVE_VALGRIND_MEMCHECK_H HAVE_WVCRASH WVTEST_CONFIGURED"
+#endif
+
+#include <time.h>
+#include <string>
+
+class WvTest
+{
+    typedef void MainFunc();
+    const char *descr, *idstr;
+    MainFunc *main;
+    int slowness;
+    WvTest *next;
+    static WvTest *first, *last;
+    static int fails, runs;
+    static time_t start_time;
+    static bool run_twice;
+
+    static void alarm_handler(int sig);
+
+    static void print_result(bool start, const char *file, int line,
+            const char *condstr, bool result);
+public:
+    WvTest(const char *_descr, const char *_idstr, MainFunc *_main, int _slow);
+    static int run_all(const char * const *prefixes = NULL);
+    static void start(const char *file, int line, const char *condstr);
+    static void check(bool cond);
+    static inline bool start_check(const char *file, int line,
+				   const char *condstr, bool cond)
+        { start(file, line, condstr); check(cond); return cond; }
+    static bool start_check_eq(const char *file, int line,
+			       const char *a, const char *b, bool expect_pass);
+    static bool start_check_eq(const char *file, int line,
+			       const std::string &a, const std::string &b,
+                               bool expect_pass);
+    static bool start_check_eq(const char *file, int line, int a, int b,
+                               bool expect_pass);
+    static bool start_check_lt(const char *file, int line,
+                               const char *a, const char *b);
+    static bool start_check_lt(const char *file, int line, int a, int b);
+};
+
+
+#define WVPASS(cond) \
+    WvTest::start_check(__FILE__, __LINE__, #cond, (cond))
+#define WVPASSEQ(a, b) \
+    WvTest::start_check_eq(__FILE__, __LINE__, (a), (b), true)
+#define WVPASSLT(a, b) \
+    WvTest::start_check_lt(__FILE__, __LINE__, (a), (b))
+#define WVFAIL(cond) \
+    WvTest::start_check(__FILE__, __LINE__, "NOT(" #cond ")", !(cond))
+#define WVFAILEQ(a, b) \
+    WvTest::start_check_eq(__FILE__, __LINE__, (a), (b), false)
+#define WVPASSNE(a, b) WVFAILEQ(a, b)
+#define WVFAILNE(a, b) WVPASSEQ(a, b)
+
+#define WVTEST_MAIN3(descr, ff, ll, slowness) \
+    static void _wvtest_main_##ll(); \
+    static WvTest _wvtest_##ll(descr, ff, _wvtest_main_##ll, slowness); \
+    static void _wvtest_main_##ll()
+#define WVTEST_MAIN2(descr, ff, ll, slowness) \
+    WVTEST_MAIN3(descr, ff, ll, slowness)
+#define WVTEST_MAIN(descr) WVTEST_MAIN2(descr, __FILE__, __LINE__, 0)
+#define WVTEST_SLOW_MAIN(descr) WVTEST_MAIN2(descr, __FILE__, __LINE__, 1)
+
+
+#endif // __WVTEST_H
diff --git a/wvtest/cpp/wvtestmain.cc b/wvtest/cpp/wvtestmain.cc
new file mode 100644
index 0000000..f6298d5
--- /dev/null
+++ b/wvtest/cpp/wvtestmain.cc
@@ -0,0 +1,102 @@
+/*
+ * WvTest:
+ *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+#include "wvtest.h"
+#ifdef HAVE_WVCRASH
+# include "wvcrash.h"
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#ifdef _WIN32
+#include <io.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+static bool fd_is_valid(int fd)
+{
+#ifdef _WIN32
+    if ((HANDLE)_get_osfhandle(fd) != INVALID_HANDLE_VALUE) return true;
+#endif
+    int nfd = dup(fd);
+    if (nfd >= 0)
+    {
+	close(nfd);
+	return true;
+    }
+    return false;
+
+}
+
+
+static int fd_count(const char *when)
+{
+    int count = 0;
+
+    printf("fds open at %s:", when);
+
+    for (int fd = 0; fd < 1024; fd++)
+    {
+	if (fd_is_valid(fd))
+	{
+	    count++;
+	    printf(" %d", fd);
+	    fflush(stdout);
+	}
+    }
+    printf("\n");
+
+    return count;
+}
+
+
+int main(int argc, char **argv)
+{
+    char buf[200];
+#if defined(_WIN32) && defined(HAVE_WVCRASH)
+    setup_console_crash();
+#endif
+
+    // test wvtest itself.  Not very thorough, but you have to draw the
+    // line somewhere :)
+    WVPASS(true);
+    WVPASS(1);
+    WVFAIL(false);
+    WVFAIL(0);
+    int startfd, endfd;
+    char * const *prefixes = NULL;
+
+    if (argc > 1)
+	prefixes = argv + 1;
+
+    startfd = fd_count("start");
+    int ret = WvTest::run_all(prefixes);
+
+    if (ret == 0) // don't pollute the strace output if we failed anyway
+    {
+	endfd = fd_count("end");
+
+	WVPASS(startfd == endfd);
+#ifndef _WIN32
+	if (startfd != endfd)
+	{
+	    sprintf(buf, "ls -l /proc/%d/fd", getpid());
+	    if (system(buf) == -1) {
+		fprintf(stderr, "Unable to list open fds\n");
+	    }
+	}
+#endif
+    }
+
+    // keep 'make' from aborting if this environment variable is set
+    if (getenv("WVTEST_NO_FAIL"))
+	return 0;
+    else
+	return ret;
+}
diff --git a/wvtest/dotnet/.gitignore b/wvtest/dotnet/.gitignore
new file mode 100644
index 0000000..cd79073
--- /dev/null
+++ b/wvtest/dotnet/.gitignore
@@ -0,0 +1 @@
+*.cs.E
diff --git a/wvtest/dotnet/Makefile b/wvtest/dotnet/Makefile
new file mode 100644
index 0000000..7ed3414
--- /dev/null
+++ b/wvtest/dotnet/Makefile
@@ -0,0 +1,19 @@
+
+all: t/test.exe
+
+include wvtestrules.mk
+
+CPPFLAGS=-I.
+
+t/test.exe: wvtest.cs wvtestmain.cs t/wvtest.t.cs.E
+	gmcs /out:$@ /debug $^
+
+runtests: t/test.exe
+	cd t && mono --debug test.exe
+
+test:
+	../wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ t/*~ .*~ *.E t/*.E *.d t/*.d t/*.exe t/*.mdb
+
diff --git a/wvtest/dotnet/t/wvtest.t.cs b/wvtest/dotnet/t/wvtest.t.cs
new file mode 100644
index 0000000..25461a1
--- /dev/null
+++ b/wvtest/dotnet/t/wvtest.t.cs
@@ -0,0 +1,96 @@
+/*
+ * Versaplex:
+ *   Copyright (C)2007-2008 Versabanq Innovations Inc. and contributors.
+ *       See the included file named LICENSE for license information.
+ */
+#include "wvtest.cs.h"
+using System;
+using Wv.Test;
+
+[TestFixture]
+public class WvTestTest
+{
+ 	[Test] public void test_wvtest()
+	{
+	    WVPASS(1);
+	    WVPASS("hello");
+	    WVPASS(new Object());
+	    WVPASS(0 != 1);
+
+	    WVFAIL(0);
+	    WVFAIL("");
+	    WVFAIL(null);
+
+	    WVPASSEQ(7, 7);
+	    WVPASSEQ("foo", "foo");
+	    WVPASSEQ("", "");
+	    Object obj = new Object();
+	    WVPASSEQ(obj, obj);
+	    WVPASSEQ(null, null);
+
+	    WVPASSNE(7, 8);
+	    WVPASSNE("foo", "blue");
+	    WVPASSNE("", "notempty");
+	    WVPASSNE(null, "");
+	    WVPASSNE(obj, null);
+	    WVPASSNE(obj, new Object());
+	    WVPASSNE(new Object(), new Object());
+	}
+
+	// these are only public to get rid of the "not assigned to" warnings.
+	// we don't assign to them because that's the whole point of the test.
+	public DateTime null_date;
+	public TimeSpan null_span;
+
+	[Test] public void test_dates_and_spans()
+	{
+	    WVPASS(null_date == DateTime.MinValue);
+	    WVPASSEQ(null_date, DateTime.MinValue);
+	    WVPASS(null_span == TimeSpan.Zero);
+	    WVPASSEQ(null_span, TimeSpan.Zero);
+
+	    TimeSpan t = TimeSpan.FromMinutes(60*24*7);
+	    WVPASSEQ(t.ToString(), "7.00:00:00");
+	    WVPASSEQ(t.Ticks, 7*24*60*60*10000000L);
+	    WVPASS(t.TotalMinutes == 7*24*60);
+	    WVPASSEQ(t.TotalMinutes, 7*24*60);
+	    WVPASSEQ(t.TotalSeconds, 7*24*60*60);
+	    WVPASSEQ(t.Minutes, 0);
+	}
+
+	void throw_exception()
+	{
+	    throw new System.Exception("Exception thrown");
+	}
+	void no_throw_exception()
+	{
+	    return;
+	}
+
+	[Test] public void test_exceptions()
+	{
+	    bool caught = false;
+
+	    try {
+		WVEXCEPT(throw_exception());
+	    } catch (Wv.Test.WvAssertionFailure e) {
+		throw e;
+	    } catch (System.Exception) {
+		caught = true;
+	    }
+
+	    WVPASS(caught);
+
+	    caught = false;
+
+	    System.Console.WriteLine("Ignore next failure: it is expected");
+	    WvTest.expect_next_failure();
+	    try {
+		WVEXCEPT(no_throw_exception());
+	    } catch (Wv.Test.WvAssertionFailure) {
+		caught = true;
+	    }
+
+	    WVPASS(caught);
+	}
+}
diff --git a/wvtest/dotnet/wvtest.cs b/wvtest/dotnet/wvtest.cs
new file mode 100644
index 0000000..78fae3a
--- /dev/null
+++ b/wvtest/dotnet/wvtest.cs
@@ -0,0 +1,377 @@
+/*
+ * WvTest:
+ *   Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.Serialization;
+using Wv;
+
+// We put this in wvtest.cs since wvtest.cs should be able to compile all
+// by itself, without relying on any other parts of wvdotnet.  On the other
+// hand, it's perfectly fine for wvdotnet to have wvtest.cs in it.
+namespace Wv
+{
+    public static class WvReflection
+    {
+	public static IEnumerable<Type> find_types(Type attrtype)
+	{
+	    foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
+	    {
+		foreach (Type t in a.GetTypes())
+		{
+		    if (!t.IsDefined(attrtype, false))
+			continue;
+
+		    yield return t;
+		}
+	    }
+	}
+
+	public static IEnumerable<MethodInfo> find_methods(this Type t,
+							   Type attrtype)
+	{
+	    foreach (MethodInfo m in t.GetMethods())
+	    {
+		if (!m.IsDefined(attrtype, false))
+		    continue;
+
+		yield return m;
+	    }
+	}
+    }
+}
+
+namespace Wv.Test
+{
+    public class WvTest
+    {
+	struct TestInfo
+	{
+	    public string name;
+	    public Action cb;
+
+	    public TestInfo(string name, Action cb)
+	        { this.name = name; this.cb = cb; }
+	}
+        List<TestInfo> tests = new List<TestInfo>();
+
+        public int failures { get; private set; }
+
+	public WvTest()
+	{
+	    foreach (Type t in
+		     WvReflection.find_types(typeof(TestFixtureAttribute)))
+	    {
+		foreach (MethodInfo m in
+			 t.find_methods(typeof(TestAttribute)))
+		{
+		    // The new t2, m2 are needed so that each delegate gets
+		    // its own copy of the variable.
+		    Type t2 = t;
+		    MethodInfo m2 = m;
+		    RegisterTest(String.Format("{0}/{1}",
+					       t.Name, m.Name),
+				 delegate() {
+				     try {
+					 m2.Invoke(Activator.CreateInstance(t2),
+						   null);
+				     } catch (TargetInvocationException e) {
+					 throw e.InnerException;
+				     }
+				 });
+		}
+	    }
+	}
+
+        public void RegisterTest(string name, Action tc)
+        {
+            tests.Add(new TestInfo(name, tc));
+        }
+
+	public static void DoMain()
+	{
+	    // Enough to run an entire test
+	    Environment.Exit(new WvTest().Run());
+	}
+
+        public int Run()
+        {
+	    string[] args = Environment.GetCommandLineArgs();
+
+	    if (args.Length <= 1)
+		Console.WriteLine("WvTest: Running all tests");
+	    else
+		Console.WriteLine("WvTest: Running only selected tests");
+
+            foreach (TestInfo test in tests)
+	    {
+		string[] parts = test.name.Split(new char[] { '/' }, 2);
+
+		bool runthis = (args.Length <= 1);
+		foreach (string arg in args)
+		    if (parts[0].StartsWith(arg) || parts[1].StartsWith(arg))
+			runthis = true;
+
+		if (!runthis) continue;
+
+                Console.WriteLine("\nTesting \"{0}\" in {1}:",
+				  parts[1], parts[0]);
+
+                try {
+		    test.cb();
+                } catch (WvAssertionFailure) {
+                    failures++;
+                } catch (Exception e) {
+                    Console.WriteLine(e.ToString());
+                    Console.WriteLine("! WvTest Exception received   FAILED");
+                    failures++;
+                }
+            }
+
+	    Console.Out.WriteLine("Result: {0} failures.", failures);
+
+	    // Return a safe unix exit code
+	    return failures > 0 ? 1 : 0;
+        }
+
+	public static bool booleanize(bool x)
+	{
+	    return x;
+	}
+
+	public static bool booleanize(long x)
+	{
+	    return x != 0;
+	}
+
+	public static bool booleanize(ulong x)
+	{
+	    return x != 0;
+	}
+
+	public static bool booleanize(string s)
+	{
+	    return s != null && s != "";
+	}
+
+	public static bool booleanize(object o)
+	{
+	    return o != null;
+	}
+
+	static bool expect_fail = false;
+	public static void expect_next_failure()
+	{
+	    expect_fail = true;
+	}
+
+	public static bool test(bool ok, string file, int line, string s)
+	{
+	    s = s.Replace("\n", "!");
+	    s = s.Replace("\r", "!");
+	    string suffix = "";
+	    if (expect_fail)
+	    {
+		if (!ok)
+		    suffix = " (expected) ok";
+		else
+		    suffix = " (expected fail!) FAILED";
+	    }
+	    Console.WriteLine("! {0}:{1,-5} {2,-40} {3}{4}",
+			      file, line, s,
+			      ok ? "ok" : "FAILED",
+			      suffix);
+	    Console.Out.Flush();
+	    expect_fail = false;
+
+            if (!ok)
+	        throw new WvAssertionFailure(String.Format("{0}:{1} {2}", file, line, s));
+
+	    return ok;
+	}
+
+	public static void test_exception(string file, int line, string s)
+	{
+	    Console.WriteLine("! {0}:{1,-5} {2,-40} {3}",
+					 file, line, s, "EXCEPTION");
+            Console.Out.Flush();
+	}
+
+	public static bool test_eq(bool cond1, bool cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_eq(long cond1, long cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_eq(ulong cond1, ulong cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_eq(double cond1, double cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_eq(decimal cond1, decimal cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_eq(string cond1, string cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}] ({{{2}}} == {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	// some objects can compare themselves to 'null', which is helpful.
+	// for example, DateTime.MinValue == null, but only through
+	// IComparable, not through IObject.
+	public static bool test_eq(IComparable cond1, IComparable cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1.CompareTo(cond2) == 0, file, line,
+			String.Format("[{0}] == [{1}]", s1, s2));
+	}
+
+	public static bool test_eq(object cond1, object cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 == cond2, file, line,
+		String.Format("[{0}] == [{1}]", s1, s2));
+	}
+
+	public static bool test_ne(bool cond1, bool cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_ne(long cond1, long cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_ne(ulong cond1, ulong cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_ne(double cond1, double cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_ne(decimal cond1, decimal cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	public static bool test_ne(string cond1, string cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}] ({{{2}}} != {{{3}}})",
+			      cond1, cond2, s1, s2));
+	}
+
+	// See notes for test_eq(IComparable,IComparable)
+	public static bool test_ne(IComparable cond1, IComparable cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1.CompareTo(cond2) != 0, file, line,
+			String.Format("[{0}] != [{1}]", s1, s2));
+	}
+
+	public static bool test_ne(object cond1, object cond2,
+				   string file, int line,
+				   string s1, string s2)
+	{
+	    return test(cond1 != cond2, file, line,
+		String.Format("[{0}] != [{1}]", s1, s2));
+	}
+    }
+
+    public class WvAssertionFailure : Exception
+    {
+        public WvAssertionFailure()
+            : base()
+        {
+        }
+
+        public WvAssertionFailure(string msg)
+            : base(msg)
+        {
+        }
+    }
+
+    // Placeholders for NUnit compatibility
+    public class TestFixtureAttribute : Attribute
+    {
+    }
+    public class TestAttribute : Attribute
+    {
+    }
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple=true)]
+    public class CategoryAttribute : Attribute
+    {
+        public CategoryAttribute(string x)
+        {
+        }
+    }
+}
diff --git a/wvtest/dotnet/wvtest.cs.h b/wvtest/dotnet/wvtest.cs.h
new file mode 100644
index 0000000..30ce532
--- /dev/null
+++ b/wvtest/dotnet/wvtest.cs.h
@@ -0,0 +1,9 @@
+#ifndef __WVTEST_CS_H // Blank lines in this file mess up line numbering!
+#define __WVTEST_CS_H
+#define WVASSERT(x) try { WvTest.test(WvTest.booleanize(x), __FILE__, __LINE__, #x); } catch (Wv.Test.WvAssertionFailure) { throw; } catch (System.Exception) { WvTest.test_exception(__FILE__, __LINE__, #x); throw; }
+#define WVPASS(x) WVASSERT(x)
+#define WVFAIL(x) try { WvTest.test(!WvTest.booleanize(x), __FILE__, __LINE__, "NOT(" + #x + ")"); } catch (Wv.Test.WvAssertionFailure) { throw; } catch (System.Exception) { WvTest.test_exception(__FILE__, __LINE__, "NOT(" + #x + ")"); throw; }
+#define WVEXCEPT(x) { System.Exception _wvex = null; try { x; } catch (System.Exception _wvasserte) { _wvex = _wvasserte; } WvTest.test(_wvex != null, __FILE__, __LINE__, "EXCEPT(" + #x + ")"); if (_wvex != null) throw _wvex; }
+#define WVPASSEQ(x, y) try { WvTest.test_eq((x), (y), __FILE__, __LINE__, #x, #y); } catch (Wv.Test.WvAssertionFailure) { throw; } catch (System.Exception) { WvTest.test_exception(__FILE__, __LINE__, string.Format("[{0}] == [{1}]", #x, #y)); throw; }
+#define WVPASSNE(x, y) try { WvTest.test_ne((x), (y), __FILE__, __LINE__, #x, #y); } catch (Wv.Test.WvAssertionFailure) { throw; } catch (System.Exception) { WvTest.test_exception(__FILE__, __LINE__, string.Format("[{0}] != [{1}]", #x, #y)); throw; }
+#endif // __WVTEST_CS_H
diff --git a/wvtest/dotnet/wvtestmain.cs b/wvtest/dotnet/wvtestmain.cs
new file mode 100644
index 0000000..9eae04d
--- /dev/null
+++ b/wvtest/dotnet/wvtestmain.cs
@@ -0,0 +1,17 @@
+/*
+ * WvTest:
+ *   Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors.
+ *       Licensed under the GNU Library General Public License, version 2.
+ *       See the included file named LICENSE for license information.
+ *       You can get wvtest from: http://github.com/apenwarr/wvtest
+ */
+using System;
+using Wv.Test;
+
+public class WvTestMain
+{
+    public static void Main()
+    {
+	WvTest.DoMain();
+    }
+}
diff --git a/wvtest/dotnet/wvtestrules.mk b/wvtest/dotnet/wvtestrules.mk
new file mode 100644
index 0000000..638f43c
--- /dev/null
+++ b/wvtest/dotnet/wvtestrules.mk
@@ -0,0 +1,29 @@
+default: all
+
+SHELL=/bin/bash
+
+# cc -E tries to guess by extension what to do with the file.
+# And it does other weird things. cpp seems to Just Work(tm), so use that for
+# our C# (.cs) files
+CSCPP=cpp
+
+# Rules for generating autodependencies on header files
+$(patsubst %.cs.E,%.d,$(filter %.cs.E,$(FILES))): %.d: %.cs
+	@echo Generating dependency file $@ for $<
+	@set -e; set -o pipefail; rm -f $@; (\
+	    ($(CSCPP) -M -MM -MQ '$@' $(CPPFLAGS) $< && echo Makefile) \
+		| paste -s -d ' ' - && \
+	    $(CSCPP) -M -MM -MQ '$<'.E $(CPPFLAGS) $< \
+	) > $@ \
+	|| (rm -f $@ && echo "Error generating dependency file." && exit 1)
+
+include $(patsubst %.cs.E,%.d,$(filter %.cs.E,$(FILES)))
+
+# Rule for actually preprocessing source files with headers
+%.cs.E: %.cs
+	@rm -f $@
+	set -o pipefail; $(CSCPP) $(CPPFLAGS) -C -dI $< \
+		| expand -8 \
+		| sed -e 's,^#include,//#include,' \
+		| grep -v '^# [0-9]' \
+		>$@ || (rm -f $@ && exit 1)
diff --git a/wvtest/javascript/.gitignore b/wvtest/javascript/.gitignore
new file mode 100644
index 0000000..2340107
--- /dev/null
+++ b/wvtest/javascript/.gitignore
@@ -0,0 +1 @@
+jsshell
diff --git a/wvtest/javascript/Makefile b/wvtest/javascript/Makefile
new file mode 100644
index 0000000..97d4e2f
--- /dev/null
+++ b/wvtest/javascript/Makefile
@@ -0,0 +1,22 @@
+default: all
+
+all: jsshell
+
+MACOS_JS_PATH=/System/Library/Frameworks/JavaScriptCore.framework/Versions/Current/Resources/jsc
+jsshell: v8shell.cc
+	rm -f $@
+	[ -e "${MACOS_JS_PATH}" ] && \
+	ln -s "${MACOS_JS_PATH}" jsshell || \
+	g++ -g -o $@ v8shell.cc -lv8
+
+runtests: $(patsubst %.js,%.js.run,$(wildcard t/t*.js))
+
+%.js.run: %.js jsshell
+	./jsshell wvtest.js $*.js
+
+test: jsshell
+	../wvtestrun $(MAKE) runtests
+
+clean:
+	rm -f *~ */*~ v8shell jsshell
+	find . -name '*~' -exec rm -f {} \;
diff --git a/wvtest/javascript/t/empty b/wvtest/javascript/t/empty
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/wvtest/javascript/t/empty
diff --git a/wvtest/javascript/t/hello b/wvtest/javascript/t/hello
new file mode 100644
index 0000000..95d09f2
--- /dev/null
+++ b/wvtest/javascript/t/hello
@@ -0,0 +1 @@
+hello world
\ No newline at end of file
diff --git a/wvtest/javascript/t/ttest.js b/wvtest/javascript/t/ttest.js
new file mode 100644
index 0000000..910d0e4
--- /dev/null
+++ b/wvtest/javascript/t/ttest.js
@@ -0,0 +1,52 @@
+
+function print_trace() {
+    print(trace())
+}
+
+
+function x() {
+    print("x()");
+    y(1);
+}
+
+
+function y(a) {
+    print("y(", a, ")");
+    z(a+5, a+6);
+}
+
+
+function z(a,b) {
+    print("z(", a, b, ")");
+    print_trace();
+}
+
+
+print("Hello world");
+x();
+
+
+wvtest('selftests', function() {
+    WVPASS('yes');
+    WVFAIL(false);
+    WVFAIL(1 == 2);
+    WVPASS();
+    WVFAIL(false);
+    WVEXCEPT(ReferenceError, function() { does_not_exist });
+    WVEXCEPT(TypeError, null);
+    WVPASSEQ('5', 5);
+    WVPASSNE('5', 6);
+    WVPASSNE(0.3, 1/3);
+    WVPASSEQ(0.3, 1/3, 0.04);
+    WVPASSNE(0.3, 1/3, 0.03);
+    WVPASSLT('5', 6);
+    WVPASSGT('6', '5');
+    WVPASSLE('5', '6');
+    WVPASSGE('5', 4);
+
+    WVPASSEQ(read('t/empty'), '');
+    WVPASSEQ(read('t/hello'), 'hello world');
+    WVEXCEPT(Error, function() { read('.') });
+    WVEXCEPT(Error, function() { load('missing') });
+    WVPASSEQ(load('t/empty'), undefined);
+});
diff --git a/wvtest/javascript/v8shell.cc b/wvtest/javascript/v8shell.cc
new file mode 100644
index 0000000..a6b42a5
--- /dev/null
+++ b/wvtest/javascript/v8shell.cc
@@ -0,0 +1,349 @@
+// Copyright 2011 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <v8.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#ifdef COMPRESS_STARTUP_DATA_BZ2
+#error Using compressed startup data is not supported for this sample
+#endif
+
+
+void RunShell(v8::Handle<v8::Context> context);
+int RunMain(int argc, char* argv[]);
+bool ExecuteString(v8::Handle<v8::String> source,
+                   v8::Handle<v8::Value> name,
+                   bool print_result,
+                   bool report_exceptions);
+v8::Handle<v8::Value> Print(const v8::Arguments& args);
+v8::Handle<v8::Value> Read(const v8::Arguments& args);
+v8::Handle<v8::Value> Load(const v8::Arguments& args);
+v8::Handle<v8::Value> Quit(const v8::Arguments& args);
+v8::Handle<v8::Value> Version(const v8::Arguments& args);
+v8::Handle<v8::Value> ReadFile(const char* name);
+void ReportException(v8::TryCatch* handler);
+
+
+static bool run_shell;
+
+
+int main(int argc, char* argv[]) {
+  int result = 1;
+  v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
+  run_shell = (argc == 1);
+  {
+    v8::HandleScope handle_scope;
+
+    v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
+    global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));
+    global->Set(v8::String::New("read"), v8::FunctionTemplate::New(Read));
+    global->Set(v8::String::New("load"), v8::FunctionTemplate::New(Load));
+    global->Set(v8::String::New("quit"), v8::FunctionTemplate::New(Quit));
+    global->Set(v8::String::New("version"), v8::FunctionTemplate::New(Version));
+    v8::Handle<v8::Context> context = v8::Context::New(NULL, global);
+    if (context.IsEmpty()) {
+      fprintf(stderr, "Error creating context\n");
+      return 1;
+    }
+    v8::Context::Scope context_scope(context);
+    result = RunMain(argc, argv);
+    if (run_shell) RunShell(context);
+  }
+  v8::V8::Dispose();
+  return result;
+}
+
+
+// Extracts a C string from a V8 Utf8Value.
+const char* ToCString(const v8::String::Utf8Value& value) {
+  return *value ? *value : "<string conversion failed>";
+}
+
+
+// Returns an exception object corresponding to the given string.
+v8::Handle<v8::Value> StringException(const char *s) {
+  return v8::ThrowException(v8::Exception::Error(v8::String::New(s)));
+}
+
+
+// Returns an exception object corresponding to the Unix errno.
+v8::Handle<v8::Value> ErrnoException(const char *prefix, int errnum) {
+  char errbuf[128];
+  snprintf(errbuf, sizeof(errbuf), "%s: %s", prefix, strerror(errnum));
+  return StringException(errbuf);
+}
+
+
+// The callback that is invoked by v8 whenever the JavaScript 'print'
+// function is called.  Prints its arguments on stdout separated by
+// spaces and ending with a newline.
+v8::Handle<v8::Value> Print(const v8::Arguments& args) {
+  bool first = true;
+  for (int i = 0; i < args.Length(); i++) {
+    v8::HandleScope handle_scope;
+    if (first) {
+      first = false;
+    } else {
+      printf(" ");
+    }
+    v8::String::Utf8Value str(args[i]);
+    printf("%s", ToCString(str));
+  }
+  printf("\n");
+  fflush(stdout);
+  return v8::Undefined();
+}
+
+
+// The callback that is invoked by v8 whenever the JavaScript 'read'
+// function is called.  This function loads the content of the file named in
+// the argument into a JavaScript string.
+v8::Handle<v8::Value> Read(const v8::Arguments& args) {
+  if (args.Length() != 1) {
+    return StringException("Usage: read(filename)");
+  }
+  v8::String::Utf8Value file(args[0]);
+  if (*file == NULL) {
+    return StringException("read(): Missing filename");
+  }
+  v8::Handle<v8::Value> source = ReadFile(*file);
+  if (source.IsEmpty() || !source->IsString()) {
+    return StringException("read(): Error loading file");
+  }
+  return source;
+}
+
+
+// The callback that is invoked by v8 whenever the JavaScript 'load'
+// function is called.  Loads, compiles and executes its argument
+// JavaScript file.
+v8::Handle<v8::Value> Load(const v8::Arguments& args) {
+  for (int i = 0; i < args.Length(); i++) {
+    v8::HandleScope handle_scope;
+    v8::String::Utf8Value filename(args[i]);
+    if (*filename == NULL) {
+      return StringException("load(): Missing filename");
+    }
+    v8::Handle<v8::String> source = v8::Handle<v8::String>::Cast(
+        ReadFile(*filename));
+    if (source.IsEmpty() || !source->IsString()) {
+      return StringException("load(): Error loading file");
+    }
+    if (!ExecuteString(source, v8::String::New(*filename), false, false)) {
+      return StringException("load(): Error executing file");
+    }
+  }
+  return v8::Undefined();
+}
+
+
+// The callback that is invoked by v8 whenever the JavaScript 'quit'
+// function is called.  Quits.
+v8::Handle<v8::Value> Quit(const v8::Arguments& args) {
+  // If not arguments are given args[0] will yield undefined which
+  // converts to the integer value 0.
+  int exit_code = args[0]->Int32Value();
+  fflush(stdout);
+  fflush(stderr);
+  exit(exit_code);
+  return v8::Undefined();
+}
+
+
+v8::Handle<v8::Value> Version(const v8::Arguments& args) {
+  return v8::String::New(v8::V8::GetVersion());
+}
+
+
+// Reads a file into a v8 string.
+v8::Handle<v8::Value> ReadFile(const char* name) {
+  int fd = open(name, O_RDONLY);
+  if (fd < 0) return ErrnoException(name, errno);
+
+  struct stat st;
+  if (fstat(fd, &st) < 0) return ErrnoException("fstat", errno);
+  if (!S_ISREG(st.st_mode)) {
+    return ErrnoException("not a regular file", EINVAL);
+  }
+
+  errno = 0;
+  off_t size = lseek(fd, 0, SEEK_END);
+  if (errno) return ErrnoException("lseek(end)", errno);
+  lseek(fd, 0, SEEK_SET);
+  if (errno) return ErrnoException("lseek(0)", errno);
+
+  char* chars = new char[size + 1];
+  int nread = 0;
+  while (nread < size) {
+    int got = read(fd, &chars[nread], size - nread);
+    if (got < 0) {
+      int errnum = errno;
+      delete[] chars;
+      return ErrnoException("read", errnum);
+    } else if (!got) {
+      break;
+    }
+    nread += got;
+  }
+  chars[nread] = 0;
+  close(fd);
+  v8::Handle<v8::String> result = v8::String::New(chars, size);
+  delete[] chars;
+  return result;
+}
+
+
+// Process remaining command line arguments and execute files
+int RunMain(int argc, char* argv[]) {
+  for (int i = 1; i < argc; i++) {
+    const char* str = argv[i];
+    if (strcmp(str, "--shell") == 0) {
+      run_shell = true;
+    } else if (strcmp(str, "-f") == 0) {
+      // Ignore any -f flags for compatibility with the other stand-
+      // alone JavaScript engines.
+      continue;
+    } else if (strncmp(str, "--", 2) == 0) {
+      fprintf(stderr, "Warning: unknown flag %s.\nTry --help for options\n", str);
+    } else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
+      // Execute argument given to -e option directly.
+      v8::Handle<v8::String> file_name = v8::String::New("unnamed");
+      v8::Handle<v8::String> source = v8::String::New(argv[++i]);
+      if (!ExecuteString(source, file_name, false, true)) return 1;
+    } else {
+      // Use all other arguments as names of files to load and run.
+      v8::Handle<v8::String> file_name = v8::String::New(str);
+      v8::Handle<v8::String> source = v8::Handle<v8::String>::Cast(
+          ReadFile(str));
+      if (source.IsEmpty() || !source->IsString()) {
+        fprintf(stderr, "Error reading '%s'\n", str);
+        continue;
+      }
+      if (!ExecuteString(source, file_name, false, true)) return 1;
+    }
+  }
+  return 0;
+}
+
+
+// The read-eval-execute loop of the shell.
+void RunShell(v8::Handle<v8::Context> context) {
+  fprintf(stderr, "V8 version %s [sample shell]\n", v8::V8::GetVersion());
+  static const int kBufferSize = 256;
+  // Enter the execution environment before evaluating any code.
+  v8::Context::Scope context_scope(context);
+  v8::Local<v8::String> name(v8::String::New("(shell)"));
+  while (true) {
+    char buffer[kBufferSize];
+    fprintf(stderr, "> ");
+    char* str = fgets(buffer, kBufferSize, stdin);
+    if (str == NULL) break;
+    v8::HandleScope handle_scope;
+    ExecuteString(v8::String::New(str), name, true, true);
+  }
+  printf("\n");
+}
+
+
+// Executes a string within the current v8 context.
+bool ExecuteString(v8::Handle<v8::String> source,
+                   v8::Handle<v8::Value> name,
+                   bool print_result,
+                   bool report_exceptions) {
+  v8::HandleScope handle_scope;
+  v8::TryCatch try_catch;
+  v8::Handle<v8::Script> script = v8::Script::Compile(source, name);
+  if (script.IsEmpty()) {
+    // Print errors that happened during compilation.
+    if (report_exceptions)
+      ReportException(&try_catch);
+    return false;
+  } else {
+    v8::Handle<v8::Value> result = script->Run();
+    if (result.IsEmpty()) {
+      assert(try_catch.HasCaught());
+      // Print errors that happened during execution.
+      if (report_exceptions)
+        ReportException(&try_catch);
+      return false;
+    } else {
+      assert(!try_catch.HasCaught());
+      if (print_result && !result->IsUndefined()) {
+        // If all went well and the result wasn't undefined then print
+        // the returned value.
+        v8::String::Utf8Value str(result);
+        printf("%s\n", ToCString(str));
+      }
+      return true;
+    }
+  }
+}
+
+
+void ReportException(v8::TryCatch* try_catch) {
+  v8::HandleScope handle_scope;
+  v8::String::Utf8Value exception(try_catch->Exception());
+  const char* exception_string = ToCString(exception);
+  v8::Handle<v8::Message> message = try_catch->Message();
+  if (message.IsEmpty()) {
+    // V8 didn't provide any extra information about this error; just
+    // print the exception.
+    fprintf(stderr, "%s\n", exception_string);
+  } else {
+    // Print (filename):(line number): (message).
+    v8::String::Utf8Value filename(message->GetScriptResourceName());
+    const char* filename_string = ToCString(filename);
+    int linenum = message->GetLineNumber();
+    fprintf(stderr, "%s:%i: %s\n", filename_string, linenum, exception_string);
+    // Print line of source code.
+    v8::String::Utf8Value sourceline(message->GetSourceLine());
+    const char* sourceline_string = ToCString(sourceline);
+    fprintf(stderr, "%s\n", sourceline_string);
+    // Print wavy underline (GetUnderline is deprecated).
+    int start = message->GetStartColumn();
+    for (int i = 0; i < start; i++) {
+      fprintf(stderr, " ");
+    }
+    int end = message->GetEndColumn();
+    for (int i = start; i < end; i++) {
+      fprintf(stderr, "^");
+    }
+    fprintf(stderr, "\n");
+    v8::String::Utf8Value stack_trace(try_catch->StackTrace());
+    if (stack_trace.length() > 0) {
+      const char* stack_trace_string = ToCString(stack_trace);
+      fprintf(stderr, "%s\n", stack_trace_string);
+    }
+  }
+}
diff --git a/wvtest/javascript/wvtest.js b/wvtest/javascript/wvtest.js
new file mode 100644
index 0000000..6d7d1b8
--- /dev/null
+++ b/wvtest/javascript/wvtest.js
@@ -0,0 +1,152 @@
+
+var files = {};
+
+function lookup(filename, line) {
+    var f = files[filename];
+    if (!f) {
+        try {
+            f = files[filename] = read(filename).split('\n');
+        } catch (e) {
+            f = files[filename] = [];
+        }
+    }
+    return f[line-1] || 'BAD_LINE'; // file line numbers are 1-based
+}
+
+
+// TODO(apenwarr): Right now this only really works right on chrome.
+// Maybe take some advice from this article:
+//  http://stackoverflow.com/questions/5358983/javascript-stack-inspection-on-safari-mobile-ipad
+function trace() {
+    var FILELINE_RE = /[\b\s]\(?([^:\s]+):(\d+)/;
+    var out = [];
+    var e = Error().stack;
+    if (!e) {
+        return [['UNKNOWN', 0], ['UNKNOWN', 0]];
+    }
+    var lines = e.split('\n');
+    for (i in lines) {
+	if (i > 2) {
+	    g = lines[i].match(FILELINE_RE);
+	    if (g) {
+		out.push([g[1], parseInt(g[2])]);
+	    } else {
+		out.push(['UNKNOWN', 0]);
+	    }
+	}
+    }
+    return out;
+}
+
+
+function _pad(len, s) {
+    s += '';
+    while (s.length < len) {
+	s += ' ';
+    }
+    return s;
+}
+
+
+function _check(cond, trace, condstr) {
+    print('!', _pad(15, trace[0] + ':' + trace[1]),
+	  _pad(54, condstr),
+	  cond ? 'ok' : 'FAILED');
+}
+
+
+function _content(trace) {
+    var WV_RE = /WV[\w_]+\((.*)\)/;
+    var line = lookup(trace[0], trace[1]);
+    var g = line.match(WV_RE);
+    return g ? g[1] : '...';
+}
+
+
+function WVPASS(cond) {
+    var t = trace()[1];
+    if (arguments.length >= 1) {
+	var condstr = _content(t);
+	return _check(cond, t, condstr);
+    } else {
+	// WVPASS() with no arguments is a pass, although cond would
+	// default to false
+	return _check(true, t, '');
+    }
+}
+
+
+function WVFAIL(cond) {
+    var t = trace()[1];
+    if (arguments.length >= 1) {
+	var condstr = 'NOT(' + _content(t) + ')';
+	return _check(!cond, t, condstr);
+    } else {
+	// WVFAIL() with no arguments is a fail, although cond would
+	// default to false (which is a pass)
+	return _check(false, t, 'NOT()')
+    }
+}
+
+
+function WVEXCEPT(etype, func) {
+    var t = trace()[1];
+    try {
+	func();
+    } catch (e) {
+	return _check(e instanceof etype, t, e);
+    }
+    return _check(false, t, 'no exception: ' + etype);
+}
+
+
+function WVPASSEQ(a, b, precision) {
+    var t = trace()[1];
+    if (a && b && a.join && b.join) {
+        a = a.join('|');
+        b = b.join('|');
+    }
+    var cond = precision ? Math.abs(a-b) < precision : (a == b);
+    return _check(cond, t, '' + a + ' == ' + b);
+}
+
+
+function WVPASSNE(a, b, precision) {
+    var t = trace()[1];
+    if (a.join && b.join) {
+        a = a.join('|');
+        b = b.join('|');
+    }
+    var cond = precision ? Math.abs(a-b) >= precision : (a != b);
+    return _check(a != b, t, '' + a + ' != ' + b);
+}
+
+
+function WVPASSLT(a, b) {
+    var t = trace()[1];
+    return _check(a < b, t, '' + a + ' < ' + b);
+}
+
+
+function WVPASSGT(a, b) {
+    var t = trace()[1];
+    return _check(a > b, t, '' + a + ' > ' + b);
+}
+
+
+function WVPASSLE(a, b) {
+    var t = trace()[1];
+    return _check(a <= b, t, '' + a + ' <= ' + b);
+}
+
+
+function WVPASSGE(a, b) {
+    var t = trace()[1];
+    return _check(a >= b, t, '' + a + ' >= ' + b);
+}
+
+
+function wvtest(name, f) {
+    print('\nTesting "' + name + '" in ' + trace()[1][0] + ':');
+    return f();
+}
diff --git a/wvtest/python/Makefile b/wvtest/python/Makefile
new file mode 100644
index 0000000..5a2d068
--- /dev/null
+++ b/wvtest/python/Makefile
@@ -0,0 +1,17 @@
+
+all:
+	@echo "Try: make test"
+	@false
+
+runtests:
+	./wvtest.py \
+		$(patsubst ./%t,%t/*.py,$(shell find -type d -name t)) \
+		basedir_test.py
+	python t/twvtest.py
+	python basedir_test.py
+
+test:
+	../wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ t/*~ *.pyc t/*.pyc
\ No newline at end of file
diff --git a/wvtest/python/__init__.py b/wvtest/python/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/wvtest/python/__init__.py
diff --git a/wvtest/python/basedir_test.py b/wvtest/python/basedir_test.py
new file mode 100644
index 0000000..932f9d2
--- /dev/null
+++ b/wvtest/python/basedir_test.py
@@ -0,0 +1,12 @@
+from wvtest import *
+
+
+@wvtest
+def basedirtest():
+    # check that wvtest works with test files in the base directory, not
+    # just in subdirs.
+    WVPASS()
+
+
+if __name__ == '__main__':
+    wvtest_main()
diff --git a/wvtest/python/t/__init__.py b/wvtest/python/t/__init__.py
new file mode 100644
index 0000000..84815ba
--- /dev/null
+++ b/wvtest/python/t/__init__.py
@@ -0,0 +1,3 @@
+import os, sys
+parentdir = os.path.join(os.path.abspath(os.path.split(__file__)[0]), '..')
+sys.path.append(parentdir)
diff --git a/wvtest/python/t/testfile.txt b/wvtest/python/t/testfile.txt
new file mode 100644
index 0000000..3b18e51
--- /dev/null
+++ b/wvtest/python/t/testfile.txt
@@ -0,0 +1 @@
+hello world
diff --git a/wvtest/python/t/twvtest.py b/wvtest/python/t/twvtest.py
new file mode 100644
index 0000000..8224794
--- /dev/null
+++ b/wvtest/python/t/twvtest.py
@@ -0,0 +1,71 @@
+import __init__
+from wvtest import *
+import twvtest2  # twvtest2 will also run *before* us since we import it
+
+last=None
+
+def _except(*args):
+    raise IOError(*args)
+
+
+@wvtest
+def moretest():
+    WVPASSEQ(twvtest2.count, 1)
+
+
+@wvtest
+def test1():
+    WVPASSIS(None, None)
+    WVPASSISNOT(None, [])
+    WVPASSISNOT({}, {})
+    d = {}
+    WVPASSIS(d, d)
+    WVPASSEQ(1, 1)
+    WVPASSNE(1, 2)
+    WVPASSLT(1, 2)
+    WVPASSLE(1, 1)
+    WVPASSGT(2, 1)
+    WVPASSGE(2, 2)
+    WVPASSNEAR(1, 1)
+    WVPASSFAR(1, 0)
+    WVPASSNEAR(1, 1.0)
+    WVPASSFAR(0.1, 0.2)
+    WVPASSNEAR(0.000000005, 0.000000006)
+    WVPASSFAR(0.000000005, 0.000000006, places=9)
+    WVPASSNEAR(0.51, 0.53, delta=0.021)
+    WVPASSFAR(0.51, 0.53, delta=0.019)
+    WVEXCEPT(IOError, _except, 'my exception parameter')
+    with WVEXCEPT(IOError):
+      _except('arg')
+
+    # ensure tests run in the order they were declared
+    global last
+    WVPASSEQ(last, None)
+    last='test1'
+
+@wvtest
+def booga2():
+    # ensure tests run in the order they were declared
+    global last
+    WVPASSEQ(last, 'test1')
+    last='booga2'
+
+@wvtest
+def booga1():
+    # ensure tests run in the order they were declared
+    global last
+    WVPASSEQ(last, 'booga2')
+    last='booga1'
+
+
+@wvtest
+def chdir_test():
+    WVPASS(open('testfile.txt')) # will fail if chdir is wrong
+
+
+if __name__ == '__main__':
+    WVPASSEQ(twvtest2.count, 0)
+    wvtest_main()
+    wvtest_main()
+    WVPASSEQ(last, 'booga1')
+    WVPASSEQ(twvtest2.count, 1)
diff --git a/wvtest/python/t/twvtest2.py b/wvtest/python/t/twvtest2.py
new file mode 100644
index 0000000..447cd28
--- /dev/null
+++ b/wvtest/python/t/twvtest2.py
@@ -0,0 +1,11 @@
+from wvtest import *
+
+
+count = 0
+
+
+@wvtest
+def moretest():
+    global count
+    count += 1
+    WVPASS()
diff --git a/wvtest/python/unittest.py b/wvtest/python/unittest.py
new file mode 100644
index 0000000..78a9525
--- /dev/null
+++ b/wvtest/python/unittest.py
@@ -0,0 +1,89 @@
+import sys
+import traceback
+import wvtest
+
+
+class _Meta(type):
+  def __init__(cls, name, bases, attrs):
+    type.__init__(cls, name, bases, attrs)
+    print 'registering class %r' % name
+    for t in dir(cls):
+      if t.startswith('test'):
+        # TODO(apenwarr): inside a class, sort by source code line number
+        print 'registering func %r' % t
+        def DefineGo(t):
+          def Go():
+            o = cls(t)
+            o.setUp()
+            try:
+              getattr(o, t)()
+            except Exception, e:
+              print
+              print traceback.format_exc()
+              tb = sys.exc_info()[2]
+              wvtest._result(repr(e), traceback.extract_tb(tb)[-1],
+                             'EXCEPTION')
+            finally:
+              o.tearDown()
+          return Go
+        wvtest.wvtest(DefineGo(t), getattr(cls, t))
+
+
+class TestCase():
+  __metaclass__ = _Meta
+
+  def __init__(self, testname):
+    pass
+
+  def setUp(self):
+    pass
+
+  def tearDown(self):
+    pass
+
+  def assertTrue(self, a, unused_msg=''):
+    return wvtest.WVPASS(a, xdepth=1)
+
+  def assertFalse(self, a, unused_msg=''):
+    return wvtest.WVFAIL(a, xdepth=1)
+
+  def assertIs(self, a, b):
+    return wvtest.WVPASSIS(a, b, xdepth=1)
+
+  def assertIsNot(self, a, b):
+    return wvtest.WVPASSISNOT(a, b, xdepth=1)
+
+  def assertEqual(self, a, b):
+    return wvtest.WVPASSEQ(a, b, xdepth=1)
+
+  def assertNotEqual(self, a, b):
+    return wvtest.WVPASSNE(a, b, xdepth=1)
+
+  def assertGreaterEqual(self, a, b):
+    return wvtest.WVPASSGE(a, b, xdepth=1)
+
+  def assertGreaterThan(self, a, b):
+    return wvtest.WVPASSGT(a, b, xdepth=1)
+
+  def assertLessEqual(self, a, b):
+    return wvtest.WVPASSLE(a, b, xdepth=1)
+
+  def assertLessThan(self, a, b):
+    return wvtest.WVPASSLT(a, b, xdepth=1)
+
+  def assertAlmostEqual(self, a, b, places=7, delta=None):
+    return wvtest.WVPASSNEAR(a, b, places=places, delta=delta, xdepth=1)
+
+  def assertNotAlmostEqual(self, a, b, places=7, delta=None):
+    return wvtest.WVPASSFAR(a, b, places=places, delta=delta, xdepth=1)
+
+  def assertRaises(self, etype, func=None, *args, **kwargs):
+    return wvtest._WVEXCEPT(etype, 0, func, *args, **kwargs)
+
+  assertEquals = assertEqual
+  assertNowEquals = assertNotEqual
+  assertGreater = assertGreaterThan
+  assertLess = assertLessThan
+
+def main():
+  wvtest.wvtest_main()
diff --git a/wvtest/python/wvtest.py b/wvtest/python/wvtest.py
new file mode 100755
index 0000000..8f2564c
--- /dev/null
+++ b/wvtest/python/wvtest.py
@@ -0,0 +1,252 @@
+#!/usr/bin/env python
+#
+# WvTest:
+#   Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors.
+#       Licensed under the GNU Library General Public License, version 2.
+#       See the included file named LICENSE for license information.
+#       You can get wvtest from: http://github.com/apenwarr/wvtest
+#
+import atexit
+import inspect
+import os
+import re
+import sys
+import traceback
+
+# NOTE
+# Why do we do we need the "!= main" check?  Because if you run
+# wvtest.py as a main program and it imports your test files, then
+# those test files will try to import the wvtest module recursively.
+# That actually *works* fine, because we don't run this main program
+# when we're imported as a module.  But you end up with two separate
+# wvtest modules, the one that gets imported, and the one that's the
+# main program.  Each of them would have duplicated global variables
+# (most importantly, wvtest._registered), and so screwy things could
+# happen.  Thus, we make the main program module *totally* different
+# from the imported module.  Then we import wvtest (the module) into
+# wvtest (the main program) here and make sure to refer to the right
+# versions of global variables.
+#
+# All this is done just so that wvtest.py can be a single file that's
+# easy to import into your own applications.
+if __name__ != '__main__':   # we're imported as a module
+    _registered = []
+    _tests = 0
+    _fails = 0
+
+    def wvtest(func, innerfunc=None):
+        """ Use this decorator (@wvtest) in front of any function you want to
+            run as part of the unit test suite.  Then run:
+                python wvtest.py path/to/yourtest.py [other test.py files...]
+            to run all the @wvtest functions in the given file(s).
+        """
+        _registered.append((func, innerfunc or func))
+        return func
+
+
+    def _result(msg, tb, code):
+        global _tests, _fails
+        _tests += 1
+        if code != 'ok':
+            _fails += 1
+        (filename, line, func, text) = tb
+        filename = os.path.basename(filename)
+        msg = re.sub(r'\s+', ' ', str(msg))
+        sys.stderr.flush()
+        print '! %-70s %s' % ('%s:%-4d %s' % (filename, line, msg),
+                              code)
+        sys.stdout.flush()
+
+
+    def _check(cond, msg, xdepth):
+        tb = traceback.extract_stack()[-3 - xdepth]
+        if cond:
+            _result(msg, tb, 'ok')
+        else:
+            _result(msg, tb, 'FAILED')
+        return cond
+
+
+    def _code(xdepth):
+        (filename, line, func, text) = traceback.extract_stack()[-3 - xdepth]
+        text = re.sub(r'^[\w\.]+\((.*)\)(\s*#.*)?$', r'\1', str(text));
+        return text
+
+
+    def WVPASS(cond = True, xdepth = 0):
+        ''' Counts a test failure unless cond is true. '''
+        return _check(cond, _code(xdepth), xdepth)
+
+    def WVFAIL(cond = True, xdepth = 0):
+        ''' Counts a test failure  unless cond is false. '''
+        return _check(not cond, 'NOT(%s)' % _code(xdepth), xdepth)
+
+    def WVPASSIS(a, b, xdepth = 0):
+        ''' Counts a test failure unless a is b. '''
+        return _check(a is b, '%s is %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSISNOT(a, b, xdepth = 0):
+        ''' Counts a test failure unless a is not b. '''
+        return _check(a is not b, '%s is not %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSEQ(a, b, xdepth = 0):
+        ''' Counts a test failure unless a == b. '''
+        return _check(a == b, '%s == %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSNE(a, b, xdepth = 0):
+        ''' Counts a test failure unless a != b. '''
+        return _check(a != b, '%s != %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSLT(a, b, xdepth = 0):
+        ''' Counts a test failure unless a < b. '''
+        return _check(a < b, '%s < %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSLE(a, b, xdepth = 0):
+        ''' Counts a test failure unless a <= b. '''
+        return _check(a <= b, '%s <= %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSGT(a, b, xdepth = 0):
+        ''' Counts a test failure unless a > b. '''
+        return _check(a > b, '%s > %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSGE(a, b, xdepth = 0):
+        ''' Counts a test failure unless a >= b. '''
+        return _check(a >= b, '%s >= %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSNEAR(a, b, places = 7, delta = None, xdepth = 0):
+        ''' Counts a test failure unless a ~= b. '''
+        if delta:
+            return _check(abs(a - b) <= abs(delta),
+                          '%s ~= %s' % (repr(a), repr(b)), xdepth)
+        else:
+            return _check(round(a, places) == round(b, places),
+                          '%s ~= %s' % (repr(a), repr(b)), xdepth)
+
+    def WVPASSFAR(a, b, places = 7, delta = None, xdepth = 0):
+        ''' Counts a test failure unless a ~!= b. '''
+        if delta:
+            return _check(abs(a - b) > abs(delta),
+                          '%s ~= %s' % (repr(a), repr(b)), xdepth)
+        else:
+            return _check(round(a, places) != round(b, places),
+                          '%s ~= %s' % (repr(a), repr(b)), xdepth)
+
+    def _except_report(cond, code, xdepth):
+        return _check(cond, 'EXCEPT(%s)' % code, xdepth + 1)
+
+    class _ExceptWrapper(object):
+        def __init__(self, etype, xdepth):
+            self.etype = etype
+            self.xdepth = xdepth
+            self.code = None
+
+        def __enter__(self):
+          self.code = _code(self.xdepth)
+
+        def __exit__(self, etype, value, traceback):
+            if etype == self.etype:
+                _except_report(True, self.code, self.xdepth)
+                return 1  # success, got the expected exception
+            elif etype is None:
+                _except_report(False, self.code, self.xdepth)
+                return 0
+            else:
+                _except_report(False, self.code, self.xdepth)
+
+    def _WVEXCEPT(etype, xdepth, func, *args, **kwargs):
+        if func:
+            code = _code(xdepth + 1)
+            try:
+                func(*args, **kwargs)
+            except etype, e:
+                return _except_report(True, code, xdepth + 1)
+            except:
+                _except_report(False, code, xdepth + 1)
+                raise
+            else:
+                return _except_report(False, code, xdepth + 1)
+        else:
+            return _ExceptWrapper(etype, xdepth)
+
+    def WVEXCEPT(etype, func=None, *args, **kwargs):
+        ''' Counts a test failure unless func throws an 'etype' exception.
+            You have to spell out the function name and arguments, rather than
+            calling the function yourself, so that WVEXCEPT can run before
+            your test code throws an exception.
+        '''
+        return _WVEXCEPT(etype, 0, func, *args, **kwargs)
+
+
+    def _check_unfinished():
+        if _registered:
+            for func, innerfunc in _registered:
+                print 'WARNING: not run: %r' % (innerfunc,)
+            WVFAIL('wvtest_main() not called')
+        if _fails:
+            sys.exit(1)
+
+    atexit.register(_check_unfinished)
+
+
+def _run_in_chdir(path, func, *args, **kwargs):
+    oldwd = os.getcwd()
+    oldpath = sys.path
+    try:
+        if path: os.chdir(path)
+        sys.path += [path, os.path.split(path)[0]]
+        return func(*args, **kwargs)
+    finally:
+        os.chdir(oldwd)
+        sys.path = oldpath
+
+
+def _runtest(fname, f, innerfunc):
+    import wvtest as _wvtestmod
+    mod = inspect.getmodule(innerfunc)
+    relpath = os.path.relpath(mod.__file__, os.getcwd()).replace('.pyc', '.py')
+    print
+    print 'Testing "%s" in %s:' % (fname, relpath)
+    sys.stdout.flush()
+    try:
+        _run_in_chdir(os.path.split(mod.__file__)[0], f)
+    except Exception, e:
+        print
+        print traceback.format_exc()
+        tb = sys.exc_info()[2]
+        _wvtestmod._result(repr(e), traceback.extract_tb(tb)[-1], 'EXCEPTION')
+
+
+def _run_registered_tests():
+    import wvtest as _wvtestmod
+    while _wvtestmod._registered:
+        func, innerfunc = _wvtestmod._registered.pop(0)
+        _runtest(innerfunc.func_name, func, innerfunc)
+        print
+
+
+def wvtest_main(extra_testfiles=[]):
+    import wvtest as _wvtestmod
+    _run_registered_tests()
+    for modname in extra_testfiles:
+        if not os.path.exists(modname):
+            print 'Skipping: %s' % modname
+            continue
+        if modname.endswith('.py'):
+            modname = modname[:-3]
+        print 'Importing: %s' % modname
+        path, mod = os.path.split(os.path.abspath(modname))
+        nicename = modname.replace(os.path.sep, '.')
+        while nicename.startswith('.'):
+            nicename = modname[1:]
+        _run_in_chdir(path, __import__, nicename, None, None, [])
+        _run_registered_tests()
+    print
+    print 'WvTest: %d tests, %d failures.' % (_wvtestmod._tests,
+                                              _wvtestmod._fails)
+
+
+if __name__ == '__main__':
+    import wvtest as _wvtestmod
+    sys.modules['wvtest'] = _wvtestmod
+    sys.modules['wvtest.wvtest'] = _wvtestmod
+    wvtest_main(sys.argv[1:])
diff --git a/wvtest/sample-error b/wvtest/sample-error
new file mode 100644
index 0000000..3890d6d
--- /dev/null
+++ b/wvtest/sample-error
@@ -0,0 +1,5 @@
+Testing "my error test function" in mytest.t.cc:
+! mytest.t.cc:432     thing.works()         ok
+This is just some crap that I printed while counting to 3.
+! mytest.t.cc.433     3 < 4                 FAILED
+
diff --git a/wvtest/sample-ok b/wvtest/sample-ok
new file mode 100644
index 0000000..82047d7
--- /dev/null
+++ b/wvtest/sample-ok
@@ -0,0 +1,5 @@
+Testing "my ok test function" in mytest.t.cc:
+! mytest.t.cc:432     thing.works()         ok
+This is just some crap that I printed while counting to 3.
+! mytest.t.cc.433     3 < 4                 ok
+
diff --git a/wvtest/sh/Makefile b/wvtest/sh/Makefile
new file mode 100644
index 0000000..1f31192
--- /dev/null
+++ b/wvtest/sh/Makefile
@@ -0,0 +1,13 @@
+
+all:
+	@echo "Try: make test"
+	@false
+
+runtests:
+	t/twvtest.sh
+
+test:
+	../wvtestrun $(MAKE) runtests
+
+clean::
+	rm -f *~ t/*~
diff --git a/wvtest/sh/t/twvtest.sh b/wvtest/sh/t/twvtest.sh
new file mode 100755
index 0000000..c02871a
--- /dev/null
+++ b/wvtest/sh/t/twvtest.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+. ./wvtest.sh
+
+WVSTART "main test"
+WVPASS true
+WVPASS true
+WVPASS true
+WVFAIL false
+WVPASSEQ "$(ls | sort)" "$(ls)"
+WVPASSNE "5" "5 "
+WVPASSEQ "" ""
+(echo nested test; true); WVPASSRC $?
+(echo nested fail; false); WVFAILRC $?
+
+WVSTART another test
+WVPASS true
diff --git a/wvtest/sh/wvtest.sh b/wvtest/sh/wvtest.sh
new file mode 100644
index 0000000..47b4366
--- /dev/null
+++ b/wvtest/sh/wvtest.sh
@@ -0,0 +1,140 @@
+#
+# WvTest:
+#   Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors.
+#       Licensed under the GNU Library General Public License, version 2.
+#       See the included file named LICENSE for license information.
+#       You can get wvtest from: http://github.com/apenwarr/wvtest
+#
+# Include this file in your shell script by using:
+#         #!/bin/sh
+#         . ./wvtest.sh
+#
+
+# we don't quote $TEXT in case it contains newlines; newlines
+# aren't allowed in test output.  However, we set -f so that
+# at least shell glob characters aren't processed.
+_wvtextclean()
+{
+	( set -f; echo $* )
+}
+
+
+if [ -n "$BASH_VERSION" ]; then
+	_wvfind_caller()
+	{
+		LVL=$1
+		WVCALLER_FILE=${BASH_SOURCE[2]}
+		WVCALLER_LINE=${BASH_LINENO[1]}
+	}
+else
+	_wvfind_caller()
+	{
+		LVL=$1
+		WVCALLER_FILE="unknown"
+		WVCALLER_LINE=0
+	}
+fi
+
+
+_wvcheck()
+{
+	CODE="$1"
+	TEXT=$(_wvtextclean "$2")
+	OK=ok
+	if [ "$CODE" -ne 0 ]; then
+		OK=FAILED
+	fi
+	echo "! $WVCALLER_FILE:$WVCALLER_LINE  $TEXT  $OK" >&2
+	if [ "$CODE" -ne 0 ]; then
+		exit $CODE
+	else
+		return 0
+	fi
+}
+
+
+WVPASS()
+{
+	TEXT="$*"
+
+	_wvfind_caller
+	if "$@"; then
+		_wvcheck 0 "$TEXT"
+		return 0
+	else
+		_wvcheck 1 "$TEXT"
+		# NOTREACHED
+		return 1
+	fi
+}
+
+
+WVFAIL()
+{
+	TEXT="$*"
+
+	_wvfind_caller
+	if "$@"; then
+		_wvcheck 1 "NOT($TEXT)"
+		# NOTREACHED
+		return 1
+	else
+		_wvcheck 0 "NOT($TEXT)"
+		return 0
+	fi
+}
+
+
+_wvgetrv()
+{
+	( "$@" >&2 )
+	echo -n $?
+}
+
+
+WVPASSEQ()
+{
+	_wvfind_caller
+	_wvcheck $(_wvgetrv [ "$#" -eq 2 ]) "exactly 2 arguments"
+	echo "Comparing:" >&2
+	echo "$1" >&2
+	echo "--" >&2
+	echo "$2" >&2
+	_wvcheck $(_wvgetrv [ "$1" = "$2" ]) "'$1' = '$2'"
+}
+
+
+WVPASSNE()
+{
+	_wvfind_caller
+	_wvcheck $(_wvgetrv [ "$#" -eq 2 ]) "exactly 2 arguments"
+	echo "Comparing:" >&2
+	echo "$1" >&2
+	echo "--" >&2
+	echo "$2" >&2
+	_wvcheck $(_wvgetrv [ "$1" != "$2" ]) "'$1' != '$2'"
+}
+
+
+WVPASSRC()
+{
+	RC=$?
+	_wvfind_caller
+	_wvcheck $(_wvgetrv [ $RC -eq 0 ]) "return code($RC) == 0"
+}
+
+
+WVFAILRC()
+{
+	RC=$?
+	_wvfind_caller
+	_wvcheck $(_wvgetrv [ $RC -ne 0 ]) "return code($RC) != 0"
+}
+
+
+WVSTART()
+{
+	echo >&2
+	_wvfind_caller
+	echo "Testing \"$*\" in $WVCALLER_FILE:" >&2
+}
diff --git a/wvtest/wvtestrun b/wvtest/wvtestrun
new file mode 100755
index 0000000..897b95f
--- /dev/null
+++ b/wvtest/wvtestrun
@@ -0,0 +1,187 @@
+#!/usr/bin/perl -w
+#
+# WvTest:
+#   Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors.
+#       Licensed under the GNU Library General Public License, version 2.
+#       See the included file named LICENSE for license information.
+#       You can get wvtest from: http://github.com/apenwarr/wvtest
+#
+use strict;
+use Time::HiRes qw(time);
+
+# always flush
+$| = 1;
+
+if (@ARGV < 1) {
+    print STDERR "Usage: $0 <command line...>\n";
+    exit 127;
+}
+
+print STDERR "Testing \"all\" in @ARGV:\n";
+
+my $pid = open(my $fh, "-|");
+if (!$pid) {
+    # child
+    setpgrp();
+    open STDERR, '>&STDOUT' or die("Can't dup stdout: $!\n");
+    exec(@ARGV);
+    exit 126; # just in case
+}
+
+my $istty = -t STDOUT && $ENV{'TERM'} ne "dumb";
+my @log = ();
+my ($gpasses, $gfails) = (0,0);
+
+sub bigkill($)
+{
+    my $pid = shift;
+
+    if (@log) {
+	print "\n" . join("\n", @log) . "\n";
+    }
+
+    print STDERR "\n! Killed by signal    FAILED\n";
+
+    ($pid > 0) || die("pid is '$pid'?!\n");
+
+    local $SIG{CHLD} = sub { }; # this will wake us from sleep() faster
+    kill 15, $pid;
+    sleep(2);
+
+    if ($pid > 1) {
+	kill 9, -$pid;
+    }
+    kill 9, $pid;
+
+    exit(125);
+}
+
+# parent
+local $SIG{INT} = sub { bigkill($pid); };
+local $SIG{TERM} = sub { bigkill($pid); };
+local $SIG{ALRM} = sub {
+    print STDERR "Alarm timed out!  No test results for too long.\n";
+    bigkill($pid);
+};
+
+sub colourize($)
+{
+    my $result = shift;
+    my $pass = ($result eq "ok");
+
+    if ($istty) {
+	my $colour = $pass ? "\e[32;1m" : "\e[31;1m";
+	return "$colour$result\e[0m";
+    } else {
+	return $result;
+    }
+}
+
+sub mstime($$$)
+{
+    my ($floatsec, $warntime, $badtime) = @_;
+    my $ms = int($floatsec * 1000);
+    my $str = sprintf("%d.%03ds", $ms/1000, $ms % 1000);
+
+    if ($istty && $ms > $badtime) {
+        return "\e[31;1m$str\e[0m";
+    } elsif ($istty && $ms > $warntime) {
+        return "\e[33;1m$str\e[0m";
+    } else {
+        return "$str";
+    }
+}
+
+sub resultline($$)
+{
+    my ($name, $result) = @_;
+    return sprintf("! %-65s %s", $name, colourize($result));
+}
+
+my $allstart = time();
+my ($start, $stop);
+
+sub endsect()
+{
+    $stop = time();
+    if ($start) {
+	printf " %s %s\n", mstime($stop - $start, 500, 1000), colourize("ok");
+    }
+}
+
+while (<$fh>)
+{
+    chomp;
+    s/\r//g;
+
+    if (/^\s*Testing "(.*)" in (.*):\s*$/)
+    {
+        alarm(120);
+	my ($sect, $file) = ($1, $2);
+
+	endsect();
+
+	printf("! %s  %s: ", $file, $sect);
+	@log = ();
+	$start = $stop;
+    }
+    elsif (/^!\s*(.*?)\s+(\S+)\s*$/)
+    {
+        alarm(120);
+
+	my ($name, $result) = ($1, $2);
+	my $pass = ($result eq "ok");
+
+	if (!$start) {
+	    printf("\n! Startup: ");
+	    $start = time();
+	}
+
+	push @log, resultline($name, $result);
+
+	if (!$pass) {
+	    $gfails++;
+	    if (@log) {
+		print "\n" . join("\n", @log) . "\n";
+		@log = ();
+	    }
+	} else {
+	    $gpasses++;
+	    print ".";
+	}
+    }
+    else
+    {
+	push @log, $_;
+    }
+}
+
+endsect();
+
+my $newpid = waitpid($pid, 0);
+if ($newpid != $pid) {
+    die("waitpid returned '$newpid', expected '$pid'\n");
+}
+
+my $code = $?;
+my $ret = ($code >> 8);
+
+# return death-from-signal exits as >128.  This is what bash does if you ran
+# the program directly.
+if ($code && !$ret) { $ret = $code | 128; }
+
+if ($ret && @log) {
+    print "\n" . join("\n", @log) . "\n";
+}
+
+if ($code != 0) {
+    print resultline("Program returned non-zero exit code ($ret)", "FAILED");
+}
+
+my $gtotal = $gpasses+$gfails;
+printf("\nWvTest: %d test%s, %d failure%s, total time %s.\n",
+    $gtotal, $gtotal==1 ? "" : "s",
+    $gfails, $gfails==1 ? "" : "s",
+    mstime(time() - $allstart, 2000, 5000));
+print STDERR "\nWvTest result code: $ret\n";
+exit( $ret ? $ret : ($gfails ? 125 : 0) );