Populate tree.

149 files changed, 2194 insertions, 0 deletions

diff --git a/src/test/bench/shootout/ackermann.rs b/src/test/bench/shootout/ackermann.rs
new file mode 100644
index 00000000..27b4c3c0
--- /dev/null
+++ b/src/test/bench/shootout/ackermann.rs
@@ -0,0 +1,25 @@
+// -*- rust -*-
+
+fn ack(int m, int n) -> int {
+  if (m == 0) {
+    ret n+1;
+  } else {
+    if (n == 0) {
+      ret ack(m-1, 1);
+    } else {
+      ret ack(m-1, ack(m, n-1));
+    }
+  }
+}
+
+fn main() {
+  check (ack(0,0) == 1);
+  check (ack(3,2) == 29);
+  check (ack(3,4) == 125);
+
+  // This takes a while; but a comparison may amuse: on win32 at least, the
+  // posted C version of the 'benchmark' running ack(4,1) overruns its stack
+  // segment and crashes. We just grow our stack (to 4mb) as we go.
+
+  // check (ack(4,1) == 65533);
+}
\ No newline at end of file
diff --git a/src/test/bench/shootout/binary-trees.rs b/src/test/bench/shootout/binary-trees.rs
new file mode 100644
index 00000000..bb3ab602
--- /dev/null
+++ b/src/test/bench/shootout/binary-trees.rs
@@ -0,0 +1,15 @@
+type tree = tag(nil(), node(@tree, @tree, int));
+
+fn item_check(&tree t) -> int {
+  alt (t) {
+    case (nil()) {
+      ret 0;
+    }
+    case (node(@tree left, @tree right, int item)) {
+      ret item + item_check(left) - item_check(right);
+    }
+  }
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/src/test/bench/shootout/fibo.rs b/src/test/bench/shootout/fibo.rs
new file mode 100644
index 00000000..9045f381
--- /dev/null
+++ b/src/test/bench/shootout/fibo.rs
@@ -0,0 +1,22 @@
+// -*- rust -*-
+
+fn fib(int n) -> int {
+  // Several of the posted 'benchmark' versions of this compute the
+  // wrong Fibonacci numbers, of course.
+  if (n == 0) {
+    ret 0;
+  } else {
+    if (n <= 2) {
+      ret 1;
+    } else {
+      ret fib(n-1) + fib(n-2);
+    }
+  }
+}
+
+fn main() {
+  check (fib(8) == 21);
+  check (fib(15) == 610);
+  log fib(8);
+  log fib(15);
+}
diff --git a/src/test/compile-fail/arg-count-mismatch.rs b/src/test/compile-fail/arg-count-mismatch.rs
new file mode 100644
index 00000000..18f4104e
--- /dev/null
+++ b/src/test/compile-fail/arg-count-mismatch.rs
@@ -0,0 +1,9 @@
+// error-pattern: mismatched types
+
+fn f(int x) {
+}
+
+fn main() {
+  let () i;
+  i = f();
+}
diff --git a/src/test/compile-fail/arg-type-mismatch.rs b/src/test/compile-fail/arg-type-mismatch.rs
new file mode 100644
index 00000000..3a61992a
--- /dev/null
+++ b/src/test/compile-fail/arg-type-mismatch.rs
@@ -0,0 +1,10 @@
+
+// error-pattern: mismatched types
+
+fn f(int x) {
+}
+
+fn main() {
+  let () i;
+  i = f(());
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/bad-env-capture.rs b/src/test/compile-fail/bad-env-capture.rs
new file mode 100644
index 00000000..013bb56e
--- /dev/null
+++ b/src/test/compile-fail/bad-env-capture.rs
@@ -0,0 +1,10 @@
+// error-pattern: attempted dynamic environment-capture
+fn foo() {
+  let int x;
+  fn bar() {
+    log x;
+  }
+}
+fn main() {
+  foo();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/bad-main.rs b/src/test/compile-fail/bad-main.rs
new file mode 100644
index 00000000..8e3fa503
--- /dev/null
+++ b/src/test/compile-fail/bad-main.rs
@@ -0,0 +1,4 @@
+// error-pattern: bad type signature
+
+fn main(int x) {
+}
diff --git a/src/test/compile-fail/bad-name.rs b/src/test/compile-fail/bad-name.rs
new file mode 100644
index 00000000..44a30219
--- /dev/null
+++ b/src/test/compile-fail/bad-name.rs
@@ -0,0 +1,6 @@
+
+// error-pattern: malformed name
+
+fn main() {
+  let x.y[int].z foo;
+}
diff --git a/src/test/compile-fail/bad-type-env-capture.rs b/src/test/compile-fail/bad-type-env-capture.rs
new file mode 100644
index 00000000..e18e63a7
--- /dev/null
+++ b/src/test/compile-fail/bad-type-env-capture.rs
@@ -0,0 +1,3 @@
+// error-pattern: attempted dynamic environment-capture
+fn foo[T]() { obj bar(T b) {} }
+fn main() {}
\ No newline at end of file
diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs
new file mode 100644
index 00000000..35c5736c
--- /dev/null
+++ b/src/test/compile-fail/bogus-tag.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+type color = tag(
+  rgb(int, int, int),
+  rgba(int, int, int, int)
+);
+
+fn main() -> () {
+  let color red = rgb(255, 0, 0);
+  alt (red) {
+    case (rgb(int r, int g, int b)) {
+      log "rgb";
+    }
+    case (hsl(int h, int s, int l)) {
+      log "hsl";
+    }
+  }
+}
+
diff --git a/src/test/compile-fail/comm-makes-io.rs b/src/test/compile-fail/comm-makes-io.rs
new file mode 100644
index 00000000..50f87d0c
--- /dev/null
+++ b/src/test/compile-fail/comm-makes-io.rs
@@ -0,0 +1,6 @@
+// error-pattern: calculated effect is 'io'
+
+fn main() {
+  let chan[int] c = chan();
+  c <| 10;
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/dead-code-be.rs b/src/test/compile-fail/dead-code-be.rs
new file mode 100644
index 00000000..060b466a
--- /dev/null
+++ b/src/test/compile-fail/dead-code-be.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn f(str caller) {
+  log caller;
+}
+
+fn main() {
+  be f("main");
+  log "Paul is dead";
+}
+
diff --git a/src/test/compile-fail/dead-code-ret.rs b/src/test/compile-fail/dead-code-ret.rs
new file mode 100644
index 00000000..7fbdcb0e
--- /dev/null
+++ b/src/test/compile-fail/dead-code-ret.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn f(str caller) {
+  log caller;
+}
+
+fn main() {
+  ret f("main");
+  log "Paul is dead";
+}
+
diff --git a/src/test/compile-fail/direct-obj-fn-call.rs b/src/test/compile-fail/direct-obj-fn-call.rs
new file mode 100644
index 00000000..e13db876
--- /dev/null
+++ b/src/test/compile-fail/direct-obj-fn-call.rs
@@ -0,0 +1,12 @@
+
+// error-pattern: mismatched types
+
+obj x() {
+  fn hello() {
+    log "hello";
+  }
+}
+
+fn main() {
+  x.hello();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs
new file mode 100644
index 00000000..7a00f221
--- /dev/null
+++ b/src/test/compile-fail/export.rs
@@ -0,0 +1,14 @@
+// error-pattern: unknown module item
+mod foo {
+  export x;
+  fn x(int y) {
+    log y;
+  }
+  fn z(int y) {
+    log y;
+  }
+}
+
+fn main() {
+  foo.z(10);
+}
diff --git a/src/test/compile-fail/fru-extra-field.rs b/src/test/compile-fail/fru-extra-field.rs
new file mode 100644
index 00000000..2762b54f
--- /dev/null
+++ b/src/test/compile-fail/fru-extra-field.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+type point = rec(int x, int y);
+
+fn main() {
+  let point origin = rec(x=0, y=0);
+
+  let point origin3d = rec(z=0 with origin);
+}
diff --git a/src/test/compile-fail/fru-typestate.rs b/src/test/compile-fail/fru-typestate.rs
new file mode 100644
index 00000000..c15683c8
--- /dev/null
+++ b/src/test/compile-fail/fru-typestate.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+type point = rec(int x, int y);
+
+fn main() {
+  let point origin;
+
+  let point right = rec(x=10 with origin);
+  origin = rec(x=0, y=0);
+}
diff --git a/src/test/compile-fail/impure-pred.rs b/src/test/compile-fail/impure-pred.rs
new file mode 100644
index 00000000..811d595a
--- /dev/null
+++ b/src/test/compile-fail/impure-pred.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+// error-pattern: impure function used in constraint
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+io fn lt(int a, int b) -> bool {
+  let port[int] p = port();
+  let chan[int] c = chan(p);
+  c <| 10;
+}
+
+fn main() {
+  let int a = 10;
+  let int b = 23;
+  check lt(a,b);
+  f(a,b);
+}
diff --git a/src/test/compile-fail/infinite-tag-type-recursion.rs b/src/test/compile-fail/infinite-tag-type-recursion.rs
new file mode 100644
index 00000000..19aea090
--- /dev/null
+++ b/src/test/compile-fail/infinite-tag-type-recursion.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+// error-pattern: Infinite type recursion
+
+type mlist = tag(cons(int,mlist), nil());
+
+fn main() {
+  auto a = cons(10, cons(11, nil()));
+}
diff --git a/src/test/compile-fail/infinite-vec-type-recursion.rs b/src/test/compile-fail/infinite-vec-type-recursion.rs
new file mode 100644
index 00000000..7c82700a
--- /dev/null
+++ b/src/test/compile-fail/infinite-vec-type-recursion.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+// error-pattern: Infinite type recursion
+
+type x = vec[x];
+
+fn main() {
+  let x b = vec();
+}
diff --git a/src/test/compile-fail/io-infects-caller.rs b/src/test/compile-fail/io-infects-caller.rs
new file mode 100644
index 00000000..2f5f003f
--- /dev/null
+++ b/src/test/compile-fail/io-infects-caller.rs
@@ -0,0 +1,10 @@
+// error-pattern: calculated effect is 'io'
+
+io fn foo() {
+  let chan[int] c = chan();
+  c <| 10;
+}
+
+fn main() {
+  foo();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/log-type-error.rs b/src/test/compile-fail/log-type-error.rs
new file mode 100644
index 00000000..c8a5df9c
--- /dev/null
+++ b/src/test/compile-fail/log-type-error.rs
@@ -0,0 +1,6 @@
+// error-pattern: mismatched types
+
+fn main() {
+  log main;
+}
+
diff --git a/src/test/compile-fail/native-makes-unsafe.rs b/src/test/compile-fail/native-makes-unsafe.rs
new file mode 100644
index 00000000..d6e77b0d
--- /dev/null
+++ b/src/test/compile-fail/native-makes-unsafe.rs
@@ -0,0 +1,9 @@
+// error-pattern: calculated effect is 'unsafe'
+
+native mod foo {
+  fn naughty();
+}
+
+fn main() {
+  foo.naughty();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/not-a-pred.rs b/src/test/compile-fail/not-a-pred.rs
new file mode 100644
index 00000000..4a899512
--- /dev/null
+++ b/src/test/compile-fail/not-a-pred.rs
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+// error-pattern: mismatched types
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+obj lt(int a, int b) {
+}
+
+fn main() {
+  let int a = 10;
+  let int b = 23;
+  check lt(a,b);
+  f(a,b);
+}
diff --git a/src/test/compile-fail/output-type-mismatch.rs b/src/test/compile-fail/output-type-mismatch.rs
new file mode 100644
index 00000000..c979f065
--- /dev/null
+++ b/src/test/compile-fail/output-type-mismatch.rs
@@ -0,0 +1,9 @@
+// error-pattern: mismatched types
+
+fn f() {
+}
+
+fn main() {
+  let int i;
+  i = f();
+}
diff --git a/src/test/compile-fail/pred-on-wrong-slots.rs b/src/test/compile-fail/pred-on-wrong-slots.rs
new file mode 100644
index 00000000..cf31b8bd
--- /dev/null
+++ b/src/test/compile-fail/pred-on-wrong-slots.rs
@@ -0,0 +1,20 @@
+// -*- rust -*-
+
+// error-pattern: Unsatisfied .* lt(a, c)
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+fn lt(int a, int b) -> bool {
+  ret a < b;
+}
+
+fn main() {
+  let int a = 10;
+  let int b = 23;
+  let int c = 77;
+  check lt(a,b);
+  check lt(b,c);
+  f(a,b);
+  f(a,c);
+}
diff --git a/src/test/compile-fail/rec-missing-fields.rs b/src/test/compile-fail/rec-missing-fields.rs
new file mode 100644
index 00000000..83736d5e
--- /dev/null
+++ b/src/test/compile-fail/rec-missing-fields.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+// Issue #51.
+
+type point = rec(int x, int y);
+
+fn main() {
+  let point p = rec(x=10);
+  log p.y;
+}
diff --git a/src/test/compile-fail/return-uninit.rs b/src/test/compile-fail/return-uninit.rs
new file mode 100644
index 00000000..37117169
--- /dev/null
+++ b/src/test/compile-fail/return-uninit.rs
@@ -0,0 +1,10 @@
+// error-pattern: precondition constraint
+
+fn f() -> int {
+   let int x;
+   ret x;
+}
+
+fn main() {
+   f();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/slot-as-pred.rs b/src/test/compile-fail/slot-as-pred.rs
new file mode 100644
index 00000000..1da8df84
--- /dev/null
+++ b/src/test/compile-fail/slot-as-pred.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+// error-pattern: mismatched types
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+fn main() {
+  let int lt;
+  let int a = 10;
+  let int b = 23;
+  check lt(a,b);
+  f(a,b);
+}
diff --git a/src/test/compile-fail/spawn-non-nil-fn.rs b/src/test/compile-fail/spawn-non-nil-fn.rs
new file mode 100644
index 00000000..4d869bba
--- /dev/null
+++ b/src/test/compile-fail/spawn-non-nil-fn.rs
@@ -0,0 +1,9 @@
+// error-pattern: mismatched types
+
+fn f(int x) -> int {
+  ret x;
+}
+
+fn main() {
+  spawn f(10);
+}
diff --git a/src/test/compile-fail/type-shadow.rs b/src/test/compile-fail/type-shadow.rs
new file mode 100644
index 00000000..8f8aff9a
--- /dev/null
+++ b/src/test/compile-fail/type-shadow.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+// error-pattern: mismatched types
+
+fn main() {
+  type X = int;
+  type Y = X;
+  if (true) {
+    type X = str;
+    let Y y = "hello";
+  }
+}
diff --git a/src/test/compile-fail/unnecessary-io.rs b/src/test/compile-fail/unnecessary-io.rs
new file mode 100644
index 00000000..45a93798
--- /dev/null
+++ b/src/test/compile-fail/unnecessary-io.rs
@@ -0,0 +1,4 @@
+// error-pattern: calculated effect is ''
+io fn main() {
+  log "hi";
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/unnecessary-unsafe.rs b/src/test/compile-fail/unnecessary-unsafe.rs
new file mode 100644
index 00000000..6705bf34
--- /dev/null
+++ b/src/test/compile-fail/unnecessary-unsafe.rs
@@ -0,0 +1,4 @@
+// error-pattern: calculated effect is ''
+unsafe fn main() {
+  log "hi";
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/unsafe-infects-caller.rs b/src/test/compile-fail/unsafe-infects-caller.rs
new file mode 100644
index 00000000..28daea6c
--- /dev/null
+++ b/src/test/compile-fail/unsafe-infects-caller.rs
@@ -0,0 +1,13 @@
+// error-pattern: calculated effect is 'unsafe'
+
+native mod foo {
+  fn naughty();
+}
+
+unsafe fn bar() {
+  foo.naughty();
+}
+
+fn main() {
+  bar();
+}
\ No newline at end of file
diff --git a/src/test/compile-fail/while-bypass.rs b/src/test/compile-fail/while-bypass.rs
new file mode 100644
index 00000000..1de89e90
--- /dev/null
+++ b/src/test/compile-fail/while-bypass.rs
@@ -0,0 +1,13 @@
+// error-pattern: precondition constraint
+
+fn f() -> int {
+  let int x;
+  while(true) {
+    x = 10;
+  }
+  ret x;
+}
+
+fn main() {
+  f();
+}
diff --git a/src/test/compile-fail/while-expr.rs b/src/test/compile-fail/while-expr.rs
new file mode 100644
index 00000000..9077c18f
--- /dev/null
+++ b/src/test/compile-fail/while-expr.rs
@@ -0,0 +1,7 @@
+// error-pattern: precondition constraint
+
+fn main() {
+  let bool x;
+  while(x) {
+  }
+}
diff --git a/src/test/compile-fail/while-type-error.rs b/src/test/compile-fail/while-type-error.rs
new file mode 100644
index 00000000..07d7867e
--- /dev/null
+++ b/src/test/compile-fail/while-type-error.rs
@@ -0,0 +1,7 @@
+// error-pattern: mismatched types
+
+fn main() {
+  while (main) {
+  }
+}
+
diff --git a/src/test/compile-fail/writing-through-read-alias.rs b/src/test/compile-fail/writing-through-read-alias.rs
new file mode 100644
index 00000000..b3d21521
--- /dev/null
+++ b/src/test/compile-fail/writing-through-read-alias.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+// error-pattern: writing to non-mutable slot
+
+type point = rec(int x, int y, int z);
+
+fn f(&point p) {
+  p.x = 13;
+}
+
+fn main() {
+  let point x = rec(x=10, y=11, z=12);
+  f(x);
+}
diff --git a/src/test/run-fail/explicit-fail.rs b/src/test/run-fail/explicit-fail.rs
new file mode 100644
index 00000000..cb0e37e5
--- /dev/null
+++ b/src/test/run-fail/explicit-fail.rs
@@ -0,0 +1,5 @@
+// error-pattern:explicit
+
+fn main() {
+  fail;
+}
diff --git a/src/test/run-fail/fail.rs b/src/test/run-fail/fail.rs
new file mode 100644
index 00000000..8808b8c8
--- /dev/null
+++ b/src/test/run-fail/fail.rs
@@ -0,0 +1,5 @@
+// error-pattern:1 == 2
+
+fn main() {
+   check (1 == 2);
+}
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
new file mode 100644
index 00000000..419fa0f3
--- /dev/null
+++ b/src/test/run-fail/linked-failure.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+// error-pattern:1 == 2
+
+fn child() {
+  check (1 == 2);
+}
+
+io fn main() {
+  let port[int] p = port();
+  spawn child();
+  let int x;
+  x <- p;
+}
diff --git a/src/test/run-fail/pred.rs b/src/test/run-fail/pred.rs
new file mode 100644
index 00000000..e5456a5e
--- /dev/null
+++ b/src/test/run-fail/pred.rs
@@ -0,0 +1,17 @@
+// -*- rust -*-
+
+// error-pattern:predicate check
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+fn lt(int a, int b) -> bool {
+  ret a < b;
+}
+
+fn main() {
+  let int a = 10;
+  let int b = 23;
+  check lt(b,a);
+  f(b,a);
+}
diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs
new file mode 100644
index 00000000..7d5a12cb
--- /dev/null
+++ b/src/test/run-fail/str-overrun.rs
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+// error-pattern:bounds check
+
+fn main() {
+  let str s = "hello";
+  let int x = 0;
+  check (s.(x) == u8(0x68));
+
+  // NB: at the moment a string always has a trailing NULL,
+  // so the largest index value on the string above is 5, not
+  // 4. Possibly change this.
+
+  // Bounds-check failure.
+  check (s.(x + 6) == u8(0x0));
+}
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
new file mode 100644
index 00000000..e646a107
--- /dev/null
+++ b/src/test/run-fail/vec-overrun.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+// error-pattern:bounds check
+
+fn main() {
+  let vec[int] v = vec(10);
+  let int x = 0;
+  check (v.(x) == 10);
+  // Bounds-check failure.
+  check (v.(x + 2) == 20);
+}
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
new file mode 100644
index 00000000..c9073030
--- /dev/null
+++ b/src/test/run-fail/vec-underrun.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+// error-pattern:bounds check
+
+fn main() {
+  let vec[int] v = vec(10, 20);
+  let int x = 0;
+  check (v.(x) == 10);
+  // Bounds-check failure.
+  check (v.(x-1) == 20);
+}
diff --git a/src/test/run-pass/acyclic-unwind.rs b/src/test/run-pass/acyclic-unwind.rs
new file mode 100644
index 00000000..b549cffe
--- /dev/null
+++ b/src/test/run-pass/acyclic-unwind.rs
@@ -0,0 +1,30 @@
+// -*- rust -*-
+
+io fn f(chan[int] c)
+{
+  type t = tup(int,int,int);
+
+  // Allocate an exterior.
+  let @t x = tup(1,2,3);
+
+  // Signal parent that we've allocated an exterior.
+  c <| 1;
+
+  while (true) {
+    // spin waiting for the parent to kill us.
+    log "child waiting to die...";
+    c <| 1;
+  }
+}
+
+
+io fn main() {
+  let port[int] p = port();
+  spawn f(chan(p));
+  let int i;
+
+  // synchronize on event from child.
+  i <- p;
+
+  log "parent exiting, killing child";
+}
diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs
new file mode 100644
index 00000000..d40c4eec
--- /dev/null
+++ b/src/test/run-pass/alt-tag.rs
@@ -0,0 +1,39 @@
+// -*- rust -*-
+
+type color = tag(
+  rgb(int, int, int),
+  rgba(int, int, int, int),
+  hsl(int, int, int)
+);
+
+fn process(color c) -> int {
+  let int x;
+  alt (c) {
+    case (rgb(r, _, _)) {
+      log "rgb";
+      log r;
+      x = r;
+    }
+    case (rgba(_, _, _, a)) {
+      log "rgba";
+      log a;
+      x = a;
+    }
+    case (hsl(_, s, _)) {
+      log "hsl";
+      log s;
+      x = s;
+    }
+  }
+  ret x;
+}
+
+fn main() {
+  let color gray = rgb(127, 127, 127);
+  let color clear = rgba(50, 150, 250, 0);
+  let color red = hsl(0, 255, 255);
+  check (process(gray) == 127);
+  check (process(clear) == 0);
+  check (process(red) == 255);
+}
+
diff --git a/src/test/run-pass/argv.rs b/src/test/run-pass/argv.rs
new file mode 100644
index 00000000..92d5fcc6
--- /dev/null
+++ b/src/test/run-pass/argv.rs
@@ -0,0 +1,9 @@
+fn main(vec[str] args) {
+  let vec[str] vs = vec("hi", "there", "this", "is", "a", "vec");
+  let vec[vec[str]] vvs = vec(args, vs);
+  for (vec[str] vs in vvs) {
+    for (str s in vs) {
+      log s;
+    }
+  }
+}
diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
new file mode 100644
index 00000000..95e4bff8
--- /dev/null
+++ b/src/test/run-pass/basic.rs
@@ -0,0 +1,50 @@
+// -*- rust -*-
+
+io fn a(chan[int] c) {
+  if (true) {
+    log "task a";
+    log "task a";
+    log "task a";
+    log "task a";
+    log "task a";
+  }
+  c <| 10;
+}
+
+fn k(int x) -> int {
+  ret 15;
+}
+
+fn g(int x, str y) -> int {
+  log x;
+  log y;
+  let int z = k(1);
+  ret z;
+}
+
+io fn main() {
+    let int n = 2 + 3 * 7;
+    let str s = "hello there";
+    let port[int] p = port();
+    spawn a(chan(p));
+    spawn b(chan(p));
+    let int x = 10;
+    x = g(n,s);
+    log x;
+    n <- p;
+    n <- p;
+    // FIXME: use signal-channel for this.
+    log "children finished, root finishing";
+}
+
+io fn b(chan[int] c) {
+  if (true) {
+    log "task b";
+    log "task b";
+    log "task b";
+    log "task b";
+    log "task b";
+    log "task b";
+  }
+  c <| 10;
+}
diff --git a/src/test/run-pass/bind-obj-ctor.rs b/src/test/run-pass/bind-obj-ctor.rs
new file mode 100644
index 00000000..8780b22a
--- /dev/null
+++ b/src/test/run-pass/bind-obj-ctor.rs
@@ -0,0 +1,17 @@
+fn main() {
+  // Testcase for issue #59.
+  obj simple(int x, int y) {
+    fn sum() -> int {
+      ret x + y;
+    }
+  }
+
+  auto obj0 = simple(1,2);
+  auto ctor0 = bind simple(1, _);
+  auto ctor1 = bind simple(_, 2);
+  auto obj1 = ctor0(2);
+  auto obj2 = ctor1(1);
+  check (obj0.sum() == 3);
+  check (obj1.sum() == 3);
+  check (obj2.sum() == 3);
+}
diff --git a/src/test/run-pass/bind-thunk.rs b/src/test/run-pass/bind-thunk.rs
new file mode 100644
index 00000000..be6e1b24
--- /dev/null
+++ b/src/test/run-pass/bind-thunk.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn f() -> int {
+  ret 42;
+}
+
+fn main() {
+  let fn() -> int g = bind f();
+  let int i = g();
+  check(i == 42);
+}
diff --git a/src/test/run-pass/bind-trivial.rs b/src/test/run-pass/bind-trivial.rs
new file mode 100644
index 00000000..fbd6e78d
--- /dev/null
+++ b/src/test/run-pass/bind-trivial.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn f(int n) -> int {
+  ret n;
+}
+
+fn main() {
+  let fn(int) -> int g = bind f(_);
+  let int i = g(42);
+  check(i == 42);
+}
diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs
new file mode 100644
index 00000000..36b58a91
--- /dev/null
+++ b/src/test/run-pass/bitwise.rs
@@ -0,0 +1,21 @@
+// -*- rust -*-
+
+fn main() {
+  let int a = 1;
+  let int b = 2;
+  a ^= b;
+  b ^= a;
+  a = a ^ b;
+  log a;
+  log b;
+  check (b == 1);
+  check (a == 2);
+
+  check (~(0xf0) & 0xff == 0xf);
+  check (0xf0 | 0xf == 0xff);
+  check (0xf << 4 == 0xf0);
+  check (0xf0 >> 4 == 0xf);
+  check (-16 >>> 2 == -4);
+  check (0b1010_1010 | 0b0101_0101 == 0xff);
+}
+
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
new file mode 100644
index 00000000..821ac74c
--- /dev/null
+++ b/src/test/run-pass/box-unbox.rs
@@ -0,0 +1,10 @@
+type box[T] = tup(@T);
+
+fn unbox[T](box[T] b) -> T { ret b._0; }
+
+fn main() {
+  let int foo = 17;
+  let box[int] bfoo = tup(foo);
+  log "see what's in our box";
+  check (unbox[int](bfoo) == foo);
+}
diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs
new file mode 100644
index 00000000..ee2fb186
--- /dev/null
+++ b/src/test/run-pass/cast.rs
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+
+fn main() {
+  let int i = int('Q');
+  check (i == 0x51);
+  let u32 u = u32(i);
+  check (u == u32(0x51));
+  check (u == u32('Q'));
+  check (i8(i) == i8('Q'));
+  check (i8(u8(i)) == i8(u8('Q')));
+  check (char(0x51) == 'Q');
+
+  check (true == bool(1));
+  check (u32(0) == u32(false));
+}
diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs
new file mode 100644
index 00000000..123f2eb2
--- /dev/null
+++ b/src/test/run-pass/char.rs
@@ -0,0 +1,12 @@
+fn main() {
+    let char c = 'x';
+    let char d = 'x';
+    check(c == 'x');
+    check('x' == c);
+    check(c == c);
+    check(c == d);
+    check(d == c);
+    check (d == 'x');
+    check('x' == d);
+}
+
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
new file mode 100644
index 00000000..7de90425
--- /dev/null
+++ b/src/test/run-pass/clone-with-exterior.rs
@@ -0,0 +1,10 @@
+fn f(@rec(int a, int b) x) {
+  check (x.a == 10);
+  check (x.b == 12);
+}
+
+fn main() {
+  let @rec(int a, int b) z = rec(a=10, b=12);
+  let task p = spawn thread f(z);
+  join p;
+}
\ No newline at end of file
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
new file mode 100644
index 00000000..129b3bdc
--- /dev/null
+++ b/src/test/run-pass/comm.rs
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+io fn main() {
+  let port[int] p = port();
+  spawn child(chan(p));
+  let int y;
+  y <- p;
+  log "received";
+  log y;
+  check (y == 10);
+}
+
+io fn child(chan[int] c) {
+  c <| 10;
+}
+
diff --git a/src/test/run-pass/command-line-args.rs b/src/test/run-pass/command-line-args.rs
new file mode 100644
index 00000000..5801f34c
--- /dev/null
+++ b/src/test/run-pass/command-line-args.rs
@@ -0,0 +1,3 @@
+fn main(vec[str] args) {
+  log args.(0);
+}
diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs
new file mode 100644
index 00000000..3a6c13f3
--- /dev/null
+++ b/src/test/run-pass/complex.rs
@@ -0,0 +1,32 @@
+// -*- rust -*-
+
+type t = int;
+fn putstr(str s) {}
+fn putint(int i) {
+  let int i = 33;
+  while (i < 36) {
+    putstr("hi"); i = i + 1;
+  }
+}
+fn zerg(int i) -> int { ret i; }
+fn foo(int x) -> int {
+  let t y = x + 2;
+  putstr("hello");
+  while (y < 10) {
+    putint(y);
+    if (y * 3 == 4) {
+      y = y + 2;
+    }
+  }
+  let t z;
+  z = 0x55;
+  foo(z);
+}
+
+fn main() {
+  let int x = 2 + 2;
+  log x;
+  log "hello, world";
+  log 10;
+}
+
diff --git a/src/test/run-pass/dead-code-one-arm-if.rs b/src/test/run-pass/dead-code-one-arm-if.rs
new file mode 100644
index 00000000..208d62e4
--- /dev/null
+++ b/src/test/run-pass/dead-code-one-arm-if.rs
@@ -0,0 +1,8 @@
+// -*- rust -*-
+
+fn main() {
+  if (1 == 1) {
+    ret;
+  }
+  log "Paul is dead";
+}
diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs
new file mode 100644
index 00000000..5131c42b
--- /dev/null
+++ b/src/test/run-pass/deep.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+fn f(int x) -> int {
+  if (x == 1) {
+    ret 1;
+  } else {
+    let int y = 1 + f(x-1);
+    ret y;
+  }
+}
+
+fn main() {
+  check (f(5000) == 5000);
+}
diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs
new file mode 100644
index 00000000..cfa0fbe9
--- /dev/null
+++ b/src/test/run-pass/div-mod.rs
@@ -0,0 +1,17 @@
+// -*- rust -*-
+
+fn main() {
+  let int x = 15;
+  let int y = 5;
+  check(x / 5 == 3);
+  check(x / 4 == 3);
+  check(x / 3 == 5);
+  check(x / y == 3);
+  check(15 / y == 3);
+
+  check(x % 5 == 0);
+  check(x % 4 == 3);
+  check(x % 3 == 0);
+  check(x % y == 0);
+  check(15 % y == 0);
+}
diff --git a/src/test/run-pass/drop-on-ret.rs b/src/test/run-pass/drop-on-ret.rs
new file mode 100644
index 00000000..9ebbe3ae
--- /dev/null
+++ b/src/test/run-pass/drop-on-ret.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+fn f() -> int {
+  if (true) {
+    let str s = "should not leak";
+    ret 1;
+  }
+  ret 0;
+}
+fn main() {
+  f();
+}
diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs
new file mode 100644
index 00000000..9e3eac14
--- /dev/null
+++ b/src/test/run-pass/else-if.rs
@@ -0,0 +1,19 @@
+fn main() {
+  if (1 == 2) {
+    check(false);
+  } else if (2 == 3) {
+    check(false);
+  } else if (3 == 4) {
+    check(false);
+  } else {
+    check(true);
+  }
+
+
+  if (1 == 2) {
+    check(false);
+  } else if (2 == 2) {
+    check(true);
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/run-pass/export-non-interference.rs b/src/test/run-pass/export-non-interference.rs
new file mode 100644
index 00000000..c0f1843f
--- /dev/null
+++ b/src/test/run-pass/export-non-interference.rs
@@ -0,0 +1,6 @@
+export foo;
+
+type list_cell[T] = tag(cons(@list_cell[T]));
+
+fn main() {
+}
diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs
new file mode 100644
index 00000000..bb0b91eb
--- /dev/null
+++ b/src/test/run-pass/exterior.rs
@@ -0,0 +1,18 @@
+// -*- rust -*-
+
+type point = rec(int x, int y, mutable int z);
+
+fn f(@point p) {
+  check (p.z == 12);
+  p.z = 13;
+  check (p.z == 13);
+}
+
+fn main() {
+  let point a = rec(x=10, y=11, z=mutable 12);
+  let @point b = a;
+  check (b.z == 12);
+  f(b);
+  check (a.z == 12);
+  check (b.z == 13);
+}
diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs
new file mode 100644
index 00000000..91cf099c
--- /dev/null
+++ b/src/test/run-pass/fact.rs
@@ -0,0 +1,21 @@
+// -*- rust -*-
+
+fn f(int x) -> int {
+  // log "in f:";
+  log x;
+  if (x == 1) {
+    // log "bottoming out";
+    ret 1;
+  } else {
+    // log "recurring";
+    let int y = x * f(x-1);
+    // log "returned";
+    log y;
+    ret y;
+  }
+}
+fn main () {
+  check (f(5) == 120);
+  // log "all done";
+}
+
diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
new file mode 100644
index 00000000..43d8b5c3
--- /dev/null
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -0,0 +1,22 @@
+iter pairs() -> tup(int,int) {
+  let int i = 0;
+  let int j = 0;
+  while (i < 10) {
+    put tup(i, j);
+    i += 1;
+    j += i;
+  }
+}
+
+fn main() {
+  let int i = 10;
+  let int j = 0;
+  for each (tup(int,int) p in pairs()) {
+      log p._0;
+      log p._1;
+      check (p._0 + 10 == i);
+      i += 1;
+      j = p._1;
+    }
+  check(j == 45);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs
new file mode 100644
index 00000000..efc6e8ca
--- /dev/null
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -0,0 +1,22 @@
+// -*- rust -*-
+
+fn main() {
+  let int sum = 0;
+  for each (int i in first_ten()) {
+    log "main";
+    log i;
+    sum = sum + i;
+  }
+  log "sum";
+  log sum;
+  check (sum == 45);
+}
+
+iter first_ten() -> int {
+  let int i = 0;
+  while (i < 10) {
+    log "first_ten";
+    put i;
+    i = i + 1;
+  }
+}
diff --git a/src/test/run-pass/foreach-simple.rs b/src/test/run-pass/foreach-simple.rs
new file mode 100644
index 00000000..df0551aa
--- /dev/null
+++ b/src/test/run-pass/foreach-simple.rs
@@ -0,0 +1,17 @@
+// -*- rust -*-
+
+fn main() {
+  for each (int i in first_ten()) {
+    log "main";
+  }
+}
+
+iter first_ten() -> int {
+  let int i = 90;
+  while (i < 100) {
+    log "first_ten";
+    log i;
+    put i;
+    i = i + 1;
+  }
+}
diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs
new file mode 100644
index 00000000..59446b4a
--- /dev/null
+++ b/src/test/run-pass/fun-call-variants.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+fn ho(fn(int) -> int f) -> int {
+  let int n = f(3);
+  ret n;
+}
+
+fn direct(int x) -> int {
+  ret x + 1;
+}
+
+fn main() {
+  let int a = direct(3); // direct
+  //let int b = ho(direct); // indirect unbound
+  let int c = ho(bind direct(_)); // indirect bound
+  //check(a == b);
+  //check(b == c);
+}
+
diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs
new file mode 100644
index 00000000..10c2cf40
--- /dev/null
+++ b/src/test/run-pass/fun-indirect-call.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn f() -> int {
+  ret 42;
+}
+
+fn main() {
+  let fn() -> int g = f;
+  let int i = g();
+  check(i == 42);
+}
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
new file mode 100644
index 00000000..9ed493a2
--- /dev/null
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -0,0 +1,17 @@
+fn g[X](X x) -> X {
+  ret x;
+}
+
+fn f[T](T t) -> tup(T,T) {
+  type pair = tup(T,T);
+  let pair x = tup(t,t);
+  ret g[pair](x);
+}
+
+fn main() {
+  auto b = f[int](10);
+  log b._0;
+  log b._1;
+  check (b._0 == 10);
+  check (b._1 == 10);
+}
diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs
new file mode 100644
index 00000000..3b439b81
--- /dev/null
+++ b/src/test/run-pass/generic-drop-glue.rs
@@ -0,0 +1,9 @@
+fn f[T](T t) {
+  log "dropping";
+}
+
+fn main() {
+  type r = rec(@int x, @int y);
+  auto x = rec(x=@10, y=@12);
+  f[r](x);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
new file mode 100644
index 00000000..797b0f6f
--- /dev/null
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -0,0 +1,13 @@
+type tupbox[T] = tup(@T);
+type recbox[T] = rec(@T x);
+
+fn tuplift[T](T t) -> tupbox[T] { ret tup(@t); }
+fn reclift[T](T t) -> recbox[T] { ret rec(x=@t); }
+
+fn main() {
+  let int foo = 17;
+  let tupbox[int] tbfoo = tuplift[int](foo);
+  let recbox[int] rbfoo = reclift[int](foo);
+  check (tbfoo._0 == foo);
+  check (rbfoo.x == foo);
+}
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
new file mode 100644
index 00000000..e24cf845
--- /dev/null
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -0,0 +1,13 @@
+// -*- rust -*-
+
+// Issue #45: infer type parameters in function applications
+
+fn id[T](T x) -> T {
+  ret x;
+}
+
+fn main() {
+  let int x = 42;
+  let int y = id(x);
+  check (x == y);
+}
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
new file mode 100644
index 00000000..68e5fa5b
--- /dev/null
+++ b/src/test/run-pass/generic-fn.rs
@@ -0,0 +1,32 @@
+// -*- rust -*-
+
+fn id[T](T x) -> T {
+   ret x;
+}
+
+type triple = tup(int,int,int);
+
+fn main() {
+   auto x = 62;
+   auto y = 63;
+   auto a = 'a';
+   auto b = 'b';
+
+   let triple p = tup(65, 66, 67);
+   let triple q = tup(68, 69, 70);
+
+   y = id[int](x);
+   log y;
+   check (x == y);
+
+   b = id[char](a);
+   log b;
+   check (a == b);
+
+   q = id[triple](p);
+   x = p._2;
+   y = q._2;
+   log y;
+   check (x == y);
+
+}
diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs
new file mode 100644
index 00000000..c902420e
--- /dev/null
+++ b/src/test/run-pass/generic-obj-with-derived-type.rs
@@ -0,0 +1,17 @@
+obj handle[T](T data) {
+  fn get() -> T {
+    ret data;
+  }
+}
+
+fn main() {
+  type rgb = tup(u8,u8,u8);
+  let handle[rgb] h = handle[rgb](tup(u8(1), u8(2), u8(3)));
+  log "constructed object";
+  log h.get()._0;
+  log h.get()._1;
+  log h.get()._2;
+  check (h.get()._0 == u8(1));
+  check (h.get()._1 == u8(2));
+  check (h.get()._2 == u8(3));
+}
diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs
new file mode 100644
index 00000000..f67fef4f
--- /dev/null
+++ b/src/test/run-pass/generic-obj.rs
@@ -0,0 +1,24 @@
+obj buf[T](tup(T,T,T) data) {
+  fn get(int i) -> T {
+    if (i == 0) {
+      ret data._0;
+    } else {
+      if (i == 1) {
+        ret data._1;
+      } else {
+        ret data._2;
+      }
+    }
+  }
+}
+
+fn main() {
+  let buf[int] b = buf[int](tup(1,2,3));
+  log "constructed object";
+  log b.get(0);
+  log b.get(1);
+  log b.get(2);
+  check (b.get(0) == 1);
+  check (b.get(1) == 2);
+  check (b.get(2) == 3);
+}
diff --git a/src/test/run-pass/generic-recursive-tag.rs b/src/test/run-pass/generic-recursive-tag.rs
new file mode 100644
index 00000000..7cae581b
--- /dev/null
+++ b/src/test/run-pass/generic-recursive-tag.rs
@@ -0,0 +1,5 @@
+type list[T] = tag(cons(@T, @list[T]), nil());
+
+fn main() {
+  let list[int] a = cons[int](10, cons[int](12, cons[int](13, nil[int]())));
+}
\ No newline at end of file
diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs
new file mode 100644
index 00000000..1fcf2c38
--- /dev/null
+++ b/src/test/run-pass/generic-tag-alt.rs
@@ -0,0 +1,9 @@
+type foo[T] = tag(arm(T));
+
+fn altfoo[T](foo[T] f) {
+  alt (f) {
+    case (arm(x)) {}
+  }
+}
+
+fn main() {}
diff --git a/src/test/run-pass/generic-tag.rs b/src/test/run-pass/generic-tag.rs
new file mode 100644
index 00000000..9a98ead5
--- /dev/null
+++ b/src/test/run-pass/generic-tag.rs
@@ -0,0 +1,6 @@
+type option[T] = tag(some(@T), none());
+
+fn main() {
+  let option[int] a = some[int](10);
+  a = none[int]();
+}
\ No newline at end of file
diff --git a/src/test/run-pass/generic-type-synonym.rs b/src/test/run-pass/generic-type-synonym.rs
new file mode 100644
index 00000000..4ddc8946
--- /dev/null
+++ b/src/test/run-pass/generic-type-synonym.rs
@@ -0,0 +1,4 @@
+type foo[T] = tup(T);
+type bar[T] = foo[T];
+fn takebar[T](bar[T] b) {}
+fn main() {}
\ No newline at end of file
diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs
new file mode 100644
index 00000000..6638cebf
--- /dev/null
+++ b/src/test/run-pass/generic-type.rs
@@ -0,0 +1,6 @@
+type pair[T] = tup(T,T);
+fn main() {
+  let pair[int] x = tup(10,12);
+  check (x._0 == 10);
+  check (x._1 == 12);
+}
diff --git a/src/test/run-pass/hello.rs b/src/test/run-pass/hello.rs
new file mode 100644
index 00000000..8535f74e
--- /dev/null
+++ b/src/test/run-pass/hello.rs
@@ -0,0 +1,6 @@
+// -*- rust -*-
+
+fn main() {
+  log "hello, world.";
+}
+
diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs
new file mode 100644
index 00000000..99bd3936
--- /dev/null
+++ b/src/test/run-pass/i32-sub.rs
@@ -0,0 +1,8 @@
+// -*- rust -*-
+
+fn main() {
+    let i32 x = i32(-400);
+    x = i32(0) - x;
+    check(x == i32(400));
+}
+
diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs
new file mode 100644
index 00000000..57029a13
--- /dev/null
+++ b/src/test/run-pass/i8-incr.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+fn main() {
+  let i8 x = i8(-12);
+  let i8 y = i8(-12);
+  x = x + i8(1);
+  x = x - i8(1);
+  check(x == y);
+}
diff --git a/src/test/run-pass/import.rs b/src/test/run-pass/import.rs
new file mode 100644
index 00000000..76de0d18
--- /dev/null
+++ b/src/test/run-pass/import.rs
@@ -0,0 +1,14 @@
+mod foo {
+  fn x(int y) {
+    log y;
+  }
+}
+
+mod bar {
+  import foo.x;
+  import z = foo.x;
+  fn main() {
+    x(10);
+    z(10);
+  }
+}
diff --git a/src/test/run-pass/inner-module.rs b/src/test/run-pass/inner-module.rs
new file mode 100644
index 00000000..f5066b6e
--- /dev/null
+++ b/src/test/run-pass/inner-module.rs
@@ -0,0 +1,17 @@
+// -*- rust -*-
+
+mod inner {
+  mod inner2 {
+    fn hello() {
+      log "hello, modular world";
+    }
+  }
+  fn hello() {
+    inner2.hello();
+  }
+}
+
+fn main() {
+  inner.hello();
+  inner.inner2.hello();
+}
diff --git a/src/test/run-pass/int.rs b/src/test/run-pass/int.rs
new file mode 100644
index 00000000..39cd48f0
--- /dev/null
+++ b/src/test/run-pass/int.rs
@@ -0,0 +1,6 @@
+// -*- rust -*-
+
+
+fn main() {
+  let int x = 10;
+}
diff --git a/src/test/run-pass/large-records.rs b/src/test/run-pass/large-records.rs
new file mode 100644
index 00000000..0de2aa1b
--- /dev/null
+++ b/src/test/run-pass/large-records.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+fn f() {
+  let rec(int a, int b, int c, int d,
+          int e, int f, int g, int h,
+          int i, int j, int k, int l) foo =
+    rec(a=0, b=0, c=0, d=0,
+        e=0, f=0, g=0, h=0,
+        i=0, j=0, k=0, l=0);
+}
+
+fn main() {
+  f();
+}
diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
new file mode 100644
index 00000000..81f09843
--- /dev/null
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -0,0 +1,22 @@
+fn incr(mutable &int x) -> bool {
+  x += 1;
+  check (false);
+  ret false;
+}
+
+fn main() {
+
+  auto x = (1 == 2) || (3 == 3);
+  check (x);
+
+  let int y = 10;
+  log x || incr(y);
+  check (y == 10);
+
+  if (true && x) {
+    check (true);
+  } else {
+    check (false);
+  }
+
+}
\ No newline at end of file
diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
new file mode 100644
index 00000000..9d560bd9
--- /dev/null
+++ b/src/test/run-pass/lazychan.rs
@@ -0,0 +1,23 @@
+// -*- rust -*-
+
+io fn main() {
+  let port[int] p = port();
+  auto c = chan(p);
+  let int y;
+
+  spawn child(c);
+  y <- p;
+  log "received 1";
+  log y;
+  check (y == 10);
+
+  spawn child(c);
+  y <- p;
+  log "received 2";
+  log y;
+  check (y == 10);
+}
+
+io fn child(chan[int] c) {
+  c <| 10;
+}
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
new file mode 100644
index 00000000..4312aea8
--- /dev/null
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -0,0 +1,38 @@
+fn main() {
+  auto x = vec(1,2,3);
+  auto y = 0;
+  for (int i in x) {
+    log i;
+    y += i;
+  }
+  log y;
+  check (y == 6);
+
+  auto s = "hello there";
+  let int i = 0;
+  for (u8 c in s) {
+    if (i == 0) {
+      check (c == u8('h'));
+    }
+    if (i == 1) {
+      check (c == u8('e'));
+    }
+    if (i == 2) {
+      check (c == u8('l'));
+    }
+    if (i == 3) {
+      check (c == u8('l'));
+    }
+    if (i == 4) {
+      check (c == u8('o'));
+    }
+    // ...
+    if (i == 12) {
+      check (c == u8(0));
+    }
+    i += 1;
+    log i;
+    log c;
+  }
+  check(i == 12);
+}
diff --git a/src/test/run-pass/list.rs b/src/test/run-pass/list.rs
new file mode 100644
index 00000000..38601f8f
--- /dev/null
+++ b/src/test/run-pass/list.rs
@@ -0,0 +1,7 @@
+// -*- rust -*-
+
+type list = tag(cons(int,@list), nil());
+
+fn main() {
+  cons(10, cons(11, cons(12, nil())));
+}
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
new file mode 100644
index 00000000..3776d38e
--- /dev/null
+++ b/src/test/run-pass/many.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+io fn sub(chan[int] parent, int id) {
+  if (id == 0) {
+    parent <| 0;
+  } else {
+    let port[int] p = port();
+    auto child = spawn sub(chan(p), id-1);
+    let int y <- p;
+    parent <| y + 1;
+  }
+}
+
+io fn main() {
+  let port[int] p = port();
+  auto child = spawn sub(chan(p), 500);
+  let int y <- p;
+  check (y == 500);
+}
diff --git a/src/test/run-pass/mlist-cycle.rs b/src/test/run-pass/mlist-cycle.rs
new file mode 100644
index 00000000..3875c5c2
--- /dev/null
+++ b/src/test/run-pass/mlist-cycle.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+type pair = rec(int head, mutable @mlist tail);
+type mlist = tag(cons(@pair), nil());
+
+fn main() {
+  let @pair p = rec(head=10, tail=mutable nil());
+  let @mlist cycle = cons(p);
+  //p.tail = cycle;
+}
diff --git a/src/test/run-pass/mlist.rs b/src/test/run-pass/mlist.rs
new file mode 100644
index 00000000..ba71aa58
--- /dev/null
+++ b/src/test/run-pass/mlist.rs
@@ -0,0 +1,7 @@
+// -*- rust -*-
+
+type mlist = tag(cons(int,mutable @mlist), nil());
+
+fn main() {
+  cons(10, cons(11, cons(12, nil())));
+}
diff --git a/src/test/run-pass/mutable-vec-drop.rs b/src/test/run-pass/mutable-vec-drop.rs
new file mode 100644
index 00000000..df3b55ee
--- /dev/null
+++ b/src/test/run-pass/mutable-vec-drop.rs
@@ -0,0 +1,4 @@
+fn main() {
+  // This just tests whether the vec leaks its members.
+  let vec[mutable @tup(int,int)] pvec = vec(tup(1,2),tup(3,4),tup(5,6));
+}
diff --git a/src/test/run-pass/mutual-recursion-group.rs b/src/test/run-pass/mutual-recursion-group.rs
new file mode 100644
index 00000000..850858a3
--- /dev/null
+++ b/src/test/run-pass/mutual-recursion-group.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+type colour = tag(red(), green(), blue());
+type tree = tag(children(@list), leaf(colour));
+type list = tag(cons(@tree, @list), nil());
+
+type small_list = tag(kons(int,@small_list), neel());
+
+fn main() {
+}
+
diff --git a/src/test/run-pass/native-mod-src/inner.rs b/src/test/run-pass/native-mod-src/inner.rs
new file mode 100644
index 00000000..546b2291
--- /dev/null
+++ b/src/test/run-pass/native-mod-src/inner.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+unsafe fn main() {
+   auto f = "Makefile";
+   auto s = rustrt.str_buf(f);
+   auto buf = libc.malloc(1024);
+   auto fd = libc.open(s, 0, 0);
+   libc.read(fd, buf, 1024);
+   libc.write(1, buf, 1024);
+   libc.close(fd);
+   libc.free(buf);
+}
diff --git a/src/test/run-pass/native-mod.rc b/src/test/run-pass/native-mod.rc
new file mode 100644
index 00000000..4fcf4499
--- /dev/null
+++ b/src/test/run-pass/native-mod.rc
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+native mod libc = target_libc {
+  fn open(int name, int flags, int mode) -> int;
+  fn close(int fd) -> int;
+  fn read(int fd, int buf, int count) -> int;
+  fn write(int fd, int buf, int count) -> int;
+  fn malloc(int sz) -> int;
+  fn free(int p) -> ();
+}
+
+native "rust" mod rustrt {
+  fn str_buf(str s) -> int;
+}
+
+mod inner = "native-mod-src/inner.rs";
diff --git a/src/test/run-pass/native-opaque-type.rs b/src/test/run-pass/native-opaque-type.rs
new file mode 100644
index 00000000..19c2c074
--- /dev/null
+++ b/src/test/run-pass/native-opaque-type.rs
@@ -0,0 +1,7 @@
+native mod libc {
+  type file_handle;
+}
+
+fn main() {
+  check (true);
+}
diff --git a/src/test/run-pass/native-src/native.rs b/src/test/run-pass/native-src/native.rs
new file mode 100644
index 00000000..22658095
--- /dev/null
+++ b/src/test/run-pass/native-src/native.rs
@@ -0,0 +1,7 @@
+// -*- rust -*-
+
+unsafe fn main() {
+  libc.puts(rustrt.str_buf("hello, native world 1"));
+  libc.puts(rustrt.str_buf("hello, native world 2"));
+  libc.puts(rustrt.str_buf("hello, native world 3"));
+}
diff --git a/src/test/run-pass/native.rc b/src/test/run-pass/native.rc
new file mode 100644
index 00000000..c0f019c5
--- /dev/null
+++ b/src/test/run-pass/native.rc
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+native "rust" mod rustrt {
+  fn str_buf(str s) -> int;
+}
+
+
+native mod libc = target_libc {
+  fn puts(int s) -> ();
+}
+
+mod user = "native-src/native.rs";
diff --git a/src/test/run-pass/obj-as.rs b/src/test/run-pass/obj-as.rs
new file mode 100644
index 00000000..62eda294
--- /dev/null
+++ b/src/test/run-pass/obj-as.rs
@@ -0,0 +1,21 @@
+
+obj big() {
+  fn one() -> int { ret 1; }
+  fn two() -> int { ret 2; }
+  fn three() -> int { ret 3; }
+}
+
+type small = obj {
+               fn one() -> int;
+             };
+
+fn main() {
+
+  let big b = big();
+  check (b.one() == 1);
+  check (b.two() == 2);
+  check (b.three() == 3);
+
+  let small s = b as small;
+  check (s.one() == 1);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/obj-drop.rs b/src/test/run-pass/obj-drop.rs
new file mode 100644
index 00000000..6d4ca3d4
--- /dev/null
+++ b/src/test/run-pass/obj-drop.rs
@@ -0,0 +1,6 @@
+fn main() {
+  obj handle(@int i) {
+  }
+  // This just tests whether the obj leaks its exterior state members.
+  auto ob = handle(0xf00f00);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/obj-dtor.rs b/src/test/run-pass/obj-dtor.rs
new file mode 100644
index 00000000..8b79047b
--- /dev/null
+++ b/src/test/run-pass/obj-dtor.rs
@@ -0,0 +1,33 @@
+obj worker(chan[int] c) {
+  drop {
+    log "in dtor";
+    c <| 10;
+  }
+}
+
+io fn do_work(chan[int] c) {
+  log "in child task";
+  {
+    let worker w = worker(c);
+    log "constructed worker";
+  }
+  log "destructed worker";
+  while(true) {
+    // Deadlock-condition not handled properly yet, need to avoid
+    // exiting the child early.
+    c <| 11;
+    yield;
+  }
+}
+
+io fn main() {
+  let port[int] p = port();
+  log "spawning worker";
+  auto w = spawn do_work(chan(p));
+  let int i;
+  log "parent waiting for shutdown";
+  i <- p;
+  log "received int";
+  check (i == 10);
+  log "int is OK, child-dtor ran as expected";
+}
\ No newline at end of file
diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs
new file mode 100644
index 00000000..169889a3
--- /dev/null
+++ b/src/test/run-pass/obj-with-vec.rs
@@ -0,0 +1,11 @@
+fn main() {
+
+  obj buf(vec[u8] data) {
+    fn get(int i) -> u8 {
+      ret data.(i);
+    }
+  }
+  auto b = buf(vec(u8(1), u8(2), u8(3)));
+  log b.get(1);
+  check (b.get(1) == u8(2));
+}
\ No newline at end of file
diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs
new file mode 100644
index 00000000..d99ebb04
--- /dev/null
+++ b/src/test/run-pass/opeq.rs
@@ -0,0 +1,22 @@
+// -*- rust -*-
+
+fn main() {
+  let int x = 1;
+
+  x *= 2;
+  log x;
+  check (x == 2);
+
+  x += 3;
+  log x;
+  check (x == 5);
+
+  x *= x;
+  log x;
+  check (x == 25);
+
+  x /= 5;
+  log x;
+  check (x == 5);
+}
+
diff --git a/src/test/run-pass/pred.rs b/src/test/run-pass/pred.rs
new file mode 100644
index 00000000..b3338f38
--- /dev/null
+++ b/src/test/run-pass/pred.rs
@@ -0,0 +1,18 @@
+// -*- rust -*-
+
+fn f(int a, int b) : lt(a,b) {
+}
+
+fn lt(int a, int b) -> bool {
+  ret a < b;
+}
+
+fn main() {
+  let int a = 10;
+  let int b = 23;
+  let int c = 77;
+  check lt(a,b);
+  check lt(a,c);
+  f(a,b);
+  f(a,c);
+}
diff --git a/src/test/run-pass/preempt.rs b/src/test/run-pass/preempt.rs
new file mode 100644
index 00000000..00fc29ca
--- /dev/null
+++ b/src/test/run-pass/preempt.rs
@@ -0,0 +1,26 @@
+// This checks that preemption works.
+
+io fn starve_main(chan[int] alive) {
+  log "signalling main";
+  alive <| 1;
+  log "starving main";
+  let int i = 0;
+  while (true) {
+    i += 1;
+  }
+}
+
+io fn main() {
+  let port[int] alive = port();
+  log "main started";
+  let task s = spawn starve_main(chan(alive));
+  let int i;
+  log "main waiting for alive signal";
+  i <- alive;
+  log "main got alive signal";
+  while (i < 1000) {
+    log "main iterated";
+    i += 1;
+  }
+  log "main completed";
+}
\ No newline at end of file
diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs
new file mode 100644
index 00000000..15fa142a
--- /dev/null
+++ b/src/test/run-pass/readalias.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+type point = rec(int x, int y, int z);
+
+fn f(&point p) {
+  check (p.z == 12);
+}
+
+fn main() {
+  let point x = rec(x=10, y=11, z=12);
+  f(x);
+}
diff --git a/src/test/run-pass/rec-auto.rs b/src/test/run-pass/rec-auto.rs
new file mode 100644
index 00000000..01390acd
--- /dev/null
+++ b/src/test/run-pass/rec-auto.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+// Issue #50.
+
+fn main() {
+  auto x = rec(foo = "hello", bar = "world");
+  log x.foo;
+  log x.bar;
+}
diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs
new file mode 100644
index 00000000..db81278b
--- /dev/null
+++ b/src/test/run-pass/rec-extend.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+type point = rec(int x, int y);
+
+fn main() {
+  let point origin = rec(x=0, y=0);
+
+  let point right = rec(x=origin.x + 10 with origin);
+  let point up = rec(y=origin.y + 10 with origin);
+
+  check(origin.x == 0);
+  check(origin.y == 0);
+
+  check(right.x == 10);
+  check(right.y == 0);
+
+  check(up.x == 0);
+  check(up.y == 10);
+}
diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs
new file mode 100644
index 00000000..e25439a9
--- /dev/null
+++ b/src/test/run-pass/rec-tup.rs
@@ -0,0 +1,25 @@
+// -*- rust -*-
+
+type point = rec(int x, int y);
+type rect = tup(point, point);
+
+fn f(rect r, int x1, int y1, int x2, int y2) {
+  check (r._0.x == x1);
+  check (r._0.y == y1);
+  check (r._1.x == x2);
+  check (r._1.y == y2);
+}
+
+fn main() {
+  let rect r = tup( rec(x=10, y=20),
+                    rec(x=11, y=22) );
+  check (r._0.x == 10);
+  check (r._0.y == 20);
+  check (r._1.x == 11);
+  check (r._1.y == 22);
+  let rect r2 = r;
+  let int x = r2._0.x;
+  check (x == 10);
+  f(r, 10, 20, 11, 22);
+  f(r2, 10, 20, 11, 22);
+}
diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs
new file mode 100644
index 00000000..0f6b7d79
--- /dev/null
+++ b/src/test/run-pass/rec.rs
@@ -0,0 +1,23 @@
+// -*- rust -*-
+
+type rect = rec(int x, int y, int w, int h);
+
+fn f(rect r, int x, int y, int w, int h) {
+  check (r.x == x);
+  check (r.y == y);
+  check (r.w == w);
+  check (r.h == h);
+}
+
+fn main() {
+  let rect r = rec(x=10, y=20, w=100, h=200);
+  check (r.x == 10);
+  check (r.y == 20);
+  check (r.w == 100);
+  check (r.h == 200);
+  let rect r2 = r;
+  let int x = r2.x;
+  check (x == 10);
+  f(r, 10, 20, 100, 200);
+  f(r2, 10, 20, 100, 200);
+}
diff --git a/src/test/run-pass/return-nil.rs b/src/test/run-pass/return-nil.rs
new file mode 100644
index 00000000..c3c8a085
--- /dev/null
+++ b/src/test/run-pass/return-nil.rs
@@ -0,0 +1,8 @@
+fn f() {
+   let () x = ();
+   ret x;
+}
+
+fn main() {
+   auto x = f();
+}
\ No newline at end of file
diff --git a/src/test/run-pass/simple-obj.rs b/src/test/run-pass/simple-obj.rs
new file mode 100644
index 00000000..b465a7d3
--- /dev/null
+++ b/src/test/run-pass/simple-obj.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+obj x() {
+  fn hello() {
+    log "hello, object world";
+  }
+}
+
+fn main() {
+  auto mx = x();
+  mx.hello();
+}
diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs
new file mode 100644
index 00000000..894a8321
--- /dev/null
+++ b/src/test/run-pass/spawn-fn.rs
@@ -0,0 +1,18 @@
+// -*- rust -*-
+
+fn x(str s, int n) {
+  log s;
+  log n;
+}
+
+fn main() {
+  spawn x("hello from first spawned fn", 65);
+  spawn x("hello from second spawned fn", 66);
+  spawn x("hello from third spawned fn", 67);
+  let int i = 30;
+  while (i > 0) {
+    i = i - 1;
+    log "parent sleeping";
+    yield;
+  }
+}
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
new file mode 100644
index 00000000..765d4c9e
--- /dev/null
+++ b/src/test/run-pass/spawn.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+fn main() {
+  spawn child(10);
+}
+
+fn child(int i) {
+   log i;
+}
+
diff --git a/src/test/run-pass/stateful-obj.rs b/src/test/run-pass/stateful-obj.rs
new file mode 100644
index 00000000..c1d96cc3
--- /dev/null
+++ b/src/test/run-pass/stateful-obj.rs
@@ -0,0 +1,23 @@
+// -*- rust -*-
+
+obj counter(mutable int x) {
+  fn hello() -> int {
+    ret 12345;
+  }
+  fn incr() {
+    x = x + 1;
+  }
+  fn get() -> int {
+    ret x;
+  }
+}
+
+fn main() {
+  auto y = counter(0);
+  check (y.hello() == 12345);
+  log y.get();
+  y.incr();
+  y.incr();
+  log y.get();
+  check (y.get() == 2);
+}
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
new file mode 100644
index 00000000..92d8ab89
--- /dev/null
+++ b/src/test/run-pass/str-append.rs
@@ -0,0 +1,8 @@
+// -*- rust -*-
+
+fn main() {
+  let str s = "hello";
+  s += "world";
+  log s;
+  check(s.(9) == u8('d'));
+}
diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
new file mode 100644
index 00000000..874a379b
--- /dev/null
+++ b/src/test/run-pass/str-concat.rs
@@ -0,0 +1,9 @@
+// -*- rust -*-
+
+fn main() {
+  let str a = "hello";
+  let str b = "world";
+  let str s = a + b;
+  log s;
+  check(s.(9) == u8('d'));
+}
diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs
new file mode 100644
index 00000000..2f39dea9
--- /dev/null
+++ b/src/test/run-pass/str-idx.rs
@@ -0,0 +1,7 @@
+
+fn main() {
+  auto s = "hello";
+  let u8 c = s.(4);
+  log c;
+  check (c == u8(0x6f));
+}
diff --git a/src/test/run-pass/syntax-extension.rs b/src/test/run-pass/syntax-extension.rs
new file mode 100644
index 00000000..35f0f2d8
--- /dev/null
+++ b/src/test/run-pass/syntax-extension.rs
@@ -0,0 +1,4 @@
+fn main() {
+  auto s = #shell { uname -a && hg identify };
+  log s;
+}
diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs
new file mode 100644
index 00000000..0d345b2d
--- /dev/null
+++ b/src/test/run-pass/tag.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+type colour = tag(red(int,int), green());
+
+fn f() {
+  auto x = red(1,2);
+  auto y = green();
+  // FIXME: needs structural equality test working.
+  // check (x != y);
+}
+
+fn main() {
+  f();
+}
diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs
new file mode 100644
index 00000000..795a105a
--- /dev/null
+++ b/src/test/run-pass/tail-cps.rs
@@ -0,0 +1,34 @@
+// -*- rust -*-
+
+fn checktrue(bool res) -> bool {
+  check(res);
+  ret true;
+}
+
+fn main() {
+  auto k = checktrue;
+  evenk(42, k);
+  oddk(45, k);
+}
+
+fn evenk(int n, fn(bool) -> bool k) -> bool {
+  log "evenk";
+  log n;
+  if (n == 0) {
+    be k(true);
+  }
+  else {
+    be oddk(n - 1, k);
+  }
+}
+
+fn oddk(int n, fn(bool) -> bool k) -> bool {
+  log "oddk";
+  log n;
+  if (n == 0) {
+    be k(false);
+  }
+  else {
+    be evenk(n - 1, k);
+  }
+}
diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs
new file mode 100644
index 00000000..345a322e
--- /dev/null
+++ b/src/test/run-pass/tail-direct.rs
@@ -0,0 +1,24 @@
+// -*- rust -*-
+
+fn main() {
+  check(even(42));
+  check(odd(45));
+}
+
+fn even(int n) -> bool {
+  if (n == 0) {
+    ret true;
+  }
+  else {
+    be odd(n - 1);
+  }
+}
+
+fn odd(int n) -> bool {
+  if (n == 0) {
+    ret false;
+  }
+  else {
+    be even(n - 1);
+  }
+}
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
new file mode 100644
index 00000000..4a21b4e4
--- /dev/null
+++ b/src/test/run-pass/task-comm.rs
@@ -0,0 +1,127 @@
+
+
+io fn main() -> () {
+    test00(true);
+    // test01();
+    // test02();
+    // test03();
+    // test04();
+}
+
+io fn test00_start(chan[int] ch, int message, int count) {
+    log "Starting test00_start";
+    let int i = 0;
+    while (i < count) {
+        ch <| message;
+        i = i + 1;
+    }
+    log "Ending test00_start";
+}
+
+io fn test00(bool is_multithreaded) {
+    let int number_of_tasks = 4;
+    let int number_of_messages = 64;
+    log "Creating tasks";
+    
+    let port[int] po = port();
+    let chan[int] ch = chan(po);
+    
+    let int i = 0;
+    
+    let vec[task] tasks = vec();
+    while (i < number_of_tasks) {
+        i = i + 1;
+        if (is_multithreaded) {
+            tasks += vec(
+                spawn thread test00_start(ch, i, number_of_messages));
+        } else {
+            tasks += vec(spawn test00_start(ch, i, number_of_messages));
+        }
+    }
+    
+    let int sum = 0;
+    for (task t in tasks) {
+        i = 0;
+        while (i < number_of_messages) {
+            let int value <- po;
+            sum += value;
+            i = i + 1;
+        }
+    }
+
+    for (task t in tasks) {
+        join t;
+    }
+    
+    log "Completed: Final number is: ";
+    check (sum == number_of_messages * 
+           (number_of_tasks * number_of_tasks + number_of_tasks) / 2);
+}
+
+io fn test01() {
+    let port[int] p = port();
+    log "Reading from a port that is never written to.";
+    let int value <- p;
+    log value;
+}
+
+io fn test02() {
+    let port[int] p = port();
+    let chan[int] c = chan(p);
+    log "Writing to a local task channel.";
+    c <| 42;
+    log "Reading from a local task port.";
+    let int value <- p;
+    log value;
+}
+
+obj vector(mutable int x, int y) {
+    fn length() -> int {
+        x = x + 2;
+        ret x + y;
+    }
+}
+
+fn test03() {
+    log "Creating object ...";
+    let mutable vector v = vector(1, 2);
+    log "created object ...";
+    let mutable vector t = v;
+    log v.length();
+}
+
+fn test04_start() {
+    log "Started Task";
+    let int i = 1024 * 1024 * 64;
+    while (i > 0) {
+        i = i - 1;
+    }
+    log "Finished Task";
+}
+
+fn test04() {
+    log "Spawning lots of tasks.";
+    let int i = 64;
+    while (i > 0) {
+        i = i - 1;
+        spawn thread test04_start();
+    }
+    log "Finishing up.";
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
new file mode 100644
index 00000000..b0fee65f
--- /dev/null
+++ b/src/test/run-pass/threads.rs
@@ -0,0 +1,16 @@
+// -*- rust -*-
+
+fn main() {
+  let port[int] p = port();
+  let int i = 10;
+  while (i > 0) {
+    spawn thread child(i);
+    i = i - 1;
+  }
+  log "main thread exiting";
+}
+
+fn child(int x) {
+  log x;
+}
+
diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs
new file mode 100644
index 00000000..23406646
--- /dev/null
+++ b/src/test/run-pass/tup.rs
@@ -0,0 +1,19 @@
+// -*- rust -*-
+
+type point = tup(int, int);
+
+fn f(point p, int x, int y) {
+  check (p._0 == x);
+  check (p._1 == y);
+}
+
+fn main() {
+  let point p = tup(10, 20);
+  check (p._0 == 10);
+  check (p._1 == 20);
+  let point p2 = p;
+  let int x = p2._0;
+  check (x == 10);
+  f(p, 10, 20);
+  f(p2, 10, 20);
+}
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
new file mode 100644
index 00000000..40f9dbad
--- /dev/null
+++ b/src/test/run-pass/type-sizes.rs
@@ -0,0 +1,20 @@
+
+import size_of = std.sys.rustrt.size_of;
+
+use std;
+
+fn main() {
+  check (size_of[u8]() == uint(1));
+  check (size_of[u32]() == uint(4));
+  check (size_of[char]() == uint(4));
+  check (size_of[i8]() == uint(1));
+  check (size_of[i32]() == uint(4));
+  check (size_of[tup(u8,i8)]() == uint(2));
+  check (size_of[tup(u8,i8,u8)]() == uint(3));
+  // Alignment causes padding before the char and the u32.
+  check (size_of[tup(u8,i8,tup(char,u8),u32)]() == uint(16));
+  check (size_of[int]() == size_of[uint]());
+  check (size_of[tup(int,())]() == size_of[int]());
+  check (size_of[tup(int,(),())]() == size_of[int]());
+  check (size_of[int]() == size_of[rec(int x)]());
+}
diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs
new file mode 100644
index 00000000..15d5bcaa
--- /dev/null
+++ b/src/test/run-pass/u32-decr.rs
@@ -0,0 +1,8 @@
+// -*- rust -*-
+
+fn main() {
+    let u32 word = u32(200000);
+    word = word - u32(1);
+    check(word == u32(199999));
+}
+
diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs
new file mode 100644
index 00000000..e8c29d4f
--- /dev/null
+++ b/src/test/run-pass/u8-incr-decr.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+// These constants were chosen because they aren't used anywhere
+// in the rest of the generated code so they're easily grep-able.
+
+fn main() {
+  let u8 x = u8(19); // 0x13
+  let u8 y = u8(35); // 0x23
+  x = x + u8(7);     // 0x7
+  y = y - u8(9);     // 0x9
+  check(x == y);
+}
diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs
new file mode 100644
index 00000000..c3c1aef4
--- /dev/null
+++ b/src/test/run-pass/u8-incr.rs
@@ -0,0 +1,12 @@
+// -*- rust -*-
+
+fn main() {
+  let u8 x = u8(12);
+  let u8 y = u8(12);
+  x = x + u8(1);
+  x = x - u8(1);
+  check(x == y);
+  //x = u8(14);
+  //x = x + u8(1);
+}
+
diff --git a/src/test/run-pass/uint.rs b/src/test/run-pass/uint.rs
new file mode 100644
index 00000000..924ff469
--- /dev/null
+++ b/src/test/run-pass/uint.rs
@@ -0,0 +1,6 @@
+// -*- rust -*-
+
+
+fn main() {
+  let uint x = uint(10);
+}
diff --git a/src/test/run-pass/unit.rs b/src/test/run-pass/unit.rs
new file mode 100644
index 00000000..ce24eabe
--- /dev/null
+++ b/src/test/run-pass/unit.rs
@@ -0,0 +1,13 @@
+// -*- rust -*-
+
+fn f(() u) -> () {
+  ret u;
+}
+
+fn main() -> () {
+  let () u1 = ();
+  let () u2 = f(u1);
+  u2 = ();
+  ret ();
+}
+
diff --git a/src/test/run-pass/user.rs b/src/test/run-pass/user.rs
new file mode 100644
index 00000000..82d3234a
--- /dev/null
+++ b/src/test/run-pass/user.rs
@@ -0,0 +1,14 @@
+// -*- rust -*-
+
+use std (name = "std",
+         url = "http://rust-lang.org/src/std",
+         uuid = _, ver = _);
+
+fn main() {
+  auto s = std._str.alloc(10);
+  s += "hello ";
+  log s;
+  s += "there";
+  log s;
+  auto z = std._vec.alloc[int](10);
+}
diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
new file mode 100644
index 00000000..fd70423a
--- /dev/null
+++ b/src/test/run-pass/utf8.rs
@@ -0,0 +1,48 @@
+fn main() {
+  let char yen = '¥';         // 0xa5
+  let char c_cedilla = 'ç';   // 0xe7
+  let char thorn = 'þ';       // 0xfe
+  let char y_diaeresis = 'ÿ'; // 0xff
+  let char pi = 'Π';          // 0x3a0
+
+  check (int(yen) == 0xa5);
+  check (int(c_cedilla) == 0xe7);
+  check (int(thorn) == 0xfe);
+  check (int(y_diaeresis) == 0xff);
+  check (int(pi) == 0x3a0);
+
+  check (int(pi) == int('\u03a0'));
+  check (int('\x0a') == int('\n'));
+
+  let str bhutan = "འབྲུག་ཡུལ།";
+  let str japan = "日本";
+  let str uzbekistan = "Ўзбекистон";
+  let str austria = "Österreich";
+
+  let str bhutan_e =
+    "\u0f60\u0f56\u0fb2\u0f74\u0f42\u0f0b\u0f61\u0f74\u0f63\u0f0d";
+  let str japan_e = "\u65e5\u672c";
+  let str uzbekistan_e =
+    "\u040e\u0437\u0431\u0435\u043a\u0438\u0441\u0442\u043e\u043d";
+  let str austria_e = "\u00d6sterreich";
+
+  let char oo = 'Ö';
+  check (int(oo) == 0xd6);
+
+  fn check_str_eq(str a, str b) {
+    let int i = 0;
+    for (u8 ab in a) {
+      log i;
+      log ab;
+      let u8 bb = b.(i);
+      log bb;
+      check(ab == bb);
+      i += 1;
+    }
+  }
+
+  check_str_eq(bhutan, bhutan_e);
+  check_str_eq(japan, japan_e);
+  check_str_eq(uzbekistan, uzbekistan_e);
+  check_str_eq(austria, austria_e);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs
new file mode 100644
index 00000000..4324ee25
--- /dev/null
+++ b/src/test/run-pass/vec-append.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+fn main() {
+  let vec[int] v = vec(1,2,3,4,5);
+  v += vec(6,7,8,9,0);
+  log v.(9);
+  check(v.(0) == 1);
+  check(v.(7) == 8);
+  check(v.(9) == 0);
+}
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
new file mode 100644
index 00000000..b6c52c3e
--- /dev/null
+++ b/src/test/run-pass/vec-concat.rs
@@ -0,0 +1,11 @@
+// -*- rust -*-
+
+fn main() {
+  let vec[int] a = vec(1,2,3,4,5);
+  let vec[int] b = vec(6,7,8,9,0);
+  let vec[int] v = a + b;
+  log v.(9);
+  check(v.(0) == 1);
+  check(v.(7) == 8);
+  check(v.(9) == 0);
+}
diff --git a/src/test/run-pass/vec-drop.rs b/src/test/run-pass/vec-drop.rs
new file mode 100644
index 00000000..267c7a78
--- /dev/null
+++ b/src/test/run-pass/vec-drop.rs
@@ -0,0 +1,4 @@
+fn main() {
+  // This just tests whether the vec leaks its members.
+  let vec[@tup(int,int)] pvec = vec(tup(1,2),tup(3,4),tup(5,6));
+}
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
new file mode 100644
index 00000000..332eff34
--- /dev/null
+++ b/src/test/run-pass/vec-slice.rs
@@ -0,0 +1,6 @@
+fn main() {
+  let vec[int] v = vec(1,2,3,4,5);
+  auto v2 = v.(1,2);
+  check (v2.(0) == 2);
+  check (v2.(1) == 3);
+}
\ No newline at end of file
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
new file mode 100644
index 00000000..67a41eab
--- /dev/null
+++ b/src/test/run-pass/vec.rs
@@ -0,0 +1,13 @@
+// -*- rust -*-
+
+fn main() {
+  let vec[int] v = vec(10, 20);
+  check (v.(0) == 10);
+  check (v.(1) == 20);
+  let int x = 0;
+  check (v.(x) == 10);
+  check (v.(x + 1) == 20);
+  x = x + 1;
+  check (v.(x) == 20);
+  check (v.(x-1) == 10);
+}
diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs
new file mode 100644
index 00000000..96b2a9d7
--- /dev/null
+++ b/src/test/run-pass/writealias.rs
@@ -0,0 +1,13 @@
+// -*- rust -*-
+
+type point = rec(int x, int y, mutable int z);
+
+fn f(mutable &point p) {
+  p.z = 13;
+}
+
+fn main() {
+  let point x = rec(x=10, y=11, z=mutable 12);
+  f(x);
+  check (x.z == 13);
+}
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
new file mode 100644
index 00000000..d2ae592a
--- /dev/null
+++ b/src/test/run-pass/yield.rs
@@ -0,0 +1,20 @@
+// -*- rust -*-
+
+fn main() {
+  auto other = spawn child();
+  log "1";
+  yield;
+  log "2";
+  yield;
+  log "3";
+  join other;
+}
+
+fn child() {
+  log "4";
+  yield;
+  log "5";
+  yield;
+  log "6";
+}
+
diff --git a/src/test/run-pass/yield2.rs b/src/test/run-pass/yield2.rs
new file mode 100644
index 00000000..11285822
--- /dev/null
+++ b/src/test/run-pass/yield2.rs
@@ -0,0 +1,10 @@
+// -*- rust -*-
+
+fn main() {
+  let int i = 0;
+  while (i < 100) {
+    i = i + 1;
+    log i;
+    yield;
+  }
+}