diff --git a/.gitignore b/.gitignore
index 8ad3368..265b1b2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 .*~
 *.pyc
 help.html
+v8shell
diff --git a/Makefile b/Makefile
index 5f318e3..b13a842 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,22 @@
 default: all
 
-all: help.html
+all: help.html v8shell
+
+v8shell: v8shell.cc
+	g++ -o $@ $< -lv8
+
+runtests: $(patsubst %.js,%.js.run,$(wildcard t/t*.js))
 
 %.html: %.md
 	markdown $< >$@.new
 	mv $@.new $@
+
+%.js.run: %.js
+	./v8shell wvtest.js $*.js
+
+test: v8shell
+	./wvtestrun $(MAKE) runtests
+
+clean:
+	rm -f *~ .*~ */*~ */.*~ v8shell
+	find -name '*~' -exec rm -f {} \;
diff --git a/t/ttest.js b/t/ttest.js
new file mode 100644
index 0000000..c79fe16
--- /dev/null
+++ b/t/ttest.js
@@ -0,0 +1,3 @@
+wvtest('example test', function() {
+    WVPASS('hello world');
+});
diff --git a/v8shell.cc b/v8shell.cc
new file mode 100644
index 0000000..b40eca2
--- /dev/null
+++ b/v8shell.cc
@@ -0,0 +1,337 @@
+// 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 <fcntl.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef COMPRESS_STARTUP_DATA_BZ2
+#error Using compressed startup data is not supported for this sample
+#endif
+
+/**
+ * This sample program shows how to implement a simple javascript shell
+ * based on V8.  This includes initializing V8 with command line options,
+ * creating global functions, compiling and executing strings.
+ *
+ * For a more sophisticated shell, consider using the debug shell D8.
+ */
+
+
+v8::Persistent<v8::Context> CreateShellContext();
+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::String> ReadFile(const char* name);
+void ReportException(v8::TryCatch* handler);
+
+
+static bool run_shell;
+
+
+int main(int argc, char* argv[]) {
+  v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
+  run_shell = (argc == 1);
+  v8::HandleScope handle_scope;
+  v8::Persistent<v8::Context> context = CreateShellContext();
+  if (context.IsEmpty()) {
+    printf("Error creating context\n");
+    return 1;
+  }
+  context->Enter();
+  int result = RunMain(argc, argv);
+  if (run_shell) RunShell(context);
+  context->Exit();
+  context.Dispose();
+  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>";
+}
+
+
+// Creates a new execution environment containing the built-in
+// functions.
+v8::Persistent<v8::Context> CreateShellContext() {
+  // Create a template for the global object.
+  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
+  // Bind the global 'print' function to the C++ Print callback.
+  global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));
+  // Bind the global 'read' function to the C++ Read callback.
+  global->Set(v8::String::New("read"), v8::FunctionTemplate::New(Read));
+  // Bind the global 'load' function to the C++ Load callback.
+  global->Set(v8::String::New("load"), v8::FunctionTemplate::New(Load));
+  // Bind the 'quit' function
+  global->Set(v8::String::New("quit"), v8::FunctionTemplate::New(Quit));
+  // Bind the 'version' function
+  global->Set(v8::String::New("version"), v8::FunctionTemplate::New(Version));
+
+  return v8::Context::New(NULL, global);
+}
+
+
+// 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]);
+    const char* cstr = ToCString(str);
+    printf("%s", cstr);
+  }
+  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 v8::ThrowException(v8::String::New("Bad parameters"));
+  }
+  v8::String::Utf8Value file(args[0]);
+  if (*file == NULL) {
+    return v8::ThrowException(v8::String::New("Error loading file"));
+  }
+  v8::Handle<v8::String> source = ReadFile(*file);
+  if (source.IsEmpty()) {
+    return v8::ThrowException(v8::String::New("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 file(args[i]);
+    if (*file == NULL) {
+      return v8::ThrowException(v8::String::New("Error loading file"));
+    }
+    v8::Handle<v8::String> source = ReadFile(*file);
+    if (source.IsEmpty()) {
+      return v8::ThrowException(v8::String::New("Error loading file"));
+    }
+    if (!ExecuteString(source, v8::String::New(*file), false, false)) {
+      return v8::ThrowException(v8::String::New("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::String> ReadFile(const char* name) {
+  FILE* file = fopen(name, "rb");
+  if (file == NULL) return v8::Handle<v8::String>();
+
+  fseek(file, 0, SEEK_END);
+  int size = ftell(file);
+  rewind(file);
+
+  char* chars = new char[size + 1];
+  chars[size] = '\0';
+  for (int i = 0; i < size;) {
+    int read = fread(&chars[i], 1, size - i, file);
+    i += read;
+  }
+  fclose(file);
+  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) {
+      printf("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 = ReadFile(str);
+      if (source.IsEmpty()) {
+        printf("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) {
+  printf("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];
+    printf("> ");
+    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);
+        const char* cstr = ToCString(str);
+        printf("%s\n", cstr);
+      }
+      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.
+    printf("%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();
+    printf("%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);
+    printf("%s\n", sourceline_string);
+    // Print wavy underline (GetUnderline is deprecated).
+    int start = message->GetStartColumn();
+    for (int i = 0; i < start; i++) {
+      printf(" ");
+    }
+    int end = message->GetEndColumn();
+    for (int i = start; i < end; i++) {
+      printf("^");
+    }
+    printf("\n");
+    v8::String::Utf8Value stack_trace(try_catch->StackTrace());
+    if (stack_trace.length() > 0) {
+      const char* stack_trace_string = ToCString(stack_trace);
+      printf("%s\n", stack_trace_string);
+    }
+  }
+}
diff --git a/wvtest.js b/wvtest.js
new file mode 100644
index 0000000..e7b1d92
--- /dev/null
+++ b/wvtest.js
@@ -0,0 +1,178 @@
+
+var files = {};
+
+function lookup(filename, line) {
+    var f = files[filename];
+    if (!f) {
+	f = files[filename] = read(filename).split('\n');
+    }
+    return f[line-1]; // file line numbers are 1-based
+}
+
+
+function trace() {
+    var FILELINE_RE = /[\b\s]\(?([^:\s]+):(\d+)/;
+    var out = [];
+    var e = Error().stack;
+    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];
+    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];
+    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();
+}
+
+
+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);
+});
diff --git a/wvtestrun b/wvtestrun
new file mode 100755
index 0000000..248a1c5
--- /dev/null
+++ b/wvtestrun
@@ -0,0 +1,186 @@
+#!/usr/bin/perl -w
+#
+# WvTest:
+#   Copyright (C)2007-2009 Versabanq Innovations Inc. and contributors.
+#       Licensed under the GNU Library General Public License, version 2.
+#       See the included file named LICENSE for license information.
+#
+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;
+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) );