librustc: Remove `fail_unless!`

671 files changed, 1912 insertions, 1912 deletions

diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index 171a5319291..d6ebf4d346b 100644
--- a/src/test/bench/core-map.rs
+++ b/src/test/bench/core-map.rs
@@ -34,13 +34,13 @@ fn ascending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
 
     do timed("search") {
         for uint::range(0, n_keys) |i| {
-            fail_unless!(map.find(&i).unwrap() == &(i + 1));
+            assert!(map.find(&i).unwrap() == &(i + 1));
         }
     }
 
     do timed("remove") {
         for uint::range(0, n_keys) |i| {
-            fail_unless!(map.remove(&i));
+            assert!(map.remove(&i));
         }
     }
 }
@@ -56,13 +56,13 @@ fn descending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) {
 
     do timed("search") {
         for uint::range_rev(n_keys, 0) |i| {
-            fail_unless!(map.find(&i).unwrap() == &(i + 1));
+            assert!(map.find(&i).unwrap() == &(i + 1));
         }
     }
 
     do timed("remove") {
         for uint::range_rev(n_keys, 0) |i| {
-            fail_unless!(map.remove(&i));
+            assert!(map.remove(&i));
         }
     }
 }
@@ -77,13 +77,13 @@ fn vector<M: Map<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) {
 
     do timed("search") {
         for uint::range(0, n_keys) |i| {
-            fail_unless!(map.find(&dist[i]).unwrap() == &(i + 1));
+            assert!(map.find(&dist[i]).unwrap() == &(i + 1));
         }
     }
 
     do timed("remove") {
         for uint::range(0, n_keys) |i| {
-            fail_unless!(map.remove(&dist[i]));
+            assert!(map.remove(&dist[i]));
         }
     }
 }
diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs
index adfde66e57a..a3210108dcc 100644
--- a/src/test/bench/core-set.rs
+++ b/src/test/bench/core-set.rs
@@ -42,7 +42,7 @@ pub impl Results {
                 }
 
                 for uint::range(0, num_keys) |i| {
-                    fail_unless!(set.contains(&i));
+                    assert!(set.contains(&i));
                 }
             }
         }
@@ -64,7 +64,7 @@ pub impl Results {
 
             do timed(&mut self.delete_ints) {
                 for uint::range(0, num_keys) |i| {
-                    fail_unless!(set.remove(&i));
+                    assert!(set.remove(&i));
                 }
             }
         }
@@ -82,7 +82,7 @@ pub impl Results {
 
                 for uint::range(0, num_keys) |i| {
                     let s = uint::to_str(i);
-                    fail_unless!(set.contains(&s));
+                    assert!(set.contains(&s));
                 }
             }
         }
@@ -104,7 +104,7 @@ pub impl Results {
             }
             do timed(&mut self.delete_strings) {
                 for uint::range(0, num_keys) |i| {
-                    fail_unless!(set.remove(&uint::to_str(i)));
+                    assert!(set.remove(&uint::to_str(i)));
                 }
             }
         }
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 899b86b5cfb..a156f915fac 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -300,7 +300,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
             };
             result
         };
-        fail_unless!((colors.len() == old_len));
+        assert!((colors.len() == old_len));
     }
 
     // Convert the results.
@@ -468,7 +468,7 @@ fn main() {
 
             if do_validate {
                 let start = time::precise_time_s();
-                fail_unless!((validate(copy edges, *root, bfs_tree)));
+                assert!((validate(copy edges, *root, bfs_tree)));
                 let stop = time::precise_time_s();
 
                 io::stdout().write_line(
@@ -488,7 +488,7 @@ fn main() {
 
             if do_validate {
                 let start = time::precise_time_s();
-                fail_unless!((validate(copy edges, *root, bfs_tree)));
+                assert!((validate(copy edges, *root, bfs_tree)));
                 let stop = time::precise_time_s();
 
                 io::stdout().write_line(
@@ -508,7 +508,7 @@ fn main() {
 
         if do_validate {
             let start = time::precise_time_s();
-            fail_unless!((validate(copy edges, *root, bfs_tree)));
+            assert!((validate(copy edges, *root, bfs_tree)));
             let stop = time::precise_time_s();
 
             io::stdout().write_line(fmt!("Validation completed in %? seconds.",
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 5ae1f796304..50647e8c100 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -95,7 +95,7 @@ fn run(args: &[~str]) {
     io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed));
     let thruput = ((size / workers * workers) as float) / (elapsed as float);
     io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput));
-    fail_unless!(result == num_bytes * size);
+    assert!(result == num_bytes * size);
 }
 
 fn main() {
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index db1aaf9bcdb..77e64818f7e 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -92,7 +92,7 @@ fn run(args: &[~str]) {
     io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed));
     let thruput = ((size / workers * workers) as float) / (elapsed as float);
     io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput));
-    fail_unless!(result == num_bytes * size);
+    assert!(result == num_bytes * size);
 }
 
 fn main() {
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 77cd7890f29..a90afd418d8 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -73,7 +73,7 @@ fn stress_task(&&id: int) {
     let mut i = 0;
     loop {
         let n = 15;
-        fail_unless!((fib(n) == fib(n)));
+        assert!((fib(n) == fib(n)));
         i += 1;
         error!("%d: Completed %d iterations", id, i);
     }
diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs
index 930e3d8a608..4b0d34d2315 100644
--- a/src/test/bench/std-smallintmap.rs
+++ b/src/test/bench/std-smallintmap.rs
@@ -22,7 +22,7 @@ fn append_sequential(min: uint, max: uint, map: &mut SmallIntMap<uint>) {
 
 fn check_sequential(min: uint, max: uint, map: &SmallIntMap<uint>) {
     for uint::range(min, max) |i| {
-        fail_unless!(*map.get(&i) == i + 22u);
+        assert!(*map.get(&i) == i + 22u);
     }
 }
 
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 09c9e27d4db..9221da8b557 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -63,7 +63,7 @@ pub impl Sudoku {
     }
 
     pub fn read(reader: @io::Reader) -> Sudoku {
-        fail_unless!(reader.read_line() == ~"9,9"); /* assert first line is exactly "9,9" */
+        assert!(reader.read_line() == ~"9,9"); /* assert first line is exactly "9,9" */
 
         let mut g = vec::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] });
         while !reader.eof() {
@@ -212,30 +212,30 @@ static default_solution: [[u8, ..9], ..9] = [
 
 #[test]
 fn colors_new_works() {
-    fail_unless!(*Colors::new(1) == 1022u16);
-    fail_unless!(*Colors::new(2) == 1020u16);
-    fail_unless!(*Colors::new(3) == 1016u16);
-    fail_unless!(*Colors::new(4) == 1008u16);
-    fail_unless!(*Colors::new(5) == 992u16);
-    fail_unless!(*Colors::new(6) == 960u16);
-    fail_unless!(*Colors::new(7) == 896u16);
-    fail_unless!(*Colors::new(8) == 768u16);
-    fail_unless!(*Colors::new(9) == 512u16);
+    assert!(*Colors::new(1) == 1022u16);
+    assert!(*Colors::new(2) == 1020u16);
+    assert!(*Colors::new(3) == 1016u16);
+    assert!(*Colors::new(4) == 1008u16);
+    assert!(*Colors::new(5) == 992u16);
+    assert!(*Colors::new(6) == 960u16);
+    assert!(*Colors::new(7) == 896u16);
+    assert!(*Colors::new(8) == 768u16);
+    assert!(*Colors::new(9) == 512u16);
 }
 
 #[test]
 fn colors_next_works() {
-    fail_unless!(Colors(0).next() == 0u8);
-    fail_unless!(Colors(2).next() == 1u8);
-    fail_unless!(Colors(4).next() == 2u8);
-    fail_unless!(Colors(8).next() == 3u8);
-    fail_unless!(Colors(16).next() == 4u8);
-    fail_unless!(Colors(32).next() == 5u8);
-    fail_unless!(Colors(64).next() == 6u8);
-    fail_unless!(Colors(128).next() == 7u8);
-    fail_unless!(Colors(256).next() == 8u8);
-    fail_unless!(Colors(512).next() == 9u8);
-    fail_unless!(Colors(1024).next() == 0u8);
+    assert!(Colors(0).next() == 0u8);
+    assert!(Colors(2).next() == 1u8);
+    assert!(Colors(4).next() == 2u8);
+    assert!(Colors(8).next() == 3u8);
+    assert!(Colors(16).next() == 4u8);
+    assert!(Colors(32).next() == 5u8);
+    assert!(Colors(64).next() == 6u8);
+    assert!(Colors(128).next() == 7u8);
+    assert!(Colors(256).next() == 8u8);
+    assert!(Colors(512).next() == 9u8);
+    assert!(Colors(1024).next() == 0u8);
 }
 
 #[test]
@@ -247,7 +247,7 @@ fn colors_remove_works() {
     colors.remove(1);
 
     // THEN
-    fail_unless!(colors.next() == 2u8);
+    assert!(colors.next() == 2u8);
 }
 
 #[test]
@@ -260,7 +260,7 @@ fn check_default_sudoku_solution() {
     sudoku.solve();
 
     // THEN
-    fail_unless!(sudoku.equal(&solution));
+    assert!(sudoku.equal(&solution));
 }
 
 fn main() {
diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs
index 889a2836c0c..d7514320e36 100644
--- a/src/test/bench/task-perf-linked-failure.rs
+++ b/src/test/bench/task-perf-linked-failure.rs
@@ -51,7 +51,7 @@ fn spawn_supervised_blocking(myname: &str, +f: ~fn()) {
     task::task().future_result(|+r| res = Some(r)).supervised().spawn(f);
     error!("%s group waiting", myname);
     let x = res.unwrap().recv();
-    fail_unless!(x == task::Success);
+    assert!(x == task::Success);
 }
 
 fn main() {
@@ -81,5 +81,5 @@ fn main() {
         error!("Grandparent group wakes up and fails");
         fail!();
     };
-    fail_unless!(x.is_err());
+    assert!(x.is_err());
 }
diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
index 1e21af7b3f0..e2dd13a4405 100644
--- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
@@ -18,5 +18,5 @@ fn main() {
         //~^ ERROR cannot infer an appropriate lifetime
     }
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).read |state| { fail_unless!(*state == 1); }
+    // do (&option::unwrap(y)).read |state| { assert!(*state == 1); }
 }
diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
index b1375cc7980..78a50a4f212 100644
--- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
@@ -18,5 +18,5 @@ fn main() {
         y = Some(write_mode);
     }
     // Adding this line causes a method unification failure instead
-    // do (&option::unwrap(y)).write |state| { fail_unless!(*state == 1); }
+    // do (&option::unwrap(y)).write |state| { assert!(*state == 1); }
 }
diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs
index 000d03ea73c..ecd31d0dde4 100644
--- a/src/test/compile-fail/autoderef-full-lval.rs
+++ b/src/test/compile-fail/autoderef-full-lval.rs
@@ -22,10 +22,10 @@ fn main() {
     let b: clam = clam{x: @10, y: @20};
     let z: int = a.x + b.y; //~ ERROR binary operation + cannot be applied to type `@int`
     debug!(z);
-    fail_unless!((z == 21));
+    assert!((z == 21));
     let forty: fish = fish{a: @40};
     let two: fish = fish{a: @2};
     let answer: int = forty.a + two.a;  //~ ERROR binary operation + cannot be applied to type `@int`
     debug!(answer);
-    fail_unless!((answer == 42));
+    assert!((answer == 42));
 }
diff --git a/src/test/compile-fail/bind-by-move-no-guards.rs b/src/test/compile-fail/bind-by-move-no-guards.rs
index 4a90d2f4b7f..ffc160ac111 100644
--- a/src/test/compile-fail/bind-by-move-no-guards.rs
+++ b/src/test/compile-fail/bind-by-move-no-guards.rs
@@ -14,7 +14,7 @@ fn main() {
     c.send(false);
     match x {
         Some(z) if z.recv() => { fail!() }, //~ ERROR cannot bind by-move into a pattern guard
-        Some(z) => { fail_unless!(!z.recv()); },
+        Some(z) => { assert!(!z.recv()); },
         None => fail!()
     }
 }
diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
index b4b10db9398..42c5ffe3e91 100644
--- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs
+++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
@@ -19,5 +19,5 @@ fn compute1() -> float {
 fn main() {
     let x = compute1();
     debug!(x);
-    fail_unless!((x == -4f));
+    assert!((x == -4f));
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
index 332ec3fe697..14cb37d775c 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
@@ -16,8 +16,8 @@ fn box_imm() {
     let mut v = ~3;
     do borrow(v) |w| { //~ NOTE loan of mutable local variable granted here
         v = ~4; //~ ERROR assigning to captured outer mutable variable in a stack closure prohibited due to outstanding loan
-        fail_unless!(*v == 3);
-        fail_unless!(*w == 4);
+        assert!(*v == 3);
+        assert!(*w == 4);
     }
 }
 
diff --git a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
index b5c8f509167..aad86241e9a 100644
--- a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
+++ b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
@@ -16,5 +16,5 @@ fn destructure(x: Option<int>) -> int {
 }
 
 fn main() {
-    fail_unless!(destructure(Some(22)) == 22);
+    assert!(destructure(Some(22)) == 22);
 }
diff --git a/src/test/compile-fail/cast-from-nil.rs b/src/test/compile-fail/cast-from-nil.rs
index 1c2a3e17426..558a5478718 100644
--- a/src/test/compile-fail/cast-from-nil.rs
+++ b/src/test/compile-fail/cast-from-nil.rs
@@ -9,4 +9,4 @@
 // except according to those terms.
 
 // error-pattern: cast from nil: `()` as `u32`
-fn main() { let u = (fail_unless!(true) as u32); }
+fn main() { let u = (assert!(true) as u32); }
diff --git a/src/test/compile-fail/crateresolve5.rs b/src/test/compile-fail/crateresolve5.rs
index 96e88f99bcb..1ad190827da 100644
--- a/src/test/compile-fail/crateresolve5.rs
+++ b/src/test/compile-fail/crateresolve5.rs
@@ -18,5 +18,5 @@ extern mod cr5_2 (name = "crateresolve5", vers = "0.2");
 
 fn main() {
     // Nominal types from two multiple versions of a crate are different types
-    fail_unless!(cr5_1::nominal() == cr5_2::nominal()); //~ ERROR mismatched types: expected
+    assert!(cr5_1::nominal() == cr5_2::nominal()); //~ ERROR mismatched types: expected
 }
diff --git a/src/test/compile-fail/do2.rs b/src/test/compile-fail/do2.rs
index 89821f97513..4466c07518f 100644
--- a/src/test/compile-fail/do2.rs
+++ b/src/test/compile-fail/do2.rs
@@ -11,6 +11,6 @@
 fn f(f: @fn(int) -> bool) -> bool { f(10i) }
 
 fn main() {
-    fail_unless!(do f() |i| { i == 10i } == 10i);
+    assert!(do f() |i| { i == 10i } == 10i);
     //~^ ERROR: expected `bool` but found `int`
 }
diff --git a/src/test/compile-fail/issue-1896-1.rs b/src/test/compile-fail/issue-1896-1.rs
index e42382fc2aa..fc5132d6510 100644
--- a/src/test/compile-fail/issue-1896-1.rs
+++ b/src/test/compile-fail/issue-1896-1.rs
@@ -20,5 +20,5 @@ fn main () {
 
     let myInt: uint = (aFn.theFn)();
 
-    fail_unless!(myInt == 10);
+    assert!(myInt == 10);
 }
diff --git a/src/test/compile-fail/issue-2467.rs b/src/test/compile-fail/issue-2467.rs
index aec14e7b719..fd6e5a762b2 100644
--- a/src/test/compile-fail/issue-2467.rs
+++ b/src/test/compile-fail/issue-2467.rs
@@ -12,5 +12,5 @@ enum test { thing = 3u } //~ ERROR mismatched types
 //~^ ERROR expected signed integer constant
 fn main() {
     error!(thing as int);
-    fail_unless!((thing as int == 3));
+    assert!((thing as int == 3));
 }
diff --git a/src/test/compile-fail/issue-2548.rs b/src/test/compile-fail/issue-2548.rs
index f8f973dbc6b..9c2d7baa23c 100644
--- a/src/test/compile-fail/issue-2548.rs
+++ b/src/test/compile-fail/issue-2548.rs
@@ -38,8 +38,8 @@ fn main() {
 
         let mut v = ~[];
         v = ~[(res)] + v; //~ instantiating a type parameter with an incompatible type `foo`, which does not fulfill `Copy`
-        fail_unless!((v.len() == 2));
+        assert!((v.len() == 2));
     }
 
-    fail_unless!(*x == 1);
+    assert!(*x == 1);
 }
diff --git a/src/test/compile-fail/issue-2969.rs b/src/test/compile-fail/issue-2969.rs
index 5e6fa6e95f8..927e81db5c1 100644
--- a/src/test/compile-fail/issue-2969.rs
+++ b/src/test/compile-fail/issue-2969.rs
@@ -15,5 +15,5 @@ fn main()
    let mut x = [1, 2, 4];
    let v : &int = &x[2];
    x[2] = 6;
-   fail_unless!(*v == 6);
+   assert!(*v == 6);
 }
diff --git a/src/test/compile-fail/issue-3888.rs b/src/test/compile-fail/issue-3888.rs
index d9ea384d820..35f8557c32b 100644
--- a/src/test/compile-fail/issue-3888.rs
+++ b/src/test/compile-fail/issue-3888.rs
@@ -25,17 +25,17 @@ fn vec_peek<'r, T>(v: &'r [T]) -> Option< (&'r T, &'r [T]) > {
 
 fn test_peek_empty_stack() {
     let v : &[int] = &[];
-    fail_unless!((None == vec_peek(v)));
+    assert!((None == vec_peek(v)));
 }
 
 fn test_peek_empty_unique() {
     let v : ~[int] = ~[];
-    fail_unless!((None == vec_peek(v)));
+    assert!((None == vec_peek(v)));
 }
 
 fn test_peek_empty_managed() {
     let v : @[int] = @[];
-    fail_unless!((None == vec_peek(v)));
+    assert!((None == vec_peek(v)));
 }
 
 
diff --git a/src/test/compile-fail/issue-511.rs b/src/test/compile-fail/issue-511.rs
index 632b15dadd4..90c46e5d602 100644
--- a/src/test/compile-fail/issue-511.rs
+++ b/src/test/compile-fail/issue-511.rs
@@ -12,7 +12,7 @@ extern mod std;
 use core::cmp::Eq;
 
 fn f<T:Eq>(o: &mut Option<T>) {
-    fail_unless!(*o == option::None);
+    assert!(*o == option::None);
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-818.rs b/src/test/compile-fail/issue-818.rs
index 0de7276fc8c..df08652ea0a 100644
--- a/src/test/compile-fail/issue-818.rs
+++ b/src/test/compile-fail/issue-818.rs
@@ -20,5 +20,5 @@ mod ctr {
 fn main() {
     let c = ctr::new(42);
     let c2 = ctr::inc(c);
-    fail_unless!(*c2 == 5); //~ ERROR can only dereference enums with a single, public variant
+    assert!(*c2 == 5); //~ ERROR can only dereference enums with a single, public variant
 }
diff --git a/src/test/compile-fail/kindck-owned-trait-contains.rs b/src/test/compile-fail/kindck-owned-trait-contains.rs
index dadc66b5029..f5153265308 100644
--- a/src/test/compile-fail/kindck-owned-trait-contains.rs
+++ b/src/test/compile-fail/kindck-owned-trait-contains.rs
@@ -27,5 +27,5 @@ fn main() {
         let x: &'blk int = &3;
         repeater(@x)
     };
-    fail_unless!(3 == *(y.get())); //~ ERROR reference is not valid
+    assert!(3 == *(y.get())); //~ ERROR reference is not valid
 }
diff --git a/src/test/compile-fail/kindck-owned-trait-scoped.rs b/src/test/compile-fail/kindck-owned-trait-scoped.rs
index 34ceb67f243..bb0ba87c098 100644
--- a/src/test/compile-fail/kindck-owned-trait-scoped.rs
+++ b/src/test/compile-fail/kindck-owned-trait-scoped.rs
@@ -30,7 +30,7 @@ fn to_foo<T:Copy>(t: T) {
     let v = &3;
     struct F<T> { f: T }
     let x = @F {f:t} as @foo;
-    fail_unless!(x.foo(v) == 3);
+    assert!(x.foo(v) == 3);
 }
 
 fn to_foo_2<T:Copy>(t: T) -> @foo {
diff --git a/src/test/compile-fail/mod_file_correct_spans.rs b/src/test/compile-fail/mod_file_correct_spans.rs
index 832e6d8a6a7..f8ea5dda183 100644
--- a/src/test/compile-fail/mod_file_correct_spans.rs
+++ b/src/test/compile-fail/mod_file_correct_spans.rs
@@ -13,5 +13,5 @@
 mod mod_file_aux;
 
 fn main() {
-    fail_unless!(mod_file_aux::bar() == 10); //~ ERROR unresolved name
+    assert!(mod_file_aux::bar() == 10); //~ ERROR unresolved name
 }
diff --git a/src/test/compile-fail/mod_file_not_exist.rs b/src/test/compile-fail/mod_file_not_exist.rs
index d742ad04d76..17ca8dca273 100644
--- a/src/test/compile-fail/mod_file_not_exist.rs
+++ b/src/test/compile-fail/mod_file_not_exist.rs
@@ -11,5 +11,5 @@
 mod not_a_real_file; //~ ERROR not_a_real_file.rs
 
 fn main() {
-    fail_unless!(mod_file_aux::bar() == 10);
+    assert!(mod_file_aux::bar() == 10);
 }
diff --git a/src/test/compile-fail/mod_file_with_path_attr.rs b/src/test/compile-fail/mod_file_with_path_attr.rs
index 2f71f4d22f9..827c77bda47 100644
--- a/src/test/compile-fail/mod_file_with_path_attr.rs
+++ b/src/test/compile-fail/mod_file_with_path_attr.rs
@@ -12,5 +12,5 @@
 mod m; //~ ERROR not_a_real_file.rs
 
 fn main() {
-    fail_unless!(m::foo() == 10);
+    assert!(m::foo() == 10);
 }
diff --git a/src/test/compile-fail/mode-inference-fail.rs b/src/test/compile-fail/mode-inference-fail.rs
index d9f6cf8b2d7..4994bb323d9 100644
--- a/src/test/compile-fail/mode-inference-fail.rs
+++ b/src/test/compile-fail/mode-inference-fail.rs
@@ -18,6 +18,6 @@ fn apply_int(f: &fn(int) -> int, a: int) -> int { f(a) }
 
 fn main() {
     let f = {|i| i};
-    fail_unless!(apply_int(f, 2) == 2);
-    fail_unless!(apply(f, 2) == 2); //~ ERROR expected argument mode &&
+    assert!(apply_int(f, 2) == 2);
+    assert!(apply(f, 2) == 2); //~ ERROR expected argument mode &&
 }
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 5e17b168d55..da75dfd0106 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -19,10 +19,10 @@ fn main() {
     
     do task::spawn() {
         let v = *arc::get(&arc_v);
-        fail_unless!(v[3] == 4);
+        assert!(v[3] == 4);
     };
 
-    fail_unless!((*arc::get(&arc_v))[2] == 3);
+    assert!((*arc::get(&arc_v))[2] == 3);
 
     info!(arc_v);
 }
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index 90faec802a4..75cd706985c 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -17,10 +17,10 @@ fn main() {
 
     do task::spawn() { //~ NOTE `arc_v` moved into closure environment here
         let v = *arc::get(&arc_v);
-        fail_unless!(v[3] == 4);
+        assert!(v[3] == 4);
     };
 
-    fail_unless!((*arc::get(&arc_v))[2] == 3); //~ ERROR use of moved value: `arc_v`
+    assert!((*arc::get(&arc_v))[2] == 3); //~ ERROR use of moved value: `arc_v`
 
     info!(arc_v);
 }
diff --git a/src/test/compile-fail/noncopyable-match-pattern.rs b/src/test/compile-fail/noncopyable-match-pattern.rs
index 0623f93a38b..e8b01765a44 100644
--- a/src/test/compile-fail/noncopyable-match-pattern.rs
+++ b/src/test/compile-fail/noncopyable-match-pattern.rs
@@ -12,7 +12,7 @@ fn main() {
     let x = Some(unstable::exclusive(false));
     match x {
         Some(copy z) => { //~ ERROR copying a value of non-copyable type
-            do z.with |b| { fail_unless!(!*b); }
+            do z.with |b| { assert!(!*b); }
         }
         None => fail!()
     }
diff --git a/src/test/compile-fail/omitted-arg-wrong-types.rs b/src/test/compile-fail/omitted-arg-wrong-types.rs
index 0ab53da0c4a..a44c113269b 100644
--- a/src/test/compile-fail/omitted-arg-wrong-types.rs
+++ b/src/test/compile-fail/omitted-arg-wrong-types.rs
@@ -12,9 +12,9 @@
 fn let_in<T>(x: T, f: &fn(T)) {}
 
 fn main() {
-    let_in(3u, |i| { fail_unless!(i == 3); });
+    let_in(3u, |i| { assert!(i == 3); });
     //~^ ERROR expected `uint` but found `int`
 
-    let_in(3, |i| { fail_unless!(i == 3u); });
+    let_in(3, |i| { assert!(i == 3u); });
     //~^ ERROR expected `int` but found `uint`
 }
diff --git a/src/test/compile-fail/private-struct-field-cross-crate.rs b/src/test/compile-fail/private-struct-field-cross-crate.rs
index 1df102a751a..5a8f80845e1 100644
--- a/src/test/compile-fail/private-struct-field-cross-crate.rs
+++ b/src/test/compile-fail/private-struct-field-cross-crate.rs
@@ -14,5 +14,5 @@ use cci_class::kitties::*;
 
 fn main() {
   let nyan : cat = cat(52u, 99);
-  fail_unless!((nyan.meows == 52u));   //~ ERROR field `meows` is private
+  assert!((nyan.meows == 52u));   //~ ERROR field `meows` is private
 }
diff --git a/src/test/compile-fail/private-struct-field.rs b/src/test/compile-fail/private-struct-field.rs
index 86a14587006..2f6a51e1637 100644
--- a/src/test/compile-fail/private-struct-field.rs
+++ b/src/test/compile-fail/private-struct-field.rs
@@ -20,5 +20,5 @@ mod cat {
 
 fn main() {
     let nyan = cat::new_cat();
-    fail_unless!(nyan.meows == 52);    //~ ERROR field `meows` is private
+    assert!(nyan.meows == 52);    //~ ERROR field `meows` is private
 }
diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs
index 1ae97d690ac..9a4974849a5 100644
--- a/src/test/compile-fail/regions-glb-free-free.rs
+++ b/src/test/compile-fail/regions-glb-free-free.rs
@@ -37,5 +37,5 @@ mod argparse {
 fn main () {
     let f : argparse::Flag = argparse::flag(~"flag", ~"My flag");
     let updated_flag = f.set_desc(~"My new flag");
-    fail_unless!(updated_flag.desc == "My new flag");
+    assert!(updated_flag.desc == "My new flag");
 }
diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
index 7e96ecd4142..a8b7ae1b9c8 100644
--- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
+++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
@@ -19,7 +19,7 @@ fn x_coord<'r>(p: &'r point) -> &'r int {
 
 fn foo(p: @point) -> &int {
     let xc = x_coord(p); //~ ERROR illegal borrow
-    fail_unless!(*xc == 3);
+    assert!(*xc == 3);
     return xc;
 }
 
diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
index d982d3c95a5..bf8f227b573 100644
--- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
+++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
@@ -19,10 +19,10 @@ fn foo(cond: &fn() -> bool, box: &fn() -> @int) {
 	// of this borrow is the fn body as a whole.
         y = borrow(x); //~ ERROR illegal borrow: cannot root managed value long enough
 
-        fail_unless!(*x == *y);
+        assert!(*x == *y);
         if cond() { break; }
     }
-    fail_unless!(*y != 0);
+    assert!(*y != 0);
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs
index 2f455e89dff..ff75ba4473d 100644
--- a/src/test/compile-fail/regions-trait-1.rs
+++ b/src/test/compile-fail/regions-trait-1.rs
@@ -34,5 +34,5 @@ fn get_v(gc: @get_ctxt) -> uint {
 fn main() {
     let ctxt = ctxt { v: 22u };
     let hc = has_ctxt { c: &ctxt };
-    fail_unless!(get_v(@hc as @get_ctxt) == 22u);
+    assert!(get_v(@hc as @get_ctxt) == 22u);
 }
diff --git a/src/test/compile-fail/regions-var-type-out-of-scope.rs b/src/test/compile-fail/regions-var-type-out-of-scope.rs
index cd395fe4dd1..7d75ac74349 100644
--- a/src/test/compile-fail/regions-var-type-out-of-scope.rs
+++ b/src/test/compile-fail/regions-var-type-out-of-scope.rs
@@ -15,7 +15,7 @@ fn foo(cond: bool) {
 
     if cond {
         x = &3; //~ ERROR illegal borrow: borrowed value does not live long enough
-        fail_unless!((*x == 3));
+        assert!((*x == 3));
     }
 }
 
diff --git a/src/test/compile-fail/tag-type-args.rs b/src/test/compile-fail/tag-type-args.rs
index b13835a89d4..f2ef1d19525 100644
--- a/src/test/compile-fail/tag-type-args.rs
+++ b/src/test/compile-fail/tag-type-args.rs
@@ -12,6 +12,6 @@
 
 enum quux<T> { bar }
 
-fn foo(c: quux) { fail_unless!((false)); }
+fn foo(c: quux) { assert!((false)); }
 
 fn main() { fail!(); }
diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs
index fab31f88e54..dd0ae87f311 100644
--- a/src/test/compile-fail/vtable-res-trait-param.rs
+++ b/src/test/compile-fail/vtable-res-trait-param.rs
@@ -29,5 +29,5 @@ fn call_it<B:TraitB>(b: B)  -> int {
 
 fn main() {
     let x = 3i;
-    fail_unless!(call_it(x) == 22);
+    assert!(call_it(x) == 22);
 }
diff --git a/src/test/pretty/do1.rs b/src/test/pretty/do1.rs
index 950d7b37aa2..6f9aa28f11a 100644
--- a/src/test/pretty/do1.rs
+++ b/src/test/pretty/do1.rs
@@ -12,4 +12,4 @@
 
 fn f(f: @fn(int)) { f(10) }
 
-fn main() { do f |i| { fail_unless!(i == 10) } }
+fn main() { do f |i| { assert!(i == 10) } }
diff --git a/src/test/pretty/record-trailing-comma.rs b/src/test/pretty/record-trailing-comma.rs
index fc80c75e532..1ea0e104132 100644
--- a/src/test/pretty/record-trailing-comma.rs
+++ b/src/test/pretty/record-trailing-comma.rs
@@ -18,5 +18,5 @@ struct Thing {
 fn main() {
     let sth = Thing{x: 0, y: 1,};
     let sth2 = Thing{y: 9 , ..sth};
-    fail_unless!(sth.x + sth2.y == 9);
+    assert!(sth.x + sth2.y == 9);
 }
diff --git a/src/test/run-fail/assert-as-macro.rs b/src/test/run-fail/assert-as-macro.rs
index 8bb1e278fd1..07813b91e57 100644
--- a/src/test/run-fail/assert-as-macro.rs
+++ b/src/test/run-fail/assert-as-macro.rs
@@ -1,6 +1,6 @@
 // error-pattern:assertion failed: 1 == 2
 
 fn main() {
-    fail_unless!(1 == 2);
+    assert!(1 == 2);
 }
 
diff --git a/src/test/run-fail/fail.rs b/src/test/run-fail/fail.rs
index 23207dcf437..42cf79af66e 100644
--- a/src/test/run-fail/fail.rs
+++ b/src/test/run-fail/fail.rs
@@ -12,4 +12,4 @@
 
 
 // error-pattern:1 == 2
-fn main() { fail_unless!((1 == 2)); }
+fn main() { assert!((1 == 2)); }
diff --git a/src/test/run-fail/issue-2761.rs b/src/test/run-fail/issue-2761.rs
index cf35d9624f3..95050a4dcf1 100644
--- a/src/test/run-fail/issue-2761.rs
+++ b/src/test/run-fail/issue-2761.rs
@@ -11,5 +11,5 @@
 // error-pattern:custom message
 
 fn main() {
-    fail_unless!(false, "custom message");
+    assert!(false, "custom message");
 }
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 458ec11c674..054d6f697ae 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -13,7 +13,7 @@
 // error-pattern:1 == 2
 extern mod std;
 
-fn child() { fail_unless!((1 == 2)); }
+fn child() { assert!((1 == 2)); }
 
 fn main() {
     let (p, _c) = comm::stream::<int>();
diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index 1955a29058f..3dc87e190a5 100644
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -11,7 +11,7 @@
 
 // error-pattern:1 == 2
 
-fn child() { fail_unless!((1 == 2)); }
+fn child() { assert!((1 == 2)); }
 
 fn parent() {
     let (p, _c) = comm::stream::<int>();
diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs
index f7ece96fd6e..38b73ea5698 100644
--- a/src/test/run-fail/str-overrun.rs
+++ b/src/test/run-fail/str-overrun.rs
@@ -15,5 +15,5 @@ fn main() {
     let s: ~str = ~"hello";
 
     // Bounds-check failure.
-    fail_unless!((s[5] == 0x0 as u8));
+    assert!((s[5] == 0x0 as u8));
 }
diff --git a/src/test/run-fail/task-spawn-barefn.rs b/src/test/run-fail/task-spawn-barefn.rs
index 17838348b82..11c9de6e14f 100644
--- a/src/test/run-fail/task-spawn-barefn.rs
+++ b/src/test/run-fail/task-spawn-barefn.rs
@@ -17,5 +17,5 @@ fn main() {
 }
 
 fn startfn() {
-    fail_unless!(str::is_empty(~"Ensure that the child task runs by failing"));
+    assert!(str::is_empty(~"Ensure that the child task runs by failing"));
 }
diff --git a/src/test/run-fail/unwind-alt.rs b/src/test/run-fail/unwind-alt.rs
index 035afa781de..41cf92d92b8 100644
--- a/src/test/run-fail/unwind-alt.rs
+++ b/src/test/run-fail/unwind-alt.rs
@@ -16,7 +16,7 @@ fn test_box() {
 fn test_str() {
   let res = match false { true => { ~"happy" },
      _ => fail!(~"non-exhaustive match failure") };
-  fail_unless!(res == ~"happy");
+  assert!(res == ~"happy");
 }
 fn main() {
     test_box();
diff --git a/src/test/run-fail/unwind-assert.rs b/src/test/run-fail/unwind-assert.rs
index 1d5397e7d38..0e685a7a469 100644
--- a/src/test/run-fail/unwind-assert.rs
+++ b/src/test/run-fail/unwind-assert.rs
@@ -12,5 +12,5 @@
 
 fn main() {
     let a = @0;
-    fail_unless!(false);
+    assert!(false);
 }
diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs
index 46176425249..ab9dcf32781 100644
--- a/src/test/run-fail/vec-overrun.rs
+++ b/src/test/run-fail/vec-overrun.rs
@@ -14,8 +14,8 @@
 fn main() {
     let v: ~[int] = ~[10];
     let x: int = 0;
-    fail_unless!((v[x] == 10));
+    assert!((v[x] == 10));
     // Bounds-check failure.
 
-    fail_unless!((v[x + 2] == 20));
+    assert!((v[x + 2] == 20));
 }
diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs
index c01dbf03455..6f403fd7721 100644
--- a/src/test/run-fail/vec-underrun.rs
+++ b/src/test/run-fail/vec-underrun.rs
@@ -14,8 +14,8 @@
 fn main() {
     let v: ~[int] = ~[10, 20];
     let x: int = 0;
-    fail_unless!((v[x] == 10));
+    assert!((v[x] == 10));
     // Bounds-check failure.
 
-    fail_unless!((v[x - 1] == 20));
+    assert!((v[x - 1] == 20));
 }
diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs
index 5eae7fca821..87bb8669046 100644
--- a/src/test/run-fail/zip-different-lengths.rs
+++ b/src/test/run-fail/zip-different-lengths.rs
@@ -15,7 +15,7 @@ extern mod std;
 use core::vec::{same_length, zip};
 
 fn enum_chars(start: u8, end: u8) -> ~[char] {
-    fail_unless!(start < end);
+    assert!(start < end);
     let mut i = start;
     let mut r = ~[];
     while i <= end { r.push(i as char); i += 1 as u8; }
@@ -23,7 +23,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
 }
 
 fn enum_uints(start: uint, end: uint) -> ~[uint] {
-    fail_unless!(start < end);
+    assert!(start < end);
     let mut i = start;
     let mut r = ~[];
     while i <= end { r.push(i); i += 1; }
@@ -35,7 +35,7 @@ fn main() {
     let chars = enum_chars(a, j);
     let ints = enum_uints(k, l);
 
-    fail_unless!(same_length(chars, ints));
+    assert!(same_length(chars, ints));
     let ps = zip(chars, ints);
     fail!(~"the impossible happened");
 }
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 779fd3e4904..9c7caebc2eb 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -84,7 +84,7 @@ fn check_pp<T>(cx: fake_ext_ctxt,
     stdout().write_line(s);
     if expect != ~"" {
         error!("expect: '%s', got: '%s'", expect, s);
-        fail_unless!(s == expect);
+        assert!(s == expect);
     }
 }
 
diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs
index f9ba6ed7f54..e3a544af309 100644
--- a/src/test/run-pass/alignment-gep-tup-like-1.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-1.rs
@@ -20,6 +20,6 @@ fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) {
 pub fn main() {
     let (a, b) = f(22_u64, 44u16)();
     debug!("a=%? b=%?", a, b);
-    fail_unless!(a == 22u64);
-    fail_unless!(b == 44u16);
+    assert!(a == 22u64);
+    assert!(b == 44u16);
 }
diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs
index 22855bce28f..847e6fce8ee 100644
--- a/src/test/run-pass/alignment-gep-tup-like-2.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-2.rs
@@ -35,6 +35,6 @@ pub fn main() {
     make_cycle(z);
     let (a, b) = z();
     debug!("a=%u b=%u", *a as uint, b as uint);
-    fail_unless!(*a == x);
-    fail_unless!(b == y);
+    assert!(*a == x);
+    assert!(b == y);
 }
diff --git a/src/test/run-pass/alt-implicit-copy-unique.rs b/src/test/run-pass/alt-implicit-copy-unique.rs
index c00b185d131..0497f11202f 100644
--- a/src/test/run-pass/alt-implicit-copy-unique.rs
+++ b/src/test/run-pass/alt-implicit-copy-unique.rs
@@ -14,7 +14,7 @@ pub fn main() {
     let mut x = ~Pair {a: ~10, b: ~20};
     match x {
       ~Pair {a: ref mut a, b: ref mut b} => {
-        fail_unless!(**a == 10); *a = ~30; fail_unless!(**a == 30);
+        assert!(**a == 10); *a = ~30; assert!(**a == 30);
       }
     }
 }
diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs
index 131869a0c4e..8e71d8d4a67 100644
--- a/src/test/run-pass/alt-pattern-drop.rs
+++ b/src/test/run-pass/alt-pattern-drop.rs
@@ -25,7 +25,7 @@ fn foo(s: @int) {
       _ => { debug!("?"); fail!(); }
     }
     debug!(::core::sys::refcount(s));
-    fail_unless!((::core::sys::refcount(s) == count + 1u));
+    assert!((::core::sys::refcount(s) == count + 1u));
     let _ = ::core::sys::refcount(s); // don't get bitten by last-use.
 }
 
@@ -39,5 +39,5 @@ pub fn main() {
     debug!("%u", ::core::sys::refcount(s));
     let count2 = ::core::sys::refcount(s);
     let _ = ::core::sys::refcount(s); // don't get bitten by last-use.
-    fail_unless!(count == count2);
+    assert!(count == count2);
 }
diff --git a/src/test/run-pass/alt-pattern-lit.rs b/src/test/run-pass/alt-pattern-lit.rs
index 37f924dd1be..d6a8afbc4e7 100644
--- a/src/test/run-pass/alt-pattern-lit.rs
+++ b/src/test/run-pass/alt-pattern-lit.rs
@@ -18,4 +18,4 @@ fn altlit(f: int) -> int {
     }
 }
 
-pub fn main() { fail_unless!((altlit(10) == 20)); fail_unless!((altlit(11) == 22)); }
+pub fn main() { assert!((altlit(10) == 20)); assert!((altlit(11) == 22)); }
diff --git a/src/test/run-pass/alt-ref-binding-in-guard-3256.rs b/src/test/run-pass/alt-ref-binding-in-guard-3256.rs
index ece2943a1c1..1ece3b5fd93 100644
--- a/src/test/run-pass/alt-ref-binding-in-guard-3256.rs
+++ b/src/test/run-pass/alt-ref-binding-in-guard-3256.rs
@@ -12,7 +12,7 @@ pub fn main() {
     let x = Some(unstable::exclusive(true));
     match x {
         Some(ref z) if z.with(|b| *b) => {
-            do z.with |b| { fail_unless!(*b); }
+            do z.with |b| { assert!(*b); }
         },
         _ => fail!()
     }
diff --git a/src/test/run-pass/alt-ref-binding-mut-option.rs b/src/test/run-pass/alt-ref-binding-mut-option.rs
index f6c5e64b353..9ef414d1170 100644
--- a/src/test/run-pass/alt-ref-binding-mut-option.rs
+++ b/src/test/run-pass/alt-ref-binding-mut-option.rs
@@ -14,5 +14,5 @@ pub fn main() {
       None => {}
       Some(ref mut p) => { *p += 1; }
     }
-    fail_unless!(v == Some(23));
+    assert!(v == Some(23));
 }
diff --git a/src/test/run-pass/alt-ref-binding-mut.rs b/src/test/run-pass/alt-ref-binding-mut.rs
index c8b1822e5fa..2bd55b46784 100644
--- a/src/test/run-pass/alt-ref-binding-mut.rs
+++ b/src/test/run-pass/alt-ref-binding-mut.rs
@@ -21,5 +21,5 @@ fn destructure(x: &mut Rec) {
 pub fn main() {
     let mut v = Rec {f: 22};
     destructure(&mut v);
-    fail_unless!(v.f == 23);
+    assert!(v.f == 23);
 }
diff --git a/src/test/run-pass/alt-ref-binding.rs b/src/test/run-pass/alt-ref-binding.rs
index 8b25d329b9a..23b3062a83a 100644
--- a/src/test/run-pass/alt-ref-binding.rs
+++ b/src/test/run-pass/alt-ref-binding.rs
@@ -16,5 +16,5 @@ fn destructure(x: Option<int>) -> int {
 }
 
 pub fn main() {
-    fail_unless!(destructure(Some(22)) == 22);
+    assert!(destructure(Some(22)) == 22);
 }
diff --git a/src/test/run-pass/alt-str.rs b/src/test/run-pass/alt-str.rs
index 4a362ca8e87..e41ec8a99e9 100644
--- a/src/test/run-pass/alt-str.rs
+++ b/src/test/run-pass/alt-str.rs
@@ -24,7 +24,7 @@ pub fn main() {
     }
 
     let x = match ~"a" { ~"a" => 1, ~"b" => 2, _ => fail!() };
-    fail_unless!((x == 1));
+    assert!((x == 1));
 
     match ~"a" { ~"a" => { } ~"b" => { }, _ => fail!() }
 
diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs
index 8051a14dac8..e2e1bf540c2 100644
--- a/src/test/run-pass/alt-tag.rs
+++ b/src/test/run-pass/alt-tag.rs
@@ -32,7 +32,7 @@ pub fn main() {
     let gray: color = rgb(127, 127, 127);
     let clear: color = rgba(50, 150, 250, 0);
     let red: color = hsl(0, 255, 255);
-    fail_unless!((process(gray) == 127));
-    fail_unless!((process(clear) == 0));
-    fail_unless!((process(red) == 255));
+    assert!((process(gray) == 127));
+    assert!((process(clear) == 0));
+    assert!((process(red) == 255));
 }
diff --git a/src/test/run-pass/alt-unique-bind.rs b/src/test/run-pass/alt-unique-bind.rs
index 6412cc7ffd5..2fb0a345157 100644
--- a/src/test/run-pass/alt-unique-bind.rs
+++ b/src/test/run-pass/alt-unique-bind.rs
@@ -12,7 +12,7 @@ pub fn main() {
     match ~100 {
       ~x => {
         debug!("%?", x);
-        fail_unless!(x == 100);
+        assert!(x == 100);
       }
     }
 }
diff --git a/src/test/run-pass/alt-with-ret-arm.rs b/src/test/run-pass/alt-with-ret-arm.rs
index ad4d87fb87c..d5d2e20cba3 100644
--- a/src/test/run-pass/alt-with-ret-arm.rs
+++ b/src/test/run-pass/alt-with-ret-arm.rs
@@ -16,6 +16,6 @@ pub fn main() {
         None => return (),
         Some(num) => num as u32
     };
-    fail_unless!(f == 1234u32);
+    assert!(f == 1234u32);
     error!(f)
 }
diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs
index 11f988bc296..d61c1214633 100644
--- a/src/test/run-pass/argument-passing.rs
+++ b/src/test/run-pass/argument-passing.rs
@@ -23,9 +23,9 @@ fn f2(a: int, f: &fn(int)) -> int { f(1); return a; }
 
 pub fn main() {
     let mut a = X {x: 1}, b = 2, c = 3;
-    fail_unless!((f1(&mut a, &mut b, c) == 6));
-    fail_unless!((a.x == 0));
-    fail_unless!((b == 10));
-    fail_unless!((f2(a.x, |x| a.x = 50) == 0));
-    fail_unless!((a.x == 50));
+    assert!((f1(&mut a, &mut b, c) == 6));
+    assert!((a.x == 0));
+    assert!((b == 10));
+    assert!((f2(a.x, |x| a.x = 50) == 0));
+    assert!((a.x == 50));
 }
diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs
index adfc1033d97..a0512ffff2a 100644
--- a/src/test/run-pass/arith-0.rs
+++ b/src/test/run-pass/arith-0.rs
@@ -13,5 +13,5 @@
 pub fn main() {
     let a: int = 10;
     debug!(a);
-    fail_unless!((a * (a - 1) == 90));
+    assert!((a * (a - 1) == 90));
 }
diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs
index 1b98cf4dc5c..c0db96f99c7 100644
--- a/src/test/run-pass/arith-1.rs
+++ b/src/test/run-pass/arith-1.rs
@@ -12,22 +12,22 @@
 
 pub fn main() {
     let i32_a: int = 10;
-    fail_unless!((i32_a == 10));
-    fail_unless!((i32_a - 10 == 0));
-    fail_unless!((i32_a / 10 == 1));
-    fail_unless!((i32_a - 20 == -10));
-    fail_unless!((i32_a << 10 == 10240));
-    fail_unless!((i32_a << 16 == 655360));
-    fail_unless!((i32_a * 16 == 160));
-    fail_unless!((i32_a * i32_a * i32_a == 1000));
-    fail_unless!((i32_a * i32_a * i32_a * i32_a == 10000));
-    fail_unless!((i32_a * i32_a / i32_a * i32_a == 100));
-    fail_unless!((i32_a * (i32_a - 1) << 2 + i32_a == 368640));
+    assert!((i32_a == 10));
+    assert!((i32_a - 10 == 0));
+    assert!((i32_a / 10 == 1));
+    assert!((i32_a - 20 == -10));
+    assert!((i32_a << 10 == 10240));
+    assert!((i32_a << 16 == 655360));
+    assert!((i32_a * 16 == 160));
+    assert!((i32_a * i32_a * i32_a == 1000));
+    assert!((i32_a * i32_a * i32_a * i32_a == 10000));
+    assert!((i32_a * i32_a / i32_a * i32_a == 100));
+    assert!((i32_a * (i32_a - 1) << 2 + i32_a == 368640));
     let i32_b: int = 0x10101010;
-    fail_unless!((i32_b + 1 - 1 == i32_b));
-    fail_unless!((i32_b << 1 == i32_b << 1));
-    fail_unless!((i32_b >> 1 == i32_b >> 1));
-    fail_unless!((i32_b & i32_b << 1 == 0));
+    assert!((i32_b + 1 - 1 == i32_b));
+    assert!((i32_b << 1 == i32_b << 1));
+    assert!((i32_b >> 1 == i32_b >> 1));
+    assert!((i32_b & i32_b << 1 == 0));
     debug!(i32_b | i32_b << 1);
-    fail_unless!((i32_b | i32_b << 1 == 0x30303030));
+    assert!((i32_b | i32_b << 1 == 0x30303030));
 }
diff --git a/src/test/run-pass/arith-2.rs b/src/test/run-pass/arith-2.rs
index 3ca889428d7..70df6e46e59 100644
--- a/src/test/run-pass/arith-2.rs
+++ b/src/test/run-pass/arith-2.rs
@@ -12,6 +12,6 @@
 
 pub fn main() {
     let i32_c: int = 0x10101010;
-    fail_unless!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
+    assert!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
                  i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3));
 }
diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs
index 45bd35a68af..a921d9f7ddc 100644
--- a/src/test/run-pass/arith-unsigned.rs
+++ b/src/test/run-pass/arith-unsigned.rs
@@ -13,24 +13,24 @@
 
 // Unsigned integer operations
 pub fn main() {
-    fail_unless!((0u8 < 255u8));
-    fail_unless!((0u8 <= 255u8));
-    fail_unless!((255u8 > 0u8));
-    fail_unless!((255u8 >= 0u8));
-    fail_unless!((250u8 / 10u8 == 25u8));
-    fail_unless!((255u8 % 10u8 == 5u8));
-    fail_unless!((0u16 < 60000u16));
-    fail_unless!((0u16 <= 60000u16));
-    fail_unless!((60000u16 > 0u16));
-    fail_unless!((60000u16 >= 0u16));
-    fail_unless!((60000u16 / 10u16 == 6000u16));
-    fail_unless!((60005u16 % 10u16 == 5u16));
-    fail_unless!((0u32 < 4000000000u32));
-    fail_unless!((0u32 <= 4000000000u32));
-    fail_unless!((4000000000u32 > 0u32));
-    fail_unless!((4000000000u32 >= 0u32));
-    fail_unless!((4000000000u32 / 10u32 == 400000000u32));
-    fail_unless!((4000000005u32 % 10u32 == 5u32));
+    assert!((0u8 < 255u8));
+    assert!((0u8 <= 255u8));
+    assert!((255u8 > 0u8));
+    assert!((255u8 >= 0u8));
+    assert!((250u8 / 10u8 == 25u8));
+    assert!((255u8 % 10u8 == 5u8));
+    assert!((0u16 < 60000u16));
+    assert!((0u16 <= 60000u16));
+    assert!((60000u16 > 0u16));
+    assert!((60000u16 >= 0u16));
+    assert!((60000u16 / 10u16 == 6000u16));
+    assert!((60005u16 % 10u16 == 5u16));
+    assert!((0u32 < 4000000000u32));
+    assert!((0u32 <= 4000000000u32));
+    assert!((4000000000u32 > 0u32));
+    assert!((4000000000u32 >= 0u32));
+    assert!((4000000000u32 / 10u32 == 400000000u32));
+    assert!((4000000005u32 % 10u32 == 5u32));
     // 64-bit numbers have some flakiness yet. Not tested
 
 }
diff --git a/src/test/run-pass/artificial-block.rs b/src/test/run-pass/artificial-block.rs
index e3159df8378..7bc1354c3ce 100644
--- a/src/test/run-pass/artificial-block.rs
+++ b/src/test/run-pass/artificial-block.rs
@@ -10,4 +10,4 @@
 
 fn f() -> int { { return 3; } }
 
-pub fn main() { fail_unless!((f() == 3)); }
+pub fn main() { assert!((f() == 3)); }
diff --git a/src/test/run-pass/assign-assign.rs b/src/test/run-pass/assign-assign.rs
index f3a792d6cca..dc0850b24f1 100644
--- a/src/test/run-pass/assign-assign.rs
+++ b/src/test/run-pass/assign-assign.rs
@@ -12,21 +12,21 @@
 fn test_assign() {
     let mut x: int;
     let mut y: () = x = 10;
-    fail_unless!((x == 10));
+    assert!((x == 10));
     let mut z = x = 11;
-    fail_unless!((x == 11));
+    assert!((x == 11));
     z = x = 12;
-    fail_unless!((x == 12));
+    assert!((x == 12));
 }
 
 fn test_assign_op() {
     let mut x: int = 0;
     let mut y: () = x += 10;
-    fail_unless!((x == 10));
+    assert!((x == 10));
     let mut z = x += 11;
-    fail_unless!((x == 21));
+    assert!((x == 21));
     z = x += 12;
-    fail_unless!((x == 33));
+    assert!((x == 33));
 }
 
 pub fn main() { test_assign(); test_assign_op(); }
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index c9e42aadfd4..c557aa7e223 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -41,17 +41,17 @@ fn length<A, T: iterable<A>>(x: T) -> uint {
 pub fn main() {
     let x = ~[0,1,2,3];
     // Call a method
-    for x.iterate() |y| { fail_unless!(x[*y] == *y); }
+    for x.iterate() |y| { assert!(x[*y] == *y); }
     // Call a parameterized function
-    fail_unless!(length(x.clone()) == vec::len(x));
+    assert!(length(x.clone()) == vec::len(x));
     // Call a parameterized function, with type arguments that require
     // a borrow
-    fail_unless!(length::<int, &[int]>(x) == vec::len(x));
+    assert!(length::<int, &[int]>(x) == vec::len(x));
 
     // Now try it with a type that *needs* to be borrowed
     let z = [0,1,2,3];
     // Call a method
-    for z.iterate() |y| { fail_unless!(z[*y] == *y); }
+    for z.iterate() |y| { assert!(z[*y] == *y); }
     // Call a parameterized function
-    fail_unless!(length::<int, &[int]>(z) == vec::len(z));
+    assert!(length::<int, &[int]>(z) == vec::len(z));
 }
diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs
index 1a8ad446c79..c4d4f305a62 100644
--- a/src/test/run-pass/auto-encode.rs
+++ b/src/test/run-pass/auto-encode.rs
@@ -34,7 +34,7 @@ fn test_prettyprint<A:Encodable<prettyprint::Serializer>>(
         a.encode(&prettyprint::Serializer(w))
     };
     debug!("s == %?", s);
-    fail_unless!(s == *expected);
+    assert!(s == *expected);
 }
 
 fn test_ebml<A:
@@ -48,7 +48,7 @@ fn test_ebml<A:
     };
     let d = EBReader::Doc(@bytes);
     let a2: A = Decodable::decode(&EBReader::Decoder(d));
-    fail_unless!(*a1 == a2);
+    assert!(*a1 == a2);
 }
 
 #[auto_encode]
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index 42b175987e1..e988028dd11 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -13,5 +13,5 @@ pub fn main() {
     for vec::each(~[1, 2, 3, 4, 5]) |x| {
         sum += *x;
     }
-    fail_unless!((sum == 15));
+    assert!((sum == 15));
 }
diff --git a/src/test/run-pass/auto-ref-newtype.rs b/src/test/run-pass/auto-ref-newtype.rs
index 9a84aa6a10e..bac6d1aa740 100644
--- a/src/test/run-pass/auto-ref-newtype.rs
+++ b/src/test/run-pass/auto-ref-newtype.rs
@@ -19,6 +19,6 @@ pub impl Foo {
 
 pub fn main() {
     let m = Foo(3);
-    fail_unless!(m.len() == 3);
+    assert!(m.len() == 3);
 }
 
diff --git a/src/test/run-pass/auto-ref-slice-plus-ref.rs b/src/test/run-pass/auto-ref-slice-plus-ref.rs
index 36c4ac2ad49..1dc56132875 100644
--- a/src/test/run-pass/auto-ref-slice-plus-ref.rs
+++ b/src/test/run-pass/auto-ref-slice-plus-ref.rs
@@ -17,13 +17,13 @@ trait MyIter {
 }
 
 impl<'self> MyIter for &'self [int] {
-    fn test_imm(&self) { fail_unless!(self[0] == 1) }
-    fn test_const(&const self) { fail_unless!(self[0] == 1) }
+    fn test_imm(&self) { assert!(self[0] == 1) }
+    fn test_const(&const self) { assert!(self[0] == 1) }
 }
 
 impl<'self> MyIter for &'self str {
-    fn test_imm(&self) { fail_unless!(*self == "test") }
-    fn test_const(&const self) { fail_unless!(*self == "test") }
+    fn test_imm(&self) { assert!(*self == "test") }
+    fn test_const(&const self) { assert!(*self == "test") }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index 2d2e909a5f9..03e847e237d 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -22,5 +22,5 @@ pub fn main() {
     let mut v = ~[1];
     v.push_val(2);
     v.push_val(3);
-    fail_unless!(v == ~[1, 2, 3]);
+    assert!(v == ~[1, 2, 3]);
 }
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 44688a8dfce..afaafd45b7b 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -13,7 +13,7 @@ fn f<T:Copy>(x: ~[T]) -> T { return x[0]; }
 fn g(act: &fn(~[int]) -> int) -> int { return act(~[1, 2, 3]); }
 
 pub fn main() {
-    fail_unless!((g(f) == 1));
+    assert!((g(f) == 1));
     let f1: &fn(~[~str]) -> ~str = f;
-    fail_unless!((f1(~[~"x", ~"y", ~"z"]) == ~"x"));
+    assert!((f1(~[~"x", ~"y", ~"z"]) == ~"x"));
 }
diff --git a/src/test/run-pass/autoderef-method-newtype.rs b/src/test/run-pass/autoderef-method-newtype.rs
index a4dbab49c0c..2d6f03c1daf 100644
--- a/src/test/run-pass/autoderef-method-newtype.rs
+++ b/src/test/run-pass/autoderef-method-newtype.rs
@@ -20,5 +20,5 @@ struct foo(uint);
 
 pub fn main() {
     let x = foo(3u);
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index 3fabb95f2a3..32f09369d98 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -18,5 +18,5 @@ impl double for uint {
 
 pub fn main() {
     let x = @(@3u as @double);
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs
index e6efa6dc633..eaef1ae3477 100644
--- a/src/test/run-pass/autoderef-method-priority.rs
+++ b/src/test/run-pass/autoderef-method-priority.rs
@@ -25,5 +25,5 @@ impl double for @uint {
 
 pub fn main() {
     let x = @3u;
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index a54e77476cf..c04efd7e18f 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -18,5 +18,5 @@ impl double for @uint {
 
 pub fn main() {
     let x = @@@@@3u;
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index dde6ae9e5de..0a2a93d40d1 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -18,5 +18,5 @@ impl double for uint {
 
 pub fn main() {
     let x = @@3u;
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index f6e04c79d45..b704011ad98 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -18,5 +18,5 @@ impl double for uint {
 
 pub fn main() {
     let x = @3u;
-    fail_unless!(x.double() == 6u);
+    assert!(x.double() == 6u);
 }
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
index 0b872569f19..5325242b99c 100644
--- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -26,5 +26,5 @@ impl Foo for uint {
 
 pub fn main() {
     let x = @3u;
-    fail_unless!(x.foo() == ~"@3");
+    assert!(x.foo() == ~"@3");
 }
diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs
index 5e28f193357..41aa2042796 100644
--- a/src/test/run-pass/big-literals.rs
+++ b/src/test/run-pass/big-literals.rs
@@ -11,11 +11,11 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!(0xffffffffu32 == (-1 as u32));
-    fail_unless!(4294967295u32 == (-1 as u32));
-    fail_unless!(0xffffffffffffffffu64 == (-1 as u64));
-    fail_unless!(18446744073709551615u64 == (-1 as u64));
+    assert!(0xffffffffu32 == (-1 as u32));
+    assert!(4294967295u32 == (-1 as u32));
+    assert!(0xffffffffffffffffu64 == (-1 as u64));
+    assert!(18446744073709551615u64 == (-1 as u64));
 
-    fail_unless!(-2147483648i32 - 1i32 == 2147483647i32);
-    fail_unless!(-9223372036854775808i64 - 1i64 == 9223372036854775807i64);
+    assert!(-2147483648i32 - 1i32 == 2147483647i32);
+    assert!(-9223372036854775808i64 - 1i64 == 9223372036854775807i64);
 }
diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs
index 2153db5e40c..50dbefdd086 100644
--- a/src/test/run-pass/binary-minus-without-space.rs
+++ b/src/test/run-pass/binary-minus-without-space.rs
@@ -12,5 +12,5 @@
 
 pub fn main() {
     match -1 { -1 => {}, _ => fail!(~"wat") }
-    fail_unless!(1-1 == 0);
+    assert!(1-1 == 0);
 }
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index 3f5547df17d..e0a2d1ffa1c 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -11,55 +11,55 @@
 // Binop corner cases
 
 fn test_nil() {
-    fail_unless!((() == ()));
-    fail_unless!((!(() != ())));
-    fail_unless!((!(() < ())));
-    fail_unless!((() <= ()));
-    fail_unless!((!(() > ())));
-    fail_unless!((() >= ()));
+    assert!((() == ()));
+    assert!((!(() != ())));
+    assert!((!(() < ())));
+    assert!((() <= ()));
+    assert!((!(() > ())));
+    assert!((() >= ()));
 }
 
 fn test_bool() {
-    fail_unless!((!(true < false)));
-    fail_unless!((!(true <= false)));
-    fail_unless!((true > false));
-    fail_unless!((true >= false));
+    assert!((!(true < false)));
+    assert!((!(true <= false)));
+    assert!((true > false));
+    assert!((true >= false));
 
-    fail_unless!((false < true));
-    fail_unless!((false <= true));
-    fail_unless!((!(false > true)));
-    fail_unless!((!(false >= true)));
+    assert!((false < true));
+    assert!((false <= true));
+    assert!((!(false > true)));
+    assert!((!(false >= true)));
 
     // Bools support bitwise binops
-    fail_unless!((false & false == false));
-    fail_unless!((true & false == false));
-    fail_unless!((true & true == true));
-    fail_unless!((false | false == false));
-    fail_unless!((true | false == true));
-    fail_unless!((true | true == true));
-    fail_unless!((false ^ false == false));
-    fail_unless!((true ^ false == true));
-    fail_unless!((true ^ true == false));
+    assert!((false & false == false));
+    assert!((true & false == false));
+    assert!((true & true == true));
+    assert!((false | false == false));
+    assert!((true | false == true));
+    assert!((true | true == true));
+    assert!((false ^ false == false));
+    assert!((true ^ false == true));
+    assert!((true ^ true == false));
 }
 
 fn test_char() {
     let ch10 = 10 as char;
     let ch4 = 4 as char;
     let ch2 = 2 as char;
-    fail_unless!((ch10 + ch4 == 14 as char));
-    fail_unless!((ch10 - ch4 == 6 as char));
-    fail_unless!((ch10 * ch4 == 40 as char));
-    fail_unless!((ch10 / ch4 == ch2));
-    fail_unless!((ch10 % ch4 == ch2));
-    fail_unless!((ch10 >> ch2 == ch2));
-    fail_unless!((ch10 << ch4 == 160 as char));
-    fail_unless!((ch10 | ch4 == 14 as char));
-    fail_unless!((ch10 & ch2 == ch2));
-    fail_unless!((ch10 ^ ch2 == 8 as char));
+    assert!((ch10 + ch4 == 14 as char));
+    assert!((ch10 - ch4 == 6 as char));
+    assert!((ch10 * ch4 == 40 as char));
+    assert!((ch10 / ch4 == ch2));
+    assert!((ch10 % ch4 == ch2));
+    assert!((ch10 >> ch2 == ch2));
+    assert!((ch10 << ch4 == 160 as char));
+    assert!((ch10 | ch4 == 14 as char));
+    assert!((ch10 & ch2 == ch2));
+    assert!((ch10 ^ ch2 == 8 as char));
 }
 
 fn test_box() {
-    fail_unless!((@10 == @10));
+    assert!((@10 == @10));
 }
 
 fn test_ptr() {
@@ -68,14 +68,14 @@ fn test_ptr() {
         let p2: *u8 = ::core::cast::reinterpret_cast(&0);
         let p3: *u8 = ::core::cast::reinterpret_cast(&1);
 
-        fail_unless!(p1 == p2);
-        fail_unless!(p1 != p3);
-        fail_unless!(p1 < p3);
-        fail_unless!(p1 <= p3);
-        fail_unless!(p3 > p1);
-        fail_unless!(p3 >= p3);
-        fail_unless!(p1 <= p2);
-        fail_unless!(p1 >= p2);
+        assert!(p1 == p2);
+        assert!(p1 != p3);
+        assert!(p1 < p3);
+        assert!(p1 <= p3);
+        assert!(p3 > p1);
+        assert!(p3 >= p3);
+        assert!(p1 <= p2);
+        assert!(p1 >= p2);
     }
 }
 
@@ -110,11 +110,11 @@ fn test_class() {
          (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))),
          (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r))));
   }
-  fail_unless!((q == r));
+  assert!((q == r));
   r.y = 17;
-  fail_unless!((r.y != q.y));
-  fail_unless!((r.y == 17));
-  fail_unless!((q != r));
+  assert!((r.y != q.y));
+  assert!((r.y == 17));
+  assert!((q != r));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs
index ec324bcf33b..1a67329ff82 100644
--- a/src/test/run-pass/bitwise.rs
+++ b/src/test/run-pass/bitwise.rs
@@ -12,12 +12,12 @@
 
 #[cfg(target_arch = "x86")]
 fn target() {
-    fail_unless!((-1000 as uint >> 3u == 536870787u));
+    assert!((-1000 as uint >> 3u == 536870787u));
 }
 
 #[cfg(target_arch = "x86_64")]
 fn target() {
-    fail_unless!((-1000 as uint >> 3u == 2305843009213693827u));
+    assert!((-1000 as uint >> 3u == 2305843009213693827u));
 }
 
 fn general() {
@@ -28,14 +28,14 @@ fn general() {
     a = a ^ b;
     debug!(a);
     debug!(b);
-    fail_unless!((b == 1));
-    fail_unless!((a == 2));
-    fail_unless!((!0xf0 & 0xff == 0xf));
-    fail_unless!((0xf0 | 0xf == 0xff));
-    fail_unless!((0xf << 4 == 0xf0));
-    fail_unless!((0xf0 >> 4 == 0xf));
-    fail_unless!((-16 >> 2 == -4));
-    fail_unless!((0b1010_1010 | 0b0101_0101 == 0xff));
+    assert!((b == 1));
+    assert!((a == 2));
+    assert!((!0xf0 & 0xff == 0xf));
+    assert!((0xf0 | 0xf == 0xff));
+    assert!((0xf << 4 == 0xf0));
+    assert!((0xf0 >> 4 == 0xf));
+    assert!((-16 >> 2 == -4));
+    assert!((0b1010_1010 | 0b0101_0101 == 0xff));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs
index f0dafa0805e..22d495e2c1b 100644
--- a/src/test/run-pass/block-arg-call-as.rs
+++ b/src/test/run-pass/block-arg-call-as.rs
@@ -24,9 +24,9 @@ fn asBlock( f : &fn()->uint ) -> uint {
 
 pub fn main() {
    let x = asSendfn(|| 22u);
-   fail_unless!((x == 22u));
+   assert!((x == 22u));
    let x = asLambda(|| 22u);
-   fail_unless!((x == 22u));
+   assert!((x == 22u));
    let x = asBlock(|| 22u);
-   fail_unless!((x == 22u));
+   assert!((x == 22u));
 }
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
index b46aad99845..74756d27fe7 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs
@@ -14,5 +14,5 @@ pub fn main() {
     // Trailing expressions don't require parentheses:
     let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
 
-    fail_unless!(y == 15f);
+    assert!(y == 15f);
 }
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
index b2e1bc51586..4cadb883d99 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs
@@ -12,5 +12,5 @@ pub fn main() {
     fn f(i: &fn() -> uint) -> uint { i() }
     let v = ~[-1f, 0f, 1f, 2f, 3f];
     let z = do do vec::foldl(f, v) |x, _y| { x } { 22u };
-    fail_unless!(z == 22u);
+    assert!(z == 22u);
 }
diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs
index bbdbfc74b0e..ac584324cec 100644
--- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs
+++ b/src/test/run-pass/block-arg-can-be-followed-by-call.rs
@@ -12,5 +12,5 @@ pub fn main() {
     fn f(i: uint) -> uint { i }
     let v = ~[-1f, 0f, 1f, 2f, 3f];
     let z = do vec::foldl(f, v) |x, _y| { x } (22u);
-    fail_unless!(z == 22u);
+    assert!(z == 22u);
 }
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
index f74c531503f..ce0b85f414b 100644
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ b/src/test/run-pass/block-arg-in-parentheses.rs
@@ -28,9 +28,9 @@ fn w_ret(v: ~[int]) -> int {
 }
 
 pub fn main() {
-    fail_unless!(w_semi(~[0, 1, 2, 3]) == -10);
-    fail_unless!(w_paren1(~[0, 1, 2, 3]) == -4);
-    fail_unless!(w_paren2(~[0, 1, 2, 3]) == -4);
-    fail_unless!(w_ret(~[0, 1, 2, 3]) == -4);
+    assert!(w_semi(~[0, 1, 2, 3]) == -10);
+    assert!(w_paren1(~[0, 1, 2, 3]) == -4);
+    assert!(w_paren2(~[0, 1, 2, 3]) == -4);
+    assert!(w_ret(~[0, 1, 2, 3]) == -4);
 }
 
diff --git a/src/test/run-pass/block-arg-used-as-any.rs b/src/test/run-pass/block-arg-used-as-any.rs
index ae110a04773..d8aeba355d1 100644
--- a/src/test/run-pass/block-arg-used-as-any.rs
+++ b/src/test/run-pass/block-arg-used-as-any.rs
@@ -14,5 +14,5 @@ fn call_any(f: &fn() -> uint) -> uint {
 
 pub fn main() {
     let x_r = do call_any { 22u };
-    fail_unless!(x_r == 22u);
+    assert!(x_r == 22u);
 }
diff --git a/src/test/run-pass/block-arg-used-as-lambda.rs b/src/test/run-pass/block-arg-used-as-lambda.rs
index 6d26ede8e3a..2a7bfe4e328 100644
--- a/src/test/run-pass/block-arg-used-as-lambda.rs
+++ b/src/test/run-pass/block-arg-used-as-lambda.rs
@@ -19,6 +19,6 @@ pub fn main() {
     let x_r = x(22u);
     let y_r = y(x_r);
 
-    fail_unless!(x_r == 44u);
-    fail_unless!(y_r == 88u);
+    assert!(x_r == 44u);
+    assert!(y_r == 88u);
 }
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index fa8687e839c..4fecbd4e956 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -19,20 +19,20 @@ pub fn main() {
 
     // Usable at all:
     let mut any_negative = do vec::any(v) |e| { float::is_negative(*e) };
-    fail_unless!(any_negative);
+    assert!(any_negative);
 
     // Higher precedence than assignments:
     any_negative = do vec::any(v) |e| { float::is_negative(*e) };
-    fail_unless!(any_negative);
+    assert!(any_negative);
 
     // Higher precedence than unary operations:
     let abs_v = do vec::map(v) |e| { float::abs(*e) };
-    fail_unless!(do vec::all(abs_v) |e| { float::is_nonnegative(*e) });
-    fail_unless!(!do vec::any(abs_v) |e| { float::is_negative(*e) });
+    assert!(do vec::all(abs_v) |e| { float::is_nonnegative(*e) });
+    assert!(!do vec::any(abs_v) |e| { float::is_negative(*e) });
 
     // Usable in funny statement-like forms:
     if !do vec::any(v) |e| { float::is_positive(*e) } {
-        fail_unless!(false);
+        assert!(false);
     }
     match do vec::all(v) |e| { float::is_negative(*e) } {
         true => { fail!(~"incorrect answer."); }
@@ -51,12 +51,12 @@ pub fn main() {
     let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
     let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f;
     let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y };
-    fail_unless!(w == y);
-    fail_unless!(y == z);
+    assert!(w == y);
+    assert!(y == z);
 
     // In the tail of a block
     let w =
         if true { do vec::any(abs_v) |e| { float::is_nonnegative(*e) } }
       else { false };
-    fail_unless!(w);
+    assert!(w);
 }
diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs
index 39e19cfec97..d8f6f167f20 100644
--- a/src/test/run-pass/block-expr-precedence.rs
+++ b/src/test/run-pass/block-expr-precedence.rs
@@ -58,8 +58,8 @@ pub fn main() {
 
   let num = 12;
 
-  fail_unless!(if (true) { 12 } else { 12 } - num == 0);
-  fail_unless!(12 - if (true) { 12 } else { 12 } == 0);
+  assert!(if (true) { 12 } else { 12 } - num == 0);
+  assert!(12 - if (true) { 12 } else { 12 } == 0);
   if (true) { 12; } {-num};
   if (true) { 12; }; {-num};
   if (true) { 12; };;; -num;
diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs
index dc8ad25e276..5a4b2f8bfd6 100644
--- a/src/test/run-pass/block-fn-coerce.rs
+++ b/src/test/run-pass/block-fn-coerce.rs
@@ -11,7 +11,7 @@
 fn force(f: &fn() -> int) -> int { return f(); }
 pub fn main() {
     fn f() -> int { return 7; }
-    fail_unless!((force(f) == 7));
+    assert!((force(f) == 7));
     let g = {||force(f)};
-    fail_unless!((g() == 7));
+    assert!((g() == 7));
 }
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index e6056382779..0a3458ed814 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -21,5 +21,5 @@ pub fn main() {
         }
     });
     error!(odds);
-    fail_unless!((odds == 4));
+    assert!((odds == 4));
 }
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 96336f5569c..e5c527db556 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -21,5 +21,5 @@ pub fn main() {
         });
     });
     error!(sum);
-    fail_unless!((sum == 225));
+    assert!((sum == 225));
 }
diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs
index 28875da25a6..d4783e1c7dd 100644
--- a/src/test/run-pass/block-vec-map2.rs
+++ b/src/test/run-pass/block-vec-map2.rs
@@ -16,5 +16,5 @@ pub fn main() {
                   ~[true, false, false, true, true],
                   |i, b| if *b { -(*i) } else { *i } );
     error!(v.clone());
-    fail_unless!((v == ~[-1, 2, 3, -4, -5]));
+    assert!((v == ~[-1, 2, 3, -4, -5]));
 }
diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs
index 656abab0cc1..3d659d5d256 100644
--- a/src/test/run-pass/bool-not.rs
+++ b/src/test/run-pass/bool-not.rs
@@ -13,6 +13,6 @@
 
 // -*- rust -*-
 pub fn main() {
-    if !false { fail_unless!((true)); } else { fail_unless!((false)); }
-    if !true { fail_unless!((false)); } else { fail_unless!((true)); }
+    if !false { assert!((true)); } else { assert!((false)); }
+    if !true { assert!((false)); } else { assert!((true)); }
 }
diff --git a/src/test/run-pass/borrowck-borrow-from-at-vec.rs b/src/test/run-pass/borrowck-borrow-from-at-vec.rs
index 6757f8655f1..e5f2a18df63 100644
--- a/src/test/run-pass/borrowck-borrow-from-at-vec.rs
+++ b/src/test/run-pass/borrowck-borrow-from-at-vec.rs
@@ -16,5 +16,5 @@ fn sum_slice(x: &[int]) -> int {
 
 pub fn main() {
     let x = @[1, 2, 3];
-    fail_unless!(sum_slice(x) == 6);
+    assert!(sum_slice(x) == 6);
 }
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index f2e0b6c9ca0..401985023bc 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -15,8 +15,8 @@ fn borrow(x: &int, f: &fn(x: &int)) {
 fn test1(x: @~int) {
     do borrow(&*x.clone()) |p| {
         let x_a = ptr::addr_of(&(**x));
-        fail_unless!((x_a as uint) != ptr::to_uint(p));
-        fail_unless!(unsafe{*x_a} == *p);
+        assert!((x_a as uint) != ptr::to_uint(p));
+        assert!(unsafe{*x_a} == *p);
     }
 }
 
diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs
index 764f5510481..e9d4a248068 100644
--- a/src/test/run-pass/borrowck-fixed-length-vecs.rs
+++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let x = [22];
     let y = &x[0];
-    fail_unless!(*y == 22);
+    assert!(*y == 22);
 }
diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
index a90381ad631..6929a98d9e1 100644
--- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
+++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
@@ -19,5 +19,5 @@ fn has_mut_vec(+v: ~[int]) -> int {
 }
 
 pub fn main() {
-    fail_unless!(has_mut_vec(~[1, 2, 3]) == 6);
+    assert!(has_mut_vec(~[1, 2, 3]) == 6);
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
index ba1c6aec215..7e871bc7caa 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs
@@ -16,14 +16,14 @@ pub fn main() {
     let mut x = @F {f: ~3};
     match x {
       @F {f: ref b_x} => {
-        fail_unless!(**b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(**b_x)));
+        assert!(**b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(**b_x)));
 
         x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint);
-        fail_unless!(**b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x)));
+        assert!(**b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x)));
       }
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 795b074e37c..a22dc621525 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) {
     let before = *x;
     f(x);
     let after = *x;
-    fail_unless!(before == after);
+    assert!(before == after);
 }
 
 struct F { f: ~int }
@@ -22,12 +22,12 @@ struct F { f: ~int }
 pub fn main() {
     let mut x = @F {f: ~3};
     do borrow(x.f) |b_x| {
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
         x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
index 374283ffb8a..f9991199c81 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs
@@ -16,14 +16,14 @@ pub fn main() {
     let mut x = @mut @F {f: ~3};
     match x {
       @@F{f: ref b_x} => {
-        fail_unless!(**b_x == 3);
-        fail_unless!(ptr::addr_of(&(x.f)) == ptr::addr_of(b_x));
+        assert!(**b_x == 3);
+        assert!(ptr::addr_of(&(x.f)) == ptr::addr_of(b_x));
 
         *x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint);
-        fail_unless!(**b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x)));
+        assert!(**b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x)));
       }
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index 11ec78b681c..99047325646 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) {
     let before = *x;
     f(x);
     let after = *x;
-    fail_unless!(before == after);
+    assert!(before == after);
 }
 
 struct F { f: ~int }
@@ -22,12 +22,12 @@ struct F { f: ~int }
 pub fn main() {
     let mut x = ~@F{f: ~3};
     do borrow(x.f) |b_x| {
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
         *x = @F{f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs
index 8d625476f57..0fe3b7947f4 100644
--- a/src/test/run-pass/borrowck-preserve-box.rs
+++ b/src/test/run-pass/borrowck-preserve-box.rs
@@ -14,18 +14,18 @@ fn borrow(x: &int, f: &fn(x: &int)) {
     let before = *x;
     f(x);
     let after = *x;
-    fail_unless!(before == after);
+    assert!(before == after);
 }
 
 pub fn main() {
     let mut x = @3;
     do borrow(x) |b_x| {
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x)));
         x = @22;
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x)));
     }
 }
diff --git a/src/test/run-pass/borrowck-preserve-cond-box.rs b/src/test/run-pass/borrowck-preserve-cond-box.rs
index 808f333dbf1..18c185cfef1 100644
--- a/src/test/run-pass/borrowck-preserve-cond-box.rs
+++ b/src/test/run-pass/borrowck-preserve-cond-box.rs
@@ -25,13 +25,13 @@ fn testfn(cond: bool) {
     }
 
     debug!("*r = %d, exp = %d", *r, exp);
-    fail_unless!(*r == exp);
+    assert!(*r == exp);
 
     x = @5;
     y = @6;
 
     debug!("*r = %d, exp = %d", *r, exp);
-    fail_unless!(*r == exp);
+    assert!(*r == exp);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index fcb84eaaf00..5939391413c 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) {
     let before = *x;
     f(x);
     let after = *x;
-    fail_unless!(before == after);
+    assert!(before == after);
 }
 
 struct F { f: ~int }
@@ -22,12 +22,12 @@ struct F { f: ~int }
 pub fn main() {
     let mut x = @F {f: ~3};
     do borrow((*x).f) |b_x| {
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x)));
         x = @F {f: ~4};
 
         debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint);
-        fail_unless!(*b_x == 3);
-        fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
+        assert!(*b_x == 3);
+        assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x)));
     }
 }
diff --git a/src/test/run-pass/borrowck-univariant-enum.rs b/src/test/run-pass/borrowck-univariant-enum.rs
index e43bcecaa9f..3ec061c2dea 100644
--- a/src/test/run-pass/borrowck-univariant-enum.rs
+++ b/src/test/run-pass/borrowck-univariant-enum.rs
@@ -25,5 +25,5 @@ pub fn main() {
         *x * b
       }
     };
-    fail_unless!(z == 18);
+    assert!(z == 18);
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern-2.rs b/src/test/run-pass/borrowed-ptr-pattern-2.rs
index e1e5d685428..b15f9e76234 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-2.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-2.rs
@@ -16,6 +16,6 @@ fn foo(s: &~str) -> bool {
 }
 
 pub fn main() {
-    fail_unless!(foo(&~"kitty"));
-    fail_unless!(!foo(&~"gata"));
+    assert!(foo(&~"kitty"));
+    assert!(!foo(&~"gata"));
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern-3.rs b/src/test/run-pass/borrowed-ptr-pattern-3.rs
index 4bdecd5eeec..030e055c4cc 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-3.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-3.rs
@@ -16,6 +16,6 @@ fn foo<'r>(s: &'r uint) -> bool {
 }
 
 pub fn main() {
-    fail_unless!(foo(&3));
-    fail_unless!(!foo(&4));
+    assert!(foo(&3));
+    assert!(!foo(&4));
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
index 1f7464c3ad4..d49ea86402a 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
@@ -10,7 +10,7 @@
 
 pub fn main() {
     let (&x, &y, &z) = (&3, &'a', &@"No pets!");
-    fail_unless!(x == 3);
-    fail_unless!(y == 'a');
-    fail_unless!(z == @"No pets!");
+    assert!(x == 3);
+    assert!(y == 'a');
+    assert!(z == @"No pets!");
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs
index ebd5cf41db5..dc620d0733d 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-option.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs
@@ -19,5 +19,5 @@ fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> {
 pub fn main() {
     let x = None;
     let y = Some(3);
-    fail_unless!(select(&x, &y).get() == 3);
+    assert!(select(&x, &y).get() == 3);
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs
index e092dea3d1c..44485b5c8df 100644
--- a/src/test/run-pass/borrowed-ptr-pattern.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern.rs
@@ -15,7 +15,7 @@ fn foo<T:Copy>(x: &T) -> T{
 }
 
 pub fn main() {
-    fail_unless!(foo(&3) == 3);
-    fail_unless!(foo(&'a') == 'a');
-    fail_unless!(foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool");
+    assert!(foo(&3) == 3);
+    assert!(foo(&'a') == 'a');
+    assert!(foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool");
 }
diff --git a/src/test/run-pass/box-compare.rs b/src/test/run-pass/box-compare.rs
index bceedcad4a8..b68ecd3f4d3 100644
--- a/src/test/run-pass/box-compare.rs
+++ b/src/test/run-pass/box-compare.rs
@@ -11,7 +11,7 @@
 
 
 pub fn main() {
-    fail_unless!((@1 < @3));
-    fail_unless!((@@~"hello " > @@~"hello"));
-    fail_unless!((@@@~"hello" != @@@~"there"));
+    assert!((@1 < @3));
+    assert!((@@~"hello " > @@~"hello"));
+    assert!((@@@~"hello" != @@@~"there"));
 }
diff --git a/src/test/run-pass/box-pattern.rs b/src/test/run-pass/box-pattern.rs
index fb88fce4232..89f62adcdee 100644
--- a/src/test/run-pass/box-pattern.rs
+++ b/src/test/run-pass/box-pattern.rs
@@ -12,7 +12,7 @@ struct Foo {a: int, b: uint}
 enum bar { u(@Foo), w(int), }
 
 pub fn main() {
-    fail_unless!(match u(@Foo{a: 10, b: 40u}) {
+    assert!(match u(@Foo{a: 10, b: 40u}) {
               u(@Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index 81ccfe5f4fa..96fc7b84bcd 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -18,5 +18,5 @@ pub fn main() {
     let foo: int = 17;
     let bfoo: Box<int> = Box {c: @foo};
     debug!("see what's in our box");
-    fail_unless!((unbox::<int>(bfoo) == foo));
+    assert!((unbox::<int>(bfoo) == foo));
 }
diff --git a/src/test/run-pass/box.rs b/src/test/run-pass/box.rs
index 12276e4cfa6..4c394a601b4 100644
--- a/src/test/run-pass/box.rs
+++ b/src/test/run-pass/box.rs
@@ -10,4 +10,4 @@
 
 
 
-pub fn main() { let x: @int = @10; fail_unless!((*x == 10)); }
+pub fn main() { let x: @int = @10; assert!((*x == 10)); }
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index f65e8481562..b3f524c0ad7 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -13,21 +13,21 @@
 pub fn main() {
     let mut i = 0;
     while i < 20 { i += 1; if i == 10 { break; } }
-    fail_unless!((i == 10));
+    assert!((i == 10));
     loop { i += 1; if i == 20 { break; } }
-    fail_unless!((i == 20));
+    assert!((i == 20));
     for vec::each(~[1, 2, 3, 4, 5, 6]) |x| {
-        if *x == 3 { break; } fail_unless!((*x <= 3));
+        if *x == 3 { break; } assert!((*x <= 3));
     }
     i = 0;
-    while i < 10 { i += 1; if i % 2 == 0 { loop; } fail_unless!((i % 2 != 0)); }
+    while i < 10 { i += 1; if i % 2 == 0 { loop; } assert!((i % 2 != 0)); }
     i = 0;
     loop { 
-        i += 1; if i % 2 == 0 { loop; } fail_unless!((i % 2 != 0)); 
+        i += 1; if i % 2 == 0 { loop; } assert!((i % 2 != 0)); 
         if i >= 10 { break; }
     }
     for vec::each(~[1, 2, 3, 4, 5, 6]) |x| {
         if *x % 2 == 0 { loop; }
-        fail_unless!((*x % 2 != 0));
+        assert!((*x % 2 != 0));
     }
 }
diff --git a/src/test/run-pass/by-val-and-by-move.rs b/src/test/run-pass/by-val-and-by-move.rs
index 673c558f98c..47d2f9e1df0 100644
--- a/src/test/run-pass/by-val-and-by-move.rs
+++ b/src/test/run-pass/by-val-and-by-move.rs
@@ -22,5 +22,5 @@ fn free<T>(-_t: T) {
 
 pub fn main() {
     let z = @3;
-    fail_unless!(3 == it_takes_two(z, z));
+    assert!(3 == it_takes_two(z, z));
 }
diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs
index b23e2147f96..a87dbaab5c9 100644
--- a/src/test/run-pass/c-stack-returning-int64.rs
+++ b/src/test/run-pass/c-stack-returning-int64.rs
@@ -29,8 +29,8 @@ fn atoll(s: ~str) -> i64 {
 
 pub fn main() {
     unsafe {
-        fail_unless!(atol(~"1024") * 10 == atol(~"10240"));
-        fail_unless!((atoll(~"11111111111111111") * 10i64)
+        assert!(atol(~"1024") * 10 == atol(~"10240"));
+        assert!((atoll(~"11111111111111111") * 10i64)
             == atoll(~"111111111111111110"));
     }
 }
diff --git a/src/test/run-pass/call-closure-from-overloaded-op.rs b/src/test/run-pass/call-closure-from-overloaded-op.rs
index 39864059fcd..8832620c4bf 100644
--- a/src/test/run-pass/call-closure-from-overloaded-op.rs
+++ b/src/test/run-pass/call-closure-from-overloaded-op.rs
@@ -13,5 +13,5 @@ fn foo() -> int { 22 }
 pub fn main() {
     let mut x: ~[@fn() -> int] = ~[];
     x.push(foo);
-    fail_unless!((x[0])() == 22);
+    assert!((x[0])() == 22);
 }
diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs
index 44f9b3e990e..7731ef8908d 100644
--- a/src/test/run-pass/cap-clause-move.rs
+++ b/src/test/run-pass/cap-clause-move.rs
@@ -12,20 +12,20 @@ pub fn main() {
     let x = ~1;
     let y = ptr::addr_of(&(*x)) as uint;
     let lam_move: @fn() -> uint = || ptr::addr_of(&(*x)) as uint;
-    fail_unless!(lam_move() == y);
+    assert!(lam_move() == y);
 
     let x = ~2;
     let y = ptr::addr_of(&(*x)) as uint;
     let lam_move: @fn() -> uint = || ptr::addr_of(&(*x)) as uint;
-    fail_unless!(lam_move() == y);
+    assert!(lam_move() == y);
 
     let x = ~3;
     let y = ptr::addr_of(&(*x)) as uint;
     let snd_move: ~fn() -> uint = || ptr::addr_of(&(*x)) as uint;
-    fail_unless!(snd_move() == y);
+    assert!(snd_move() == y);
 
     let x = ~4;
     let y = ptr::addr_of(&(*x)) as uint;
     let lam_move: ~fn() -> uint = || ptr::addr_of(&(*x)) as uint;
-    fail_unless!(lam_move() == y);
+    assert!(lam_move() == y);
 }
diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs
index 97400198167..1df1f3b4c8b 100644
--- a/src/test/run-pass/cast.rs
+++ b/src/test/run-pass/cast.rs
@@ -14,13 +14,13 @@
 // -*- rust -*-
 pub fn main() {
     let i: int = 'Q' as int;
-    fail_unless!((i == 0x51));
+    assert!((i == 0x51));
     let u: u32 = i as u32;
-    fail_unless!((u == 0x51 as u32));
-    fail_unless!((u == 'Q' as u32));
-    fail_unless!((i as u8 == 'Q' as u8));
-    fail_unless!((i as u8 as i8 == 'Q' as u8 as i8));
-    fail_unless!((0x51 as char == 'Q'));
-    fail_unless!((true == 1 as bool));
-    fail_unless!((0 as u32 == false as u32));
+    assert!((u == 0x51 as u32));
+    assert!((u == 'Q' as u32));
+    assert!((i as u8 == 'Q' as u8));
+    assert!((i as u8 as i8 == 'Q' as u8 as i8));
+    assert!((0x51 as char == 'Q'));
+    assert!((true == 1 as bool));
+    assert!((0 as u32 == false as u32));
 }
diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs
index 7e30910b169..e6ec46acd23 100644
--- a/src/test/run-pass/cci_borrow.rs
+++ b/src/test/run-pass/cci_borrow.rs
@@ -18,5 +18,5 @@ pub fn main() {
     let p = @22u;
     let r = foo(p);
     debug!("r=%u", r);
-    fail_unless!(r == 22u);
+    assert!(r == 22u);
 }
diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs
index 2366582a4ed..db25b36aa61 100644
--- a/src/test/run-pass/cci_impl_exe.rs
+++ b/src/test/run-pass/cci_impl_exe.rs
@@ -23,6 +23,6 @@ pub fn main() {
 
         //let bt1 = sys::frame_address();
         //debug!("%?", bt1);
-        //fail_unless!(bt0 == bt1);
+        //assert!(bt0 == bt1);
     }
 }
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index 55ecf317f85..55113019110 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -20,6 +20,6 @@ pub fn main() {
     //debug!("%?", bt0);
     do cci_iter_lib::iter(~[1, 2, 3]) |i| {
         io::print(fmt!("%d", i));
-        //fail_unless!(bt0 == sys::rusti::frame_address(2u32));
+        //assert!(bt0 == sys::rusti::frame_address(2u32));
     }
 }
diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs
index 56b42759599..f6bfa25d94d 100644
--- a/src/test/run-pass/cci_nested_exe.rs
+++ b/src/test/run-pass/cci_nested_exe.rs
@@ -18,12 +18,12 @@ pub fn main() {
     let lst = new_int_alist();
     alist_add(lst, 22, ~"hi");
     alist_add(lst, 44, ~"ho");
-    fail_unless!(alist_get(lst, 22) == ~"hi");
-    fail_unless!(alist_get(lst, 44) == ~"ho");
+    assert!(alist_get(lst, 22) == ~"hi");
+    assert!(alist_get(lst, 44) == ~"ho");
 
     let lst = new_int_alist_2();
     alist_add(lst, 22, ~"hi");
     alist_add(lst, 44, ~"ho");
-    fail_unless!(alist_get(lst, 22) == ~"hi");
-    fail_unless!(alist_get(lst, 44) == ~"ho");
+    assert!(alist_get(lst, 22) == ~"hi");
+    assert!(alist_get(lst, 44) == ~"ho");
 }
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index f2e6eeb31ff..a1c2666b2e5 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -28,6 +28,6 @@ pub fn main() {
         //let bt1 = sys::frame_address();
         //debug!("%?", bt1);
 
-        //fail_unless!(bt0 != bt1);
+        //assert!(bt0 != bt1);
     }
 }
diff --git a/src/test/run-pass/cfgs-on-items.rs b/src/test/run-pass/cfgs-on-items.rs
index 47aa683ecd2..ed025623ac3 100644
--- a/src/test/run-pass/cfgs-on-items.rs
+++ b/src/test/run-pass/cfgs-on-items.rs
@@ -26,6 +26,6 @@ fn foo2() -> int { 3 }
 
 
 fn main() {
-    fail_unless!(1 == foo1());
-    fail_unless!(3 == foo2());
+    assert!(1 == foo1());
+    assert!(3 == foo2());
 }
diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs
index d1d1cc84d38..bcfc6a3ccd9 100644
--- a/src/test/run-pass/char.rs
+++ b/src/test/run-pass/char.rs
@@ -13,11 +13,11 @@
 pub fn main() {
     let c: char = 'x';
     let d: char = 'x';
-    fail_unless!((c == 'x'));
-    fail_unless!(('x' == c));
-    fail_unless!((c == c));
-    fail_unless!((c == d));
-    fail_unless!((d == c));
-    fail_unless!((d == 'x'));
-    fail_unless!(('x' == d));
+    assert!((c == 'x'));
+    assert!(('x' == c));
+    assert!((c == c));
+    assert!((c == d));
+    assert!((d == c));
+    assert!((d == 'x'));
+    assert!(('x' == d));
 }
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index 5f3650d3aec..68bc567cf51 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -17,7 +17,7 @@ use cci_class_cast::kitty::*;
 fn print_out(thing: @ToStr, expected: ~str) {
   let actual = thing.to_str();
   debug!("%s", actual);
-  fail_unless!((actual == expected));
+  assert!((actual == expected));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate.rs b/src/test/run-pass/class-cast-to-trait-cross-crate.rs
index c3f5db0b100..10cce8cf56a 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate.rs
@@ -51,7 +51,7 @@ class cat : to_str {
 fn print_out<T:to_str>(thing: T, expected: str) {
   let actual = thing.to_str();
   debug!("%s", actual);
-  fail_unless!((actual == expected));
+  assert!((actual == expected));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
index eefa78cc3c9..be63e339478 100644
--- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs
+++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs
@@ -88,6 +88,6 @@ pub fn main() {
   let whitefang : dog = dog();
   annoy_neighbors(@(copy nyan) as @noisy);
   annoy_neighbors(@(copy whitefang) as @noisy);
-  fail_unless!((nyan.meow_count() == 10u));
-  fail_unless!((*whitefang.volume == 1));
+  assert!((nyan.meow_count() == 10u));
+  assert!((*whitefang.volume == 1));
 }
diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs
index 6a665f770ff..6684a729d23 100644
--- a/src/test/run-pass/class-exports.rs
+++ b/src/test/run-pass/class-exports.rs
@@ -34,5 +34,5 @@ mod kitty {
 }
 
 pub fn main() {
-  fail_unless!((cat(~"Spreckles").get_name() == ~"Spreckles"));
+  assert!((cat(~"Spreckles").get_name() == ~"Spreckles"));
 }
diff --git a/src/test/run-pass/class-impl-parameterized-trait.rs b/src/test/run-pass/class-impl-parameterized-trait.rs
index 87573b84dc8..53ae0021a91 100644
--- a/src/test/run-pass/class-impl-parameterized-trait.rs
+++ b/src/test/run-pass/class-impl-parameterized-trait.rs
@@ -78,6 +78,6 @@ pub fn main() {
   for uint::range(1u, 5u) |_i| { nyan.speak(); }
   // cat returns true if uint input is greater than
   // the number of meows so far
-  fail_unless!((nyan.get(1)));
-  fail_unless!((!nyan.get(10)));
+  assert!((nyan.get(1)));
+  assert!((!nyan.get(10)));
 }
diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs
index bc6972bfb27..30ca5ea3881 100644
--- a/src/test/run-pass/class-impl-very-parameterized-trait.rs
+++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs
@@ -135,11 +135,11 @@ priv impl<T> cat<T> {
 pub fn main() {
     let mut nyan: cat<~str> = cat::new(0, 2, ~"nyan");
     for uint::range(1, 5) |_| { nyan.speak(); }
-    fail_unless!((*nyan.find(&1).unwrap() == ~"nyan"));
-    fail_unless!((nyan.find(&10) == None));
+    assert!((*nyan.find(&1).unwrap() == ~"nyan"));
+    assert!((nyan.find(&10) == None));
     let mut spotty: cat<cat_type> = cat::new(2, 57, tuxedo);
     for uint::range(0, 6) |_| { spotty.speak(); }
-    fail_unless!((spotty.len() == 8));
-    fail_unless!((spotty.contains_key(&2)));
-    fail_unless!((spotty.get(&3) == &tuxedo));
+    assert!((spotty.len() == 8));
+    assert!((spotty.contains_key(&2)));
+    assert!((spotty.get(&3) == &tuxedo));
 }
diff --git a/src/test/run-pass/class-implement-trait-cross-crate.rs b/src/test/run-pass/class-implement-trait-cross-crate.rs
index ed3e3e38c93..226dbe535fa 100644
--- a/src/test/run-pass/class-implement-trait-cross-crate.rs
+++ b/src/test/run-pass/class-implement-trait-cross-crate.rs
@@ -60,7 +60,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
 pub fn main() {
   let mut nyan = cat(0u, 2, ~"nyan");
   nyan.eat();
-  fail_unless!((!nyan.eat()));
+  assert!((!nyan.eat()));
   for uint::range(1u, 10u) |_i| { nyan.speak(); };
-  fail_unless!((nyan.eat()));
+  assert!((nyan.eat()));
 }
diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs
index 7cd2753ee15..ebc4668e70f 100644
--- a/src/test/run-pass/class-implement-traits.rs
+++ b/src/test/run-pass/class-implement-traits.rs
@@ -65,7 +65,7 @@ fn make_speak<C:noisy>(mut c: C) {
 pub fn main() {
   let mut nyan = cat(0u, 2, ~"nyan");
   nyan.eat();
-  fail_unless!((!nyan.eat()));
+  assert!((!nyan.eat()));
   for uint::range(1u, 10u) |_i| { make_speak(nyan); };
-  fail_unless!((nyan.eat()));
+  assert!((nyan.eat()));
 }
diff --git a/src/test/run-pass/class-implements-multiple-traits.rs b/src/test/run-pass/class-implements-multiple-traits.rs
index 22519be0817..3a5bd648639 100644
--- a/src/test/run-pass/class-implements-multiple-traits.rs
+++ b/src/test/run-pass/class-implements-multiple-traits.rs
@@ -123,7 +123,7 @@ fn scratched_something<T:scratchy>(critter: T) -> bool {
 pub fn main() {
   let nyan : cat  = cat(0u, 2, "nyan");
   annoy_neighbors(nyan as noisy);
-  fail_unless!((nyan.meow_count() == 10u));
-  fail_unless!((bite_everything(nyan as bitey)));
-  fail_unless!((scratched_something(nyan as scratchy)));
+  assert!((nyan.meow_count() == 10u));
+  assert!((bite_everything(nyan as bitey)));
+  assert!((scratched_something(nyan as scratchy)));
 }
diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs
index cb266c1f9b4..a6ab91a2c88 100644
--- a/src/test/run-pass/class-method-cross-crate.rs
+++ b/src/test/run-pass/class-method-cross-crate.rs
@@ -16,7 +16,7 @@ use cci_class_2::kitties::*;
 pub fn main() {
   let nyan : cat = cat(52u, 99);
   let kitty = cat(1000u, 2);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
   nyan.speak();
 }
diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs
index 2664841e3e4..8e5843c6a85 100644
--- a/src/test/run-pass/class-methods-cross-crate.rs
+++ b/src/test/run-pass/class-methods-cross-crate.rs
@@ -16,8 +16,8 @@ use cci_class_3::kitties::*;
 pub fn main() {
     let mut nyan : cat = cat(52u, 99);
     let mut kitty = cat(1000u, 2);
-    fail_unless!((nyan.how_hungry == 99));
-    fail_unless!((kitty.how_hungry == 2));
+    assert!((nyan.how_hungry == 99));
+    assert!((kitty.how_hungry == 2));
     nyan.speak();
-    fail_unless!((nyan.meow_count() == 53u));
+    assert!((nyan.meow_count() == 53u));
 }
diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs
index 0168db2b7b5..1c4c83999f7 100644
--- a/src/test/run-pass/class-methods.rs
+++ b/src/test/run-pass/class-methods.rs
@@ -29,8 +29,8 @@ fn cat(in_x: uint, in_y: int) -> cat {
 pub fn main() {
   let mut nyan: cat = cat(52u, 99);
   let mut kitty = cat(1000u, 2);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
   nyan.speak();
-  fail_unless!((nyan.meow_count() == 53u));
+  assert!((nyan.meow_count() == 53u));
 }
diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs
index e87cbc383bc..cde171a44e2 100644
--- a/src/test/run-pass/class-poly-methods-cross-crate.rs
+++ b/src/test/run-pass/class-poly-methods-cross-crate.rs
@@ -16,10 +16,10 @@ use cci_class_6::kitties::*;
 pub fn main() {
   let mut nyan : cat<char> = cat::<char>(52u, 99, ~['p']);
   let mut kitty = cat(1000u, 2, ~[~"tabby"]);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
   nyan.speak(~[1u,2u,3u]);
-  fail_unless!((nyan.meow_count() == 55u));
+  assert!((nyan.meow_count() == 55u));
   kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]);
-  fail_unless!((kitty.meow_count() == 1004u));
+  assert!((kitty.meow_count() == 1004u));
 }
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index 95db23f6c5a..adcab8b40aa 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -33,10 +33,10 @@ fn cat<U>(in_x : uint, in_y : int, +in_info: ~[U]) -> cat<U> {
 pub fn main() {
   let mut nyan : cat<int> = cat::<int>(52u, 99, ~[9]);
   let mut kitty = cat(1000u, 2, ~[~"tabby"]);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
   nyan.speak(~[1,2,3]);
-  fail_unless!((nyan.meow_count() == 55u));
+  assert!((nyan.meow_count() == 55u));
   kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]);
-  fail_unless!((kitty.meow_count() == 1004u));
+  assert!((kitty.meow_count() == 1004u));
 }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 168f2d872e7..e058b3331b3 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -62,7 +62,7 @@ impl ToStr for cat {
 fn print_out(thing: @ToStr, expected: ~str) {
   let actual = thing.to_str();
   debug!("%s", actual);
-  fail_unless!((actual == expected));
+  assert!((actual == expected));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/class-trait-bounded-param.rs b/src/test/run-pass/class-trait-bounded-param.rs
index e525312d6da..f4fd548a8e4 100644
--- a/src/test/run-pass/class-trait-bounded-param.rs
+++ b/src/test/run-pass/class-trait-bounded-param.rs
@@ -31,5 +31,5 @@ pub fn main() {
     let m = int_hash();
     m.insert(1, 2);
     m.insert(3, 4);
-    fail_unless!(iter::to_vec(keys(m)) == ~[1, 3]);
+    assert!(iter::to_vec(keys(m)) == ~[1, 3]);
 }
diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs
index 2999f38caec..6a8a47990b8 100644
--- a/src/test/run-pass/classes-cross-crate.rs
+++ b/src/test/run-pass/classes-cross-crate.rs
@@ -16,7 +16,7 @@ use cci_class_4::kitties::*;
 pub fn main() {
     let mut nyan = cat(0u, 2, ~"nyan");
     nyan.eat();
-    fail_unless!((!nyan.eat()));
+    assert!((!nyan.eat()));
     for uint::range(1u, 10u) |_i| { nyan.speak(); };
-    fail_unless!((nyan.eat()));
+    assert!((nyan.eat()));
 }
diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs
index b1deb5b5e1a..6c35d113e0e 100644
--- a/src/test/run-pass/classes-simple-cross-crate.rs
+++ b/src/test/run-pass/classes-simple-cross-crate.rs
@@ -16,6 +16,6 @@ use cci_class::kitties::*;
 pub fn main() {
   let nyan : cat = cat(52u, 99);
   let kitty = cat(1000u, 2);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
 }
diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs
index bb2da08d5a1..cd318ab6c6b 100644
--- a/src/test/run-pass/classes-simple-method.rs
+++ b/src/test/run-pass/classes-simple-method.rs
@@ -28,7 +28,7 @@ fn cat(in_x : uint, in_y : int) -> cat {
 pub fn main() {
   let mut nyan : cat = cat(52u, 99);
   let mut kitty = cat(1000u, 2);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
   nyan.speak();
 }
diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs
index 850e34db6d1..0af281bdce4 100644
--- a/src/test/run-pass/classes-simple.rs
+++ b/src/test/run-pass/classes-simple.rs
@@ -24,6 +24,6 @@ fn cat(in_x : uint, in_y : int) -> cat {
 pub fn main() {
   let mut nyan : cat = cat(52u, 99);
   let mut kitty = cat(1000u, 2);
-  fail_unless!((nyan.how_hungry == 99));
-  fail_unless!((kitty.how_hungry == 2));
+  assert!((nyan.how_hungry == 99));
+  assert!((kitty.how_hungry == 2));
 }
diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs
index 136573fe05b..52346904141 100644
--- a/src/test/run-pass/classes.rs
+++ b/src/test/run-pass/classes.rs
@@ -51,7 +51,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
 pub fn main() {
   let mut nyan = cat(0u, 2, ~"nyan");
   nyan.eat();
-  fail_unless!((!nyan.eat()));
+  assert!((!nyan.eat()));
   for uint::range(1u, 10u) |_i| { nyan.speak(); };
-  fail_unless!((nyan.eat()));
+  assert!((nyan.eat()));
 }
diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs
index 84bcc663970..41f76b1b4f2 100644
--- a/src/test/run-pass/cleanup-copy-mode.rs
+++ b/src/test/run-pass/cleanup-copy-mode.rs
@@ -12,7 +12,7 @@
 fn adder(+x: @int, +y: @int) -> int { return *x + *y; }
 fn failer() -> @int { fail!(); }
 pub fn main() {
-    fail_unless!(result::is_err(&task::try(|| {
+    assert!(result::is_err(&task::try(|| {
         adder(@2, failer()); ()
     })));
 }
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
index 08ff8b1ab4f..f0734e285b2 100644
--- a/src/test/run-pass/clone-with-exterior.rs
+++ b/src/test/run-pass/clone-with-exterior.rs
@@ -13,8 +13,8 @@
 extern mod std;
 
 fn f(x : @{a:int, b:int}) {
-    fail_unless!((x.a == 10));
-    fail_unless!((x.b == 12));
+    assert!((x.a == 10));
+    assert!((x.b == 12));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs
index 5a853d9fe21..0cff05ed19f 100644
--- a/src/test/run-pass/close-over-big-then-small-data.rs
+++ b/src/test/run-pass/close-over-big-then-small-data.rs
@@ -24,6 +24,6 @@ fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) {
 pub fn main() {
     let (a, b) = f(22_u64, 44u16)();
     debug!("a=%? b=%?", a, b);
-    fail_unless!(a == 22u64);
-    fail_unless!(b == 44u16);
+    assert!(a == 22u64);
+    assert!(b == 44u16);
 }
diff --git a/src/test/run-pass/closure-inference.rs b/src/test/run-pass/closure-inference.rs
index e61636a323a..6cdb8f393d5 100644
--- a/src/test/run-pass/closure-inference.rs
+++ b/src/test/run-pass/closure-inference.rs
@@ -16,5 +16,5 @@ fn apply<A>(f: &fn(A) -> A, v: A) -> A { f(v) }
 
 pub fn main() {
     let f = {|i| foo(i)};
-    fail_unless!(apply(f, 2) == 3);
+    assert!(apply(f, 2) == 3);
 }
diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs
index 05926761897..4e297239445 100644
--- a/src/test/run-pass/closure-inference2.rs
+++ b/src/test/run-pass/closure-inference2.rs
@@ -12,6 +12,6 @@
 
 pub fn main() {
     let f = {|i| i};
-    fail_unless!(f(2) == 2);
-    fail_unless!(f(5) == 5);
+    assert!(f(2) == 2);
+    assert!(f(5) == 5);
 }
diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
index 12ca00fedd3..c4bed1e7d7d 100644
--- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs
@@ -12,5 +12,5 @@ fn foo(speaker: &const SpeechMaker) -> uint {
 
 pub fn main() {
     let mut lincoln = SpeechMaker {speeches: 22};
-    fail_unless!(foo(&const lincoln) == 55);
+    assert!(foo(&const lincoln) == 55);
 }
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index 7dcf49ef1ac..1511eab8241 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -14,7 +14,7 @@ fn bip(v: &[uint]) -> ~[uint] {
 
 pub fn main() {
     let mut the_vec = ~[1, 2, 3, 100];
-    fail_unless!(the_vec == foo(the_vec));
-    fail_unless!(the_vec == bar(the_vec));
-    fail_unless!(the_vec == bip(the_vec));
+    assert!(the_vec == foo(the_vec));
+    assert!(the_vec == bar(the_vec));
+    assert!(the_vec == bip(the_vec));
 }
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
index f89a59ff022..bfc1de4d1e7 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs
@@ -11,5 +11,5 @@ fn bar(v: &mut [uint]) {
 pub fn main() {
     let mut the_vec = ~[1, 2, 3, 100];
     bar(the_vec);
-    fail_unless!(the_vec == ~[100, 3, 2, 1]);
+    assert!(the_vec == ~[100, 3, 2, 1]);
 }
diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
index c656dfd1530..0e67532d7a1 100644
--- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs
@@ -17,5 +17,5 @@ fn bar(v: &mut [uint]) {
 pub fn main() {
     let mut the_vec = ~[1, 2, 3, 100];
     bar(the_vec);
-    fail_unless!(the_vec == ~[100, 3, 2, 1]);
+    assert!(the_vec == ~[100, 3, 2, 1]);
 }
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index 601bae85d4f..a01b06d4d7c 100644
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -17,7 +17,7 @@ pub fn main() {
     let y = p.recv();
     error!("received");
     error!(y);
-    fail_unless!((y == 10));
+    assert!((y == 10));
 }
 
 fn child(c: &Chan<int>) {
diff --git a/src/test/run-pass/compare-generic-enums.rs b/src/test/run-pass/compare-generic-enums.rs
index 9c91bad0df7..c6f4fecf8ac 100644
--- a/src/test/run-pass/compare-generic-enums.rs
+++ b/src/test/run-pass/compare-generic-enums.rs
@@ -15,8 +15,8 @@ fn cmp(x: Option<an_int>, y: Option<int>) -> bool {
 }
 
 pub fn main() {
-    fail_unless!(!cmp(Some(3), None));
-    fail_unless!(!cmp(Some(3), Some(4)));
-    fail_unless!(cmp(Some(3), Some(3)));
-    fail_unless!(cmp(None, None));
+    assert!(!cmp(Some(3), None));
+    assert!(!cmp(Some(3), Some(4)));
+    assert!(cmp(Some(3), Some(3)));
+    assert!(cmp(None, None));
 }
diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs
index 194f0e71b17..609bfe7a4cb 100644
--- a/src/test/run-pass/conditional-compile.rs
+++ b/src/test/run-pass/conditional-compile.rs
@@ -88,7 +88,7 @@ pub fn main() { fail!() }
 pub fn main() {
     // Exercise some of the configured items in ways that wouldn't be possible
     // if they had the bogus definition
-    fail_unless!((b));
+    assert!((b));
     let x: t = true;
     let y: tg = bar;
 
@@ -104,7 +104,7 @@ fn test_in_fn_ctxt() {
     #[cfg(bogus)]
     static i: int = 0;
     static i: int = 1;
-    fail_unless!((i == 1));
+    assert!((i == 1));
 }
 
 mod test_foreign_items {
diff --git a/src/test/run-pass/const-autoderef-newtype.rs b/src/test/run-pass/const-autoderef-newtype.rs
index a157c46403b..021196bf707 100644
--- a/src/test/run-pass/const-autoderef-newtype.rs
+++ b/src/test/run-pass/const-autoderef-newtype.rs
@@ -13,5 +13,5 @@ static C0: S = S([3]);
 static C1: int = C0[0];
 
 pub fn main() {
-    fail_unless!(C1 == 3);
+    assert!(C1 == 3);
 }
diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs
index 572b961b2f8..a7f9b57718c 100644
--- a/src/test/run-pass/const-autoderef.rs
+++ b/src/test/run-pass/const-autoderef.rs
@@ -14,6 +14,6 @@ static C: &'static &'static &'static &'static [u8, ..1] = & & & &A;
 static D: u8 = (&C)[0];
 
 pub fn main() {
-    fail_unless!(B == A[0]);
-    fail_unless!(D == A[0]);
+    assert!(B == A[0]);
+    assert!(D == A[0]);
 }
diff --git a/src/test/run-pass/const-big-enum.rs b/src/test/run-pass/const-big-enum.rs
index 97544da41c0..3aa7fd475b0 100644
--- a/src/test/run-pass/const-big-enum.rs
+++ b/src/test/run-pass/const-big-enum.rs
@@ -22,13 +22,13 @@ pub fn main() {
         _ => fail!()
     }
     match Y {
-        Bar(s) => fail_unless!(s == 2654435769),
+        Bar(s) => assert!(s == 2654435769),
         _ => fail!()
     }
     match Z {
         Quux(d,h) => {
-            fail_unless!((d == 0x123456789abcdef0));
-            fail_unless!((h == 0x1234));
+            assert!((d == 0x123456789abcdef0));
+            assert!((h == 0x1234));
         }
         _ => fail!()
     }
diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs
index f6f0e6ef370..ea5533da14d 100644
--- a/src/test/run-pass/const-cast-ptr-int.rs
+++ b/src/test/run-pass/const-cast-ptr-int.rs
@@ -11,5 +11,5 @@
 static a: *u8 = 0 as *u8;
 
 pub fn main() {
-    fail_unless!(a == ptr::null());
+    assert!(a == ptr::null());
 }
diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs
index 981a8a94b09..d35ad9d2da3 100644
--- a/src/test/run-pass/const-cast.rs
+++ b/src/test/run-pass/const-cast.rs
@@ -16,6 +16,6 @@ static a: &'static int = &10;
 static b: *int = a as *int;
 
 pub fn main() {
-    fail_unless!(x as *libc::c_void == y);
-    fail_unless!(a as *int == b);
+    assert!(x as *libc::c_void == y);
+    assert!(a as *int == b);
 }
diff --git a/src/test/run-pass/const-const.rs b/src/test/run-pass/const-const.rs
index 3f8a7da4c14..e68bf8a74c3 100644
--- a/src/test/run-pass/const-const.rs
+++ b/src/test/run-pass/const-const.rs
@@ -12,5 +12,5 @@ static a: int = 1;
 static b: int = a + 2;
 
 pub fn main() {
-    fail_unless!(b == 3);
+    assert!(b == 3);
 }
diff --git a/src/test/run-pass/const-contents.rs b/src/test/run-pass/const-contents.rs
index 379089cc2a2..19ce5b3713d 100644
--- a/src/test/run-pass/const-contents.rs
+++ b/src/test/run-pass/const-contents.rs
@@ -18,10 +18,10 @@ static notb : bool = !true;
 static neg : int = -(1);
 
 pub fn main() {
-    fail_unless!((lsl == 4));
-    fail_unless!((add == 3));
-    fail_unless!((addf == 3.0f));
-    fail_unless!((not == -1));
-    fail_unless!((notb == false));
-    fail_unless!((neg == -1));
+    assert!((lsl == 4));
+    assert!((add == 3));
+    assert!((addf == 3.0f));
+    assert!((not == -1));
+    assert!((notb == false));
+    assert!((neg == -1));
 }
diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs
index 130f43cfddd..55975d364c8 100644
--- a/src/test/run-pass/const-cross-crate-const.rs
+++ b/src/test/run-pass/const-cross-crate-const.rs
@@ -17,9 +17,9 @@ static a: uint = cci_const::uint_val;
 static b: uint = cci_const::uint_expr + 5;
 
 fn main() {
-    fail_unless!(a == 12);
+    assert!(a == 12);
     let foo2 = a;
-    fail_unless!(foo2 == cci_const::uint_val);
-    fail_unless!(b == cci_const::uint_expr + 5);
-    fail_unless!(foo == cci_const::foopy);
+    assert!(foo2 == cci_const::uint_val);
+    assert!(b == cci_const::uint_expr + 5);
+    assert!(foo == cci_const::foopy);
 }
diff --git a/src/test/run-pass/const-cross-crate-extern.rs b/src/test/run-pass/const-cross-crate-extern.rs
index 67bae91b26e..bac84d12e4c 100644
--- a/src/test/run-pass/const-cross-crate-extern.rs
+++ b/src/test/run-pass/const-cross-crate-extern.rs
@@ -16,5 +16,5 @@ use cci_const::bar;
 static foo: *u8 = bar;
 
 pub fn main() {
-    fail_unless!(foo == cci_const::bar);
+    assert!(foo == cci_const::bar);
 }
diff --git a/src/test/run-pass/const-deref.rs b/src/test/run-pass/const-deref.rs
index a69ca9cb939..ee98e60f4d6 100644
--- a/src/test/run-pass/const-deref.rs
+++ b/src/test/run-pass/const-deref.rs
@@ -15,6 +15,6 @@ static E: &'static S = &S(C);
 static F: int = ***E;
 
 pub fn main() {
-    fail_unless!(D == 1000);
-    fail_unless!(F == 1000);
+    assert!(D == 1000);
+    assert!(F == 1000);
 }
diff --git a/src/test/run-pass/const-enum-cast.rs b/src/test/run-pass/const-enum-cast.rs
index 800800a307b..89990e9d892 100644
--- a/src/test/run-pass/const-enum-cast.rs
+++ b/src/test/run-pass/const-enum-cast.rs
@@ -20,12 +20,12 @@ pub fn main () {
     let a2 = B2 as int;
     let a3 = A2 as float;
     let a4 = B2 as float;
-    fail_unless!(c1 == 1);
-    fail_unless!(c2 == 2);
-    fail_unless!(c3 == 1.0);
-    fail_unless!(c4 == 2.0);
-    fail_unless!(a1 == 1);
-    fail_unless!(a2 == 2);
-    fail_unless!(a3 == 1.0);
-    fail_unless!(a4 == 2.0);
+    assert!(c1 == 1);
+    assert!(c2 == 2);
+    assert!(c3 == 1.0);
+    assert!(c4 == 2.0);
+    assert!(a1 == 1);
+    assert!(a2 == 2);
+    assert!(a3 == 1.0);
+    assert!(a4 == 2.0);
 }
diff --git a/src/test/run-pass/const-enum-struct.rs b/src/test/run-pass/const-enum-struct.rs
index 7da171cc006..b6d916a9c38 100644
--- a/src/test/run-pass/const-enum-struct.rs
+++ b/src/test/run-pass/const-enum-struct.rs
@@ -14,6 +14,6 @@ static C: S = S { a: V16(0xDEAD), b: 0x600D, c: 0xBAD };
 
 pub fn main() {
     let n = C.b;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-struct2.rs b/src/test/run-pass/const-enum-struct2.rs
index c24db8414c4..3d9f7fc2044 100644
--- a/src/test/run-pass/const-enum-struct2.rs
+++ b/src/test/run-pass/const-enum-struct2.rs
@@ -14,6 +14,6 @@ static C: S = S { a: V0, b: 0x600D, c: 0xBAD };
 
 pub fn main() {
     let n = C.b;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-structlike.rs b/src/test/run-pass/const-enum-structlike.rs
index 12349eacd29..cc9d24e16db 100644
--- a/src/test/run-pass/const-enum-structlike.rs
+++ b/src/test/run-pass/const-enum-structlike.rs
@@ -18,6 +18,6 @@ static C: E = S1 { u: 23 };
 pub fn main() {
     match C {
         S0 { _ } => fail!(),
-        S1 { u } => fail_unless!(u == 23)
+        S1 { u } => assert!(u == 23)
     }
 }
diff --git a/src/test/run-pass/const-enum-tuple.rs b/src/test/run-pass/const-enum-tuple.rs
index acefd4ff878..ade3dfd6b63 100644
--- a/src/test/run-pass/const-enum-tuple.rs
+++ b/src/test/run-pass/const-enum-tuple.rs
@@ -13,6 +13,6 @@ static C: (E, u16, u16) = (V16(0xDEAD), 0x600D, 0xBAD);
 
 pub fn main() {
     let (_, n, _) = C;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-tuple2.rs b/src/test/run-pass/const-enum-tuple2.rs
index 63f1f41d9ab..14da9438af0 100644
--- a/src/test/run-pass/const-enum-tuple2.rs
+++ b/src/test/run-pass/const-enum-tuple2.rs
@@ -13,6 +13,6 @@ static C: (E, u16, u16) = (V0, 0x600D, 0xBAD);
 
 pub fn main() {
     let (_, n, _) = C;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-tuplestruct.rs b/src/test/run-pass/const-enum-tuplestruct.rs
index b0d321abb09..885664f7ef0 100644
--- a/src/test/run-pass/const-enum-tuplestruct.rs
+++ b/src/test/run-pass/const-enum-tuplestruct.rs
@@ -14,6 +14,6 @@ static C: S = S(V16(0xDEAD), 0x600D, 0xBAD);
 
 pub fn main() {
     let S(_, n, _) = C;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-tuplestruct2.rs b/src/test/run-pass/const-enum-tuplestruct2.rs
index 7fa04af3f9a..ad4befd92d1 100644
--- a/src/test/run-pass/const-enum-tuplestruct2.rs
+++ b/src/test/run-pass/const-enum-tuplestruct2.rs
@@ -14,6 +14,6 @@ static C: S = S(V0, 0x600D, 0xBAD);
 
 pub fn main() {
     let S(_, n, _) = C;
-    fail_unless!(n != 0xBAD);
-    fail_unless!(n == 0x600D);
+    assert!(n != 0xBAD);
+    assert!(n == 0x600D);
 }
diff --git a/src/test/run-pass/const-enum-vec-index.rs b/src/test/run-pass/const-enum-vec-index.rs
index fd11fc42272..01bab077832 100644
--- a/src/test/run-pass/const-enum-vec-index.rs
+++ b/src/test/run-pass/const-enum-vec-index.rs
@@ -19,7 +19,7 @@ pub fn main() {
         _ => fail!()
     }
     match C1 {
-        V1(n) => fail_unless!(n == 0xDEADBEE),
+        V1(n) => assert!(n == 0xDEADBEE),
         _ => fail!()
     }
 }
diff --git a/src/test/run-pass/const-enum-vec-ptr.rs b/src/test/run-pass/const-enum-vec-ptr.rs
index 8d152dca54c..8615356965e 100644
--- a/src/test/run-pass/const-enum-vec-ptr.rs
+++ b/src/test/run-pass/const-enum-vec-ptr.rs
@@ -13,7 +13,7 @@ static C: &'static [E] = &[V0, V1(0xDEADBEE), V0];
 
 pub fn main() {
     match C[1] {
-        V1(n) => fail_unless!(n == 0xDEADBEE),
+        V1(n) => assert!(n == 0xDEADBEE),
         _ => fail!()
     }
     match C[2] { 
diff --git a/src/test/run-pass/const-enum-vector.rs b/src/test/run-pass/const-enum-vector.rs
index 0e92694dde8..7ae2c5a2fee 100644
--- a/src/test/run-pass/const-enum-vector.rs
+++ b/src/test/run-pass/const-enum-vector.rs
@@ -13,7 +13,7 @@ static C: [E, ..3] = [V0, V1(0xDEADBEE), V0];
 
 pub fn main() {
     match C[1] {
-        V1(n) => fail_unless!(n == 0xDEADBEE),
+        V1(n) => assert!(n == 0xDEADBEE),
         _ => fail!()
     }
     match C[2] { 
diff --git a/src/test/run-pass/const-extern-function.rs b/src/test/run-pass/const-extern-function.rs
index 5e7ac4e4518..a9d036f1219 100644
--- a/src/test/run-pass/const-extern-function.rs
+++ b/src/test/run-pass/const-extern-function.rs
@@ -18,6 +18,6 @@ struct S {
 }
 
 pub fn main() {
-    fail_unless!(foopy == f);
-    fail_unless!(f == s.f);
+    assert!(foopy == f);
+    assert!(f == s.f);
 }
diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs
index 658b39509bf..014ec19d565 100644
--- a/src/test/run-pass/const-fields-and-indexing.rs
+++ b/src/test/run-pass/const-fields-and-indexing.rs
@@ -28,7 +28,7 @@ pub fn main() {
     io::println(fmt!("%?", p));
     io::println(fmt!("%?", q));
     io::println(fmt!("%?", t));
-    fail_unless!(p == 3);
-    fail_unless!(q == 3);
-    fail_unless!(t == 20);
+    assert!(p == 3);
+    assert!(q == 3);
+    assert!(t == 20);
 }
diff --git a/src/test/run-pass/const-fn-val.rs b/src/test/run-pass/const-fn-val.rs
index f08fc3be074..544d6714312 100644
--- a/src/test/run-pass/const-fn-val.rs
+++ b/src/test/run-pass/const-fn-val.rs
@@ -17,5 +17,5 @@ struct Bar<'self> { f: &'self fn() -> int }
 static b : Bar<'static> = Bar { f: foo };
 
 pub fn main() {
-    fail_unless!((b.f)() == 0xca7f000d);
+    assert!((b.f)() == 0xca7f000d);
 }
diff --git a/src/test/run-pass/const-negative.rs b/src/test/run-pass/const-negative.rs
index e2add6409f7..e4905d5c532 100644
--- a/src/test/run-pass/const-negative.rs
+++ b/src/test/run-pass/const-negative.rs
@@ -13,5 +13,5 @@
 static toplevel_mod: int = -1;
 
 pub fn main() {
-    fail_unless!(toplevel_mod == -1);
+    assert!(toplevel_mod == -1);
 }
diff --git a/src/test/run-pass/const-nullary-univariant-enum.rs b/src/test/run-pass/const-nullary-univariant-enum.rs
index 75fd2774095..0d0674aa962 100644
--- a/src/test/run-pass/const-nullary-univariant-enum.rs
+++ b/src/test/run-pass/const-nullary-univariant-enum.rs
@@ -15,8 +15,8 @@ enum Foo {
 static X: Foo = Bar;
 
 pub fn main() {
-    fail_unless!(((X as uint) == 0xDEADBEE));
-    fail_unless!(((Y as uint) == 0xDEADBEE));
+    assert!(((X as uint) == 0xDEADBEE));
+    assert!(((Y as uint) == 0xDEADBEE));
 }
 
 static Y: Foo = Bar;
diff --git a/src/test/run-pass/const-rec-and-tup.rs b/src/test/run-pass/const-rec-and-tup.rs
index 77d4521e709..557fa427e43 100644
--- a/src/test/run-pass/const-rec-and-tup.rs
+++ b/src/test/run-pass/const-rec-and-tup.rs
@@ -20,6 +20,6 @@ static y : AnotherPair = AnotherPair{ x: (0xf0f0f0f0_f0f0f0f0,
 
 pub fn main() {
     let (p, _) = y.x;
-    fail_unless!(p == - 1085102592571150096);
+    assert!(p == - 1085102592571150096);
     io::println(fmt!("0x%x", p as uint));
 }
diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs
index a0d16a3ec3a..960faf131e8 100644
--- a/src/test/run-pass/const-region-ptrs-noncopy.rs
+++ b/src/test/run-pass/const-region-ptrs-noncopy.rs
@@ -14,5 +14,5 @@ static x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]);
 static y: &'static Pair<'static> = &Pair {a: 15, b: x};
 
 pub fn main() {
-    fail_unless!(ptr::addr_of(x) == ptr::addr_of(y.b));
+    assert!(ptr::addr_of(x) == ptr::addr_of(y.b));
 }
diff --git a/src/test/run-pass/const-region-ptrs.rs b/src/test/run-pass/const-region-ptrs.rs
index 6c501ebf938..a2bedc85cdd 100644
--- a/src/test/run-pass/const-region-ptrs.rs
+++ b/src/test/run-pass/const-region-ptrs.rs
@@ -18,6 +18,6 @@ static y: &'static Pair<'static> = &Pair {a: 15, b: x};
 pub fn main() {
     io::println(fmt!("x = %?", *x));
     io::println(fmt!("y = {a: %?, b: %?}", y.a, *(y.b)));
-    fail_unless!(*x == 10);
-    fail_unless!(*(y.b) == 10);
+    assert!(*x == 10);
+    assert!(*(y.b) == 10);
 }
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
index 4163748eaee..2f98036a5b1 100644
--- a/src/test/run-pass/const-str-ptr.rs
+++ b/src/test/run-pass/const-str-ptr.rs
@@ -14,9 +14,9 @@ static b: *u8 = c as *u8;
 
 pub fn main() {
     let foo = &a as *u8;
-    fail_unless!(unsafe { str::raw::from_bytes(a) } == ~"hi\x00");
-    fail_unless!(unsafe { str::raw::from_buf(foo) } == ~"hi");
-    fail_unless!(unsafe { str::raw::from_buf(b) } == ~"hi");
-    fail_unless!(unsafe { *b == a[0] });
-    fail_unless!(unsafe { *(&c[0] as *u8) == a[0] });
+    assert!(unsafe { str::raw::from_bytes(a) } == ~"hi\x00");
+    assert!(unsafe { str::raw::from_buf(foo) } == ~"hi");
+    assert!(unsafe { str::raw::from_buf(b) } == ~"hi");
+    assert!(unsafe { *b == a[0] });
+    assert!(unsafe { *(&c[0] as *u8) == a[0] });
 }
diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs
index a826f7bf564..f75b4321e90 100644
--- a/src/test/run-pass/const-struct.rs
+++ b/src/test/run-pass/const-struct.rs
@@ -25,9 +25,9 @@ static y : foo = foo { b:2, c:3, a: 1 };
 static z : &'static foo = &foo { a: 10, b: 22, c: 12 };
 
 pub fn main() {
-    fail_unless!(x.b == 2);
-    fail_unless!(x == y);
-    fail_unless!(z.b == 22);
+    assert!(x.b == 2);
+    assert!(x == y);
+    assert!(z.b == 22);
     io::println(fmt!("0x%x", x.b as uint));
     io::println(fmt!("0x%x", z.c as uint));
 }
diff --git a/src/test/run-pass/const-tuple-struct.rs b/src/test/run-pass/const-tuple-struct.rs
index 857997b29d2..a68e12b7b10 100644
--- a/src/test/run-pass/const-tuple-struct.rs
+++ b/src/test/run-pass/const-tuple-struct.rs
@@ -15,8 +15,8 @@ static X: Bar = Bar(1, 2);
 pub fn main() {
     match X {
         Bar(x, y) => {
-            fail_unless!(x == 1);
-            fail_unless!(y == 2);
+            assert!(x == 1);
+            assert!(y == 2);
         }
     }
 }
diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs
index f99f2c17ca5..517ced302dd 100644
--- a/src/test/run-pass/const-vecs-and-slices.rs
+++ b/src/test/run-pass/const-vecs-and-slices.rs
@@ -14,7 +14,7 @@ static y : &'static [int] = &[1,2,3,4];
 pub fn main() {
     io::println(fmt!("%?", x[1]));
     io::println(fmt!("%?", y[1]));
-    fail_unless!(x[1] == 2);
-    fail_unless!(x[3] == 4);
-    fail_unless!(x[3] == y[3]);
+    assert!(x[1] == 2);
+    assert!(x[3] == 4);
+    assert!(x[3] == y[3]);
 }
diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs
index 5e79838c4b7..408c0e612f4 100644
--- a/src/test/run-pass/consts-in-patterns.rs
+++ b/src/test/run-pass/consts-in-patterns.rs
@@ -18,6 +18,6 @@ pub fn main() {
         BAR => 2,
         _ => 3
     };
-    fail_unless!(y == 2);
+    assert!(y == 2);
 }
 
diff --git a/src/test/run-pass/crateresolve1.rs b/src/test/run-pass/crateresolve1.rs
index 819e8d4901a..1ddb955cee7 100644
--- a/src/test/run-pass/crateresolve1.rs
+++ b/src/test/run-pass/crateresolve1.rs
@@ -16,5 +16,5 @@
 extern mod crateresolve1(vers = "0.2");
 
 pub fn main() {
-    fail_unless!(crateresolve1::f() == 20);
+    assert!(crateresolve1::f() == 20);
 }
diff --git a/src/test/run-pass/crateresolve2.rs b/src/test/run-pass/crateresolve2.rs
index 9312c9c2a51..1ffbf8320e5 100644
--- a/src/test/run-pass/crateresolve2.rs
+++ b/src/test/run-pass/crateresolve2.rs
@@ -15,17 +15,17 @@
 
 mod a {
     extern mod crateresolve2(vers = "0.1");
-    pub fn f() { fail_unless!(crateresolve2::f() == 10); }
+    pub fn f() { assert!(crateresolve2::f() == 10); }
 }
 
 mod b {
     extern mod crateresolve2(vers = "0.2");
-    pub fn f() { fail_unless!(crateresolve2::f() == 20); }
+    pub fn f() { assert!(crateresolve2::f() == 20); }
 }
 
 mod c {
     extern mod crateresolve2(vers = "0.3");
-    pub fn f() { fail_unless!(crateresolve2::f() == 30); }
+    pub fn f() { assert!(crateresolve2::f() == 30); }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/crateresolve3.rs b/src/test/run-pass/crateresolve3.rs
index 51dde6cd9c3..519e67acdd6 100644
--- a/src/test/run-pass/crateresolve3.rs
+++ b/src/test/run-pass/crateresolve3.rs
@@ -17,12 +17,12 @@
 
 mod a {
     extern mod crateresolve3(vers = "0.1");
-    pub fn f() { fail_unless!(crateresolve3::f() == 10); }
+    pub fn f() { assert!(crateresolve3::f() == 10); }
 }
 
 mod b {
     extern mod crateresolve3(vers = "0.2");
-    pub fn f() { fail_unless!(crateresolve3::g() == 20); }
+    pub fn f() { assert!(crateresolve3::g() == 20); }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/crateresolve4.rs b/src/test/run-pass/crateresolve4.rs
index ba35170b147..ead2a2131b0 100644
--- a/src/test/run-pass/crateresolve4.rs
+++ b/src/test/run-pass/crateresolve4.rs
@@ -16,12 +16,12 @@
 
 pub mod a {
     extern mod crateresolve4b(vers = "0.1");
-    pub fn f() { fail_unless!(crateresolve4b::f() == 20); }
+    pub fn f() { assert!(crateresolve4b::f() == 20); }
 }
 
 pub mod b {
     extern mod crateresolve4b(vers = "0.2");
-    pub fn f() { fail_unless!(crateresolve4b::g() == 10); }
+    pub fn f() { assert!(crateresolve4b::g() == 10); }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/crateresolve5.rs b/src/test/run-pass/crateresolve5.rs
index b467da6802e..688853dd9ae 100644
--- a/src/test/run-pass/crateresolve5.rs
+++ b/src/test/run-pass/crateresolve5.rs
@@ -17,8 +17,8 @@ extern mod cr5_2 (name = "crateresolve5", vers = "0.2");
 
 pub fn main() {
     // Structural types can be used between two versions of the same crate
-    fail_unless!(cr5_1::struct_nameval().name == cr5_2::struct_nameval().name);
-    fail_unless!(cr5_1::struct_nameval().val == cr5_2::struct_nameval().val);
+    assert!(cr5_1::struct_nameval().name == cr5_2::struct_nameval().name);
+    assert!(cr5_1::struct_nameval().val == cr5_2::struct_nameval().val);
     // Make sure these are actually two different crates
-    fail_unless!(cr5_1::f() == 10 && cr5_2::f() == 20);
+    assert!(cr5_1::f() == 10 && cr5_2::f() == 20);
 }
diff --git a/src/test/run-pass/crateresolve6.rs b/src/test/run-pass/crateresolve6.rs
index f273b12eae4..0263af55105 100644
--- a/src/test/run-pass/crateresolve6.rs
+++ b/src/test/run-pass/crateresolve6.rs
@@ -18,6 +18,6 @@ extern mod cr6_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
 extern mod cr6_2 (name = "crateresolve_calories", vers = "0.1", calories="200");
 
 pub fn main() {
-    fail_unless!(cr6_1::f() == 100);
-    fail_unless!(cr6_2::f() == 200);
+    assert!(cr6_1::f() == 100);
+    assert!(cr6_2::f() == 200);
 }
diff --git a/src/test/run-pass/crateresolve7.rs b/src/test/run-pass/crateresolve7.rs
index 49d8f27dbd6..b54b5a0983f 100644
--- a/src/test/run-pass/crateresolve7.rs
+++ b/src/test/run-pass/crateresolve7.rs
@@ -16,6 +16,6 @@
 extern mod crateresolve7x;
 
 pub fn main() {
-    fail_unless!(crateresolve7x::a::f() == 100);
-    fail_unless!(crateresolve7x::b::f() == 200);
+    assert!(crateresolve7x::a::f() == 100);
+    assert!(crateresolve7x::b::f() == 200);
 }
diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs
index fceae82e68e..ebb033d188e 100644
--- a/src/test/run-pass/deep.rs
+++ b/src/test/run-pass/deep.rs
@@ -16,4 +16,4 @@ fn f(x: int) -> int {
     if x == 1 { return 1; } else { let y: int = 1 + f(x - 1); return y; }
 }
 
-pub fn main() { fail_unless!((f(5000) == 5000)); }
+pub fn main() { assert!((f(5000) == 5000)); }
diff --git a/src/test/run-pass/deriving-via-extension-c-enum.rs b/src/test/run-pass/deriving-via-extension-c-enum.rs
index 47d088cfc6f..67893ae9c1e 100644
--- a/src/test/run-pass/deriving-via-extension-c-enum.rs
+++ b/src/test/run-pass/deriving-via-extension-c-enum.rs
@@ -18,9 +18,9 @@ enum Foo {
 pub fn main() {
     let a = Bar;
     let b = Bar;
-    fail_unless!(a == b);
-    fail_unless!(!(a != b));
-    fail_unless!(a.eq(&b));
-    fail_unless!(!a.ne(&b));
+    assert!(a == b);
+    assert!(!(a != b));
+    assert!(a.eq(&b));
+    assert!(!a.ne(&b));
 }
 
diff --git a/src/test/run-pass/deriving-via-extension-enum.rs b/src/test/run-pass/deriving-via-extension-enum.rs
index 32f693abf25..7481bae508b 100644
--- a/src/test/run-pass/deriving-via-extension-enum.rs
+++ b/src/test/run-pass/deriving-via-extension-enum.rs
@@ -17,9 +17,9 @@ enum Foo {
 pub fn main() {
     let a = Bar(1, 2);
     let b = Bar(1, 2);
-    fail_unless!(a == b);
-    fail_unless!(!(a != b));
-    fail_unless!(a.eq(&b));
-    fail_unless!(!a.ne(&b));
+    assert!(a == b);
+    assert!(!(a != b));
+    assert!(a.eq(&b));
+    assert!(!a.ne(&b));
 }
 
diff --git a/src/test/run-pass/deriving-via-extension-struct-empty.rs b/src/test/run-pass/deriving-via-extension-struct-empty.rs
index 09ee83870a0..00b0c14369e 100644
--- a/src/test/run-pass/deriving-via-extension-struct-empty.rs
+++ b/src/test/run-pass/deriving-via-extension-struct-empty.rs
@@ -12,6 +12,6 @@
 struct Foo;
 
 pub fn main() {
-  fail_unless!(Foo == Foo);
-  fail_unless!(!(Foo != Foo));
+  assert!(Foo == Foo);
+  assert!(!(Foo != Foo));
 }
\ No newline at end of file
diff --git a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs
index c349600eb99..712767efacf 100644
--- a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs
+++ b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs
@@ -6,7 +6,7 @@ enum S {
 
 pub fn main() {
     let x = X { x: 1, y: 2 };
-    fail_unless!(x == x);
-    fail_unless!(!(x != x));
+    assert!(x == x);
+    assert!(!(x != x));
 }
 
diff --git a/src/test/run-pass/deriving-via-extension-struct-tuple.rs b/src/test/run-pass/deriving-via-extension-struct-tuple.rs
index 35c20c13e93..906d69dbf53 100644
--- a/src/test/run-pass/deriving-via-extension-struct-tuple.rs
+++ b/src/test/run-pass/deriving-via-extension-struct-tuple.rs
@@ -16,11 +16,11 @@ pub fn main() {
   let a2 = Foo(5, 6, ~"abc");
   let b = Foo(5, 7, ~"def");
 
-  fail_unless!(a1 == a1);
-  fail_unless!(a1 == a2);
-  fail_unless!(!(a1 == b));
+  assert!(a1 == a1);
+  assert!(a1 == a2);
+  assert!(!(a1 == b));
 
-  fail_unless!(a1 != b);
-  fail_unless!(!(a1 != a1));
-  fail_unless!(!(a1 != a2));
+  assert!(a1 != b);
+  assert!(!(a1 != a1));
+  assert!(!(a1 != a2));
 }
diff --git a/src/test/run-pass/deriving-via-extension-struct.rs b/src/test/run-pass/deriving-via-extension-struct.rs
index f5cc85c6382..1e004d1a8c0 100644
--- a/src/test/run-pass/deriving-via-extension-struct.rs
+++ b/src/test/run-pass/deriving-via-extension-struct.rs
@@ -18,9 +18,9 @@ struct Foo {
 pub fn main() {
     let a = Foo { x: 1, y: 2, z: 3 };
     let b = Foo { x: 1, y: 2, z: 3 };
-    fail_unless!(a == b);
-    fail_unless!(!(a != b));
-    fail_unless!(a.eq(&b));
-    fail_unless!(!a.ne(&b));
+    assert!(a == b);
+    assert!(!(a != b));
+    assert!(a.eq(&b));
+    assert!(!a.ne(&b));
 }
 
diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs
index 298e30f7ec1..f310643f943 100644
--- a/src/test/run-pass/deriving-via-extension-type-params.rs
+++ b/src/test/run-pass/deriving-via-extension-type-params.rs
@@ -21,9 +21,9 @@ struct Foo<T> {
 pub fn main() {
     let a = Foo { x: 1, y: 2.0, z: 3 };
     let b = Foo { x: 1, y: 2.0, z: 3 };
-    fail_unless!(a == b);
-    fail_unless!(!(a != b));
-    fail_unless!(a.eq(&b));
-    fail_unless!(!a.ne(&b));
+    assert!(a == b);
+    assert!(!(a != b));
+    assert!(a.eq(&b));
+    assert!(!a.ne(&b));
 }
 
diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs
index b7ade51e344..bf1d6e3c060 100644
--- a/src/test/run-pass/div-mod.rs
+++ b/src/test/run-pass/div-mod.rs
@@ -15,14 +15,14 @@
 pub fn main() {
     let x: int = 15;
     let y: int = 5;
-    fail_unless!((x / 5 == 3));
-    fail_unless!((x / 4 == 3));
-    fail_unless!((x / 3 == 5));
-    fail_unless!((x / y == 3));
-    fail_unless!((15 / y == 3));
-    fail_unless!((x % 5 == 0));
-    fail_unless!((x % 4 == 3));
-    fail_unless!((x % 3 == 0));
-    fail_unless!((x % y == 0));
-    fail_unless!((15 % y == 0));
+    assert!((x / 5 == 3));
+    assert!((x / 4 == 3));
+    assert!((x / 3 == 5));
+    assert!((x / y == 3));
+    assert!((15 / y == 3));
+    assert!((x % 5 == 0));
+    assert!((x % 4 == 3));
+    assert!((x % 3 == 0));
+    assert!((x % y == 0));
+    assert!((15 % y == 0));
 }
diff --git a/src/test/run-pass/do-stack.rs b/src/test/run-pass/do-stack.rs
index a37c9ec1812..0444b269cb3 100644
--- a/src/test/run-pass/do-stack.rs
+++ b/src/test/run-pass/do-stack.rs
@@ -11,5 +11,5 @@
 fn f(f: &fn(int)) { f(10) }
 
 pub fn main() {
-    do f() |i| { fail_unless!(i == 10) }
+    do f() |i| { assert!(i == 10) }
 }
diff --git a/src/test/run-pass/do1.rs b/src/test/run-pass/do1.rs
index d993bbd2d3c..735621a19fe 100644
--- a/src/test/run-pass/do1.rs
+++ b/src/test/run-pass/do1.rs
@@ -11,5 +11,5 @@
 fn f(f: @fn(int)) { f(10) }
 
 pub fn main() {
-    do f() |i| { fail_unless!(i == 10) }
+    do f() |i| { assert!(i == 10) }
 }
diff --git a/src/test/run-pass/do2.rs b/src/test/run-pass/do2.rs
index 8995faaf8ba..ee1321e9d00 100644
--- a/src/test/run-pass/do2.rs
+++ b/src/test/run-pass/do2.rs
@@ -11,5 +11,5 @@
 fn f(f: @fn(int) -> int) -> int { f(10) }
 
 pub fn main() {
-    fail_unless!(do f() |i| { i } == 10);
+    assert!(do f() |i| { i } == 10);
 }
diff --git a/src/test/run-pass/do3.rs b/src/test/run-pass/do3.rs
index dee9bd77a91..7cbf49a3486 100644
--- a/src/test/run-pass/do3.rs
+++ b/src/test/run-pass/do3.rs
@@ -11,5 +11,5 @@
 fn f(f: @fn(int) -> int) -> int { f(10) }
 
 pub fn main() {
-    fail_unless!(do f |i| { i } == 10);
+    assert!(do f |i| { i } == 10);
 }
diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs
index 15e68bccba8..476d3f42d6e 100644
--- a/src/test/run-pass/else-if.rs
+++ b/src/test/run-pass/else-if.rs
@@ -12,19 +12,19 @@
 
 pub fn main() {
     if 1 == 2 {
-        fail_unless!((false));
+        assert!((false));
     } else if 2 == 3 {
-        fail_unless!((false));
-    } else if 3 == 4 { fail_unless!((false)); } else { fail_unless!((true)); }
-    if 1 == 2 { fail_unless!((false)); } else if 2 == 2 { fail_unless!((true)); }
+        assert!((false));
+    } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
+    if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
     if 1 == 2 {
-        fail_unless!((false));
+        assert!((false));
     } else if 2 == 2 {
         if 1 == 1 {
-            fail_unless!((true));
-        } else { if 2 == 1 { fail_unless!((false)); } else { fail_unless!((false)); } }
+            assert!((true));
+        } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
     }
     if 1 == 2 {
-        fail_unless!((false));
-    } else { if 1 == 2 { fail_unless!((false)); } else { fail_unless!((true)); } }
+        assert!((false));
+    } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
 }
diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs
index 0589ffc79e0..f1b89f2bb1d 100644
--- a/src/test/run-pass/empty-tag.rs
+++ b/src/test/run-pass/empty-tag.rs
@@ -18,7 +18,7 @@ impl cmp::Eq for chan {
 }
 
 fn wrapper3(i: chan) {
-    fail_unless!(i == chan_t);
+    assert!(i == chan_t);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs
index 5da64367023..e8de422d5ce 100644
--- a/src/test/run-pass/enum-alignment.rs
+++ b/src/test/run-pass/enum-alignment.rs
@@ -21,6 +21,6 @@ pub fn main() {
     let x = Some(0u64);
     match x {
         None => fail!(),
-        Some(ref y) => fail_unless!(is_aligned(y))
+        Some(ref y) => assert!(is_aligned(y))
     }
 }
diff --git a/src/test/run-pass/enum-disr-val-pretty.rs b/src/test/run-pass/enum-disr-val-pretty.rs
index aca9f72d265..39a807789ec 100644
--- a/src/test/run-pass/enum-disr-val-pretty.rs
+++ b/src/test/run-pass/enum-disr-val-pretty.rs
@@ -20,7 +20,7 @@ pub fn main() {
 }
 
 fn test_color(color: color, val: int, name: ~str) {
-    fail_unless!(color as int == val);
-    fail_unless!(color as float == val as float);
+    assert!(color as int == val);
+    assert!(color as float == val as float);
 }
 
diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs
index 869ea6007c2..27a1b951413 100644
--- a/src/test/run-pass/estr-slice.rs
+++ b/src/test/run-pass/estr-slice.rs
@@ -17,12 +17,12 @@ pub fn main() {
     debug!(x);
     debug!(y);
 
-    fail_unless!(x[0] == 'h' as u8);
-    fail_unless!(x[4] == 'o' as u8);
+    assert!(x[0] == 'h' as u8);
+    assert!(x[4] == 'o' as u8);
 
     let z : &str = &"thing";
-    fail_unless!(v == x);
-    fail_unless!(x != z);
+    assert!(v == x);
+    assert!(x != z);
 
     let a = &"aaaa";
     let b = &"bbbb";
@@ -32,27 +32,27 @@ pub fn main() {
 
     debug!(a);
 
-    fail_unless!(a < b);
-    fail_unless!(a <= b);
-    fail_unless!(a != b);
-    fail_unless!(b >= a);
-    fail_unless!(b > a);
+    assert!(a < b);
+    assert!(a <= b);
+    assert!(a != b);
+    assert!(b >= a);
+    assert!(b > a);
 
     debug!(b);
 
-    fail_unless!(a < c);
-    fail_unless!(a <= c);
-    fail_unless!(a != c);
-    fail_unless!(c >= a);
-    fail_unless!(c > a);
+    assert!(a < c);
+    assert!(a <= c);
+    assert!(a != c);
+    assert!(c >= a);
+    assert!(c > a);
 
     debug!(c);
 
-    fail_unless!(c < cc);
-    fail_unless!(c <= cc);
-    fail_unless!(c != cc);
-    fail_unless!(cc >= c);
-    fail_unless!(cc > c);
+    assert!(c < cc);
+    assert!(c <= cc);
+    assert!(c != cc);
+    assert!(cc >= c);
+    assert!(cc > c);
 
     debug!(cc);
 }
diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs
index 4720f29f891..5e23fd0f751 100644
--- a/src/test/run-pass/estr-uniq.rs
+++ b/src/test/run-pass/estr-uniq.rs
@@ -13,6 +13,6 @@ pub fn main() {
     let _y : ~str = ~"there";
     let mut z = ~"thing";
     z = x;
-    fail_unless!(z[0] == ('h' as u8));
-    fail_unless!(z[4] == ('o' as u8));
+    assert!(z[0] == ('h' as u8));
+    assert!(z[4] == ('o' as u8));
 }
diff --git a/src/test/run-pass/evec-internal-boxes.rs b/src/test/run-pass/evec-internal-boxes.rs
index ec5c5f01e15..7b51b803136 100644
--- a/src/test/run-pass/evec-internal-boxes.rs
+++ b/src/test/run-pass/evec-internal-boxes.rs
@@ -13,6 +13,6 @@ pub fn main() {
     let _y : [@int, ..5] = [@1,@2,@3,@4,@5];
     let mut z = [@1,@2,@3,@4,@5];
     z = x;
-    fail_unless!(*z[0] == 1);
-    fail_unless!(*z[4] == 5);
+    assert!(*z[0] == 1);
+    assert!(*z[4] == 5);
 }
diff --git a/src/test/run-pass/evec-internal.rs b/src/test/run-pass/evec-internal.rs
index 1c23d5ac810..39a4397f84e 100644
--- a/src/test/run-pass/evec-internal.rs
+++ b/src/test/run-pass/evec-internal.rs
@@ -18,8 +18,8 @@ pub fn main() {
     let _y : [int, ..5] = [1,2,3,4,5];
     let mut z = [1,2,3,4,5];
     z = x;
-    fail_unless!(z[0] == 1);
-    fail_unless!(z[4] == 5);
+    assert!(z[0] == 1);
+    assert!(z[4] == 5);
 
     let a : [int, ..5] = [1,1,1,1,1];
     let b : [int, ..5] = [2,2,2,2,2];
@@ -27,25 +27,25 @@ pub fn main() {
 
     log(debug, a);
 
-    fail_unless!(a < b);
-    fail_unless!(a <= b);
-    fail_unless!(a != b);
-    fail_unless!(b >= a);
-    fail_unless!(b > a);
+    assert!(a < b);
+    assert!(a <= b);
+    assert!(a != b);
+    assert!(b >= a);
+    assert!(b > a);
 
     log(debug, b);
 
-    fail_unless!(b < c);
-    fail_unless!(b <= c);
-    fail_unless!(b != c);
-    fail_unless!(c >= b);
-    fail_unless!(c > b);
-
-    fail_unless!(a < c);
-    fail_unless!(a <= c);
-    fail_unless!(a != c);
-    fail_unless!(c >= a);
-    fail_unless!(c > a);
+    assert!(b < c);
+    assert!(b <= c);
+    assert!(b != c);
+    assert!(c >= b);
+    assert!(c > b);
+
+    assert!(a < c);
+    assert!(a <= c);
+    assert!(a != c);
+    assert!(c >= a);
+    assert!(c > a);
 
     log(debug, c);
 
diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs
index 0d14670a6db..28bac56b05e 100644
--- a/src/test/run-pass/evec-slice.rs
+++ b/src/test/run-pass/evec-slice.rs
@@ -12,8 +12,8 @@ pub fn main() {
     let x : &[int] = &[1,2,3,4,5];
     let mut z = &[1,2,3,4,5];
     z = x;
-    fail_unless!(z[0] == 1);
-    fail_unless!(z[4] == 5);
+    assert!(z[0] == 1);
+    assert!(z[4] == 5);
 
     let a : &[int] = &[1,1,1,1,1];
     let b : &[int] = &[2,2,2,2,2];
@@ -22,33 +22,33 @@ pub fn main() {
 
     debug!(a);
 
-    fail_unless!(a < b);
-    fail_unless!(a <= b);
-    fail_unless!(a != b);
-    fail_unless!(b >= a);
-    fail_unless!(b > a);
+    assert!(a < b);
+    assert!(a <= b);
+    assert!(a != b);
+    assert!(b >= a);
+    assert!(b > a);
 
     debug!(b);
 
-    fail_unless!(b < c);
-    fail_unless!(b <= c);
-    fail_unless!(b != c);
-    fail_unless!(c >= b);
-    fail_unless!(c > b);
+    assert!(b < c);
+    assert!(b <= c);
+    assert!(b != c);
+    assert!(c >= b);
+    assert!(c > b);
 
-    fail_unless!(a < c);
-    fail_unless!(a <= c);
-    fail_unless!(a != c);
-    fail_unless!(c >= a);
-    fail_unless!(c > a);
+    assert!(a < c);
+    assert!(a <= c);
+    assert!(a != c);
+    assert!(c >= a);
+    assert!(c > a);
 
     debug!(c);
 
-    fail_unless!(a < cc);
-    fail_unless!(a <= cc);
-    fail_unless!(a != cc);
-    fail_unless!(cc >= a);
-    fail_unless!(cc > a);
+    assert!(a < cc);
+    assert!(a <= cc);
+    assert!(a != cc);
+    assert!(cc >= a);
+    assert!(cc > a);
 
     debug!(cc);
 }
diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs
index 2478eed2f0c..486186e9fe0 100644
--- a/src/test/run-pass/exec-env.rs
+++ b/src/test/run-pass/exec-env.rs
@@ -12,5 +12,5 @@
 // exec-env:TEST_EXEC_ENV=22
 
 pub fn main() {
-    fail_unless!(os::getenv(~"TEST_EXEC_ENV") == Some(~"22"));
+    assert!(os::getenv(~"TEST_EXEC_ENV") == Some(~"22"));
 }
diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs
index e22e739f570..fdf733d0314 100644
--- a/src/test/run-pass/explicit-self-generic.rs
+++ b/src/test/run-pass/explicit-self-generic.rs
@@ -38,6 +38,6 @@ pub impl<K,V> LinearMap<K,V> {
 
 pub fn main() {
     let mut m = ~linear_map::<(),()>();
-    fail_unless!(m.len() == 0);
+    assert!(m.len() == 0);
 }
 
diff --git a/src/test/run-pass/explicit-self-objects-box.rs b/src/test/run-pass/explicit-self-objects-box.rs
index 6c981a93d7c..105aad03083 100644
--- a/src/test/run-pass/explicit-self-objects-box.rs
+++ b/src/test/run-pass/explicit-self-objects-box.rs
@@ -18,7 +18,7 @@ struct S {
 
 impl Foo for S {
     fn f(@self) {
-        fail_unless!(self.x == 3);
+        assert!(self.x == 3);
     }
 }
 
diff --git a/src/test/run-pass/explicit-self-objects-simple.rs b/src/test/run-pass/explicit-self-objects-simple.rs
index 1fa054a9060..de2926b0e7e 100644
--- a/src/test/run-pass/explicit-self-objects-simple.rs
+++ b/src/test/run-pass/explicit-self-objects-simple.rs
@@ -18,7 +18,7 @@ struct S {
 
 impl Foo for S {
     fn f(&self) {
-        fail_unless!(self.x == 3);
+        assert!(self.x == 3);
     }
 }
 
diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs
index 2361df4f457..e99a6bbedc0 100644
--- a/src/test/run-pass/explicit-self-objects-uniq.rs
+++ b/src/test/run-pass/explicit-self-objects-uniq.rs
@@ -18,7 +18,7 @@ struct S {
 
 impl Foo for S {
     fn f(~self) {
-        fail_unless!(self.x == 3);
+        assert!(self.x == 3);
     }
 }
 
diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs
index c41fa52bf15..c5b5016572c 100644
--- a/src/test/run-pass/explicit-self.rs
+++ b/src/test/run-pass/explicit-self.rs
@@ -68,13 +68,13 @@ impl Nus for thing { fn f(&self) {} }
 pub fn main() {
 
     let x = @thing(A {a: @10});
-    fail_unless!(x.foo() == 10);
-    fail_unless!(x.quux() == 10);
+    assert!(x.foo() == 10);
+    assert!(x.quux() == 10);
 
     let y = ~thing(A {a: @10});
-    fail_unless!((copy y).bar() == 10);
-    fail_unless!(y.quux() == 10);
+    assert!((copy y).bar() == 10);
+    assert!(y.quux() == 10);
 
     let z = thing(A {a: @11});
-    fail_unless!(z.spam() == 11);
+    assert!(z.spam() == 11);
 }
diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs
index 4634cc4ef11..ba2a7c6104a 100644
--- a/src/test/run-pass/export-unexported-dep.rs
+++ b/src/test/run-pass/export-unexported-dep.rs
@@ -24,7 +24,7 @@ mod foo {
 
     pub fn f() -> t { return t1; }
 
-    pub fn g(v: t) { fail_unless!((v == t1)); }
+    pub fn g(v: t) { assert!((v == t1)); }
 }
 
 pub fn main() { foo::g(foo::f()); }
diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs
index a5ad80a49e7..5439d13fed8 100644
--- a/src/test/run-pass/expr-alt-box.rs
+++ b/src/test/run-pass/expr-alt-box.rs
@@ -16,13 +16,13 @@
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
     let res = match true { true => { @100 } _ => fail!(~"wat") };
-    fail_unless!((*res == 100));
+    assert!((*res == 100));
 }
 
 fn test_str() {
     let res = match true { true => { ~"happy" },
                          _ => fail!(~"not happy at all") };
-    fail_unless!((res == ~"happy"));
+    assert!((res == ~"happy"));
 }
 
 pub fn main() { test_box(); test_str(); }
diff --git a/src/test/run-pass/expr-alt-fail.rs b/src/test/run-pass/expr-alt-fail.rs
index a22afab485c..4391856230f 100644
--- a/src/test/run-pass/expr-alt-fail.rs
+++ b/src/test/run-pass/expr-alt-fail.rs
@@ -10,12 +10,12 @@
 
 fn test_simple() {
     let r = match true { true => { true } false => { fail!() } };
-    fail_unless!((r == true));
+    assert!((r == true));
 }
 
 fn test_box() {
     let r = match true { true => { ~[10] } false => { fail!() } };
-    fail_unless!((r[0] == 10));
+    assert!((r[0] == 10));
 }
 
 pub fn main() { test_simple(); test_box(); }
diff --git a/src/test/run-pass/expr-alt-generic-box1.rs b/src/test/run-pass/expr-alt-generic-box1.rs
index 5d9e317be38..4ea2d0fba9b 100644
--- a/src/test/run-pass/expr-alt-generic-box1.rs
+++ b/src/test/run-pass/expr-alt-generic-box1.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(@T, @T) -> bool;
 
 fn test_generic<T>(expected: @T, eq: compare<T>) {
     let actual: @T = match true { true => { expected }, _ => fail!() };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_box() {
diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs
index 15bfd759059..02227bbc700 100644
--- a/src/test/run-pass/expr-alt-generic-box2.rs
+++ b/src/test/run-pass/expr-alt-generic-box2.rs
@@ -15,7 +15,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
     let actual: T = match true { true => { expected }, _ => fail!(~"wat") };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_vec() {
diff --git a/src/test/run-pass/expr-alt-generic-unique1.rs b/src/test/run-pass/expr-alt-generic-unique1.rs
index 74a88bb5c87..037cda85499 100644
--- a/src/test/run-pass/expr-alt-generic-unique1.rs
+++ b/src/test/run-pass/expr-alt-generic-unique1.rs
@@ -18,7 +18,7 @@ fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
         true => { expected.clone() },
         _ => fail!(~"wat")
     };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_box() {
diff --git a/src/test/run-pass/expr-alt-generic-unique2.rs b/src/test/run-pass/expr-alt-generic-unique2.rs
index c9efe753f57..2d470cd6fcc 100644
--- a/src/test/run-pass/expr-alt-generic-unique2.rs
+++ b/src/test/run-pass/expr-alt-generic-unique2.rs
@@ -18,7 +18,7 @@ fn test_generic<T:Copy+Clone>(expected: T, eq: compare<T>) {
         true => expected.clone(),
         _ => fail!(~"wat")
     };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_vec() {
diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs
index 1c7f907933e..0fcca32cde0 100644
--- a/src/test/run-pass/expr-alt-generic.rs
+++ b/src/test/run-pass/expr-alt-generic.rs
@@ -15,7 +15,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
   let actual: T = match true { true => { expected }, _ => fail!(~"wat") };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_bool() {
diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs
index 03358f2511b..a8cacca4fe8 100644
--- a/src/test/run-pass/expr-alt-struct.rs
+++ b/src/test/run-pass/expr-alt-struct.rs
@@ -18,7 +18,7 @@ struct R { i: int }
 
 fn test_rec() {
     let rs = match true { true => R {i: 100}, _ => fail!() };
-    fail_unless!((rs.i == 100));
+    assert!((rs.i == 100));
 }
 
 enum mood { happy, sad, }
@@ -32,7 +32,7 @@ impl cmp::Eq for mood {
 
 fn test_tag() {
     let rs = match true { true => { happy } false => { sad } };
-    fail_unless!((rs == happy));
+    assert!((rs == happy));
 }
 
 pub fn main() { test_rec(); test_tag(); }
diff --git a/src/test/run-pass/expr-alt-unique.rs b/src/test/run-pass/expr-alt-unique.rs
index 3fa9e84d4b3..dd20840db57 100644
--- a/src/test/run-pass/expr-alt-unique.rs
+++ b/src/test/run-pass/expr-alt-unique.rs
@@ -16,7 +16,7 @@
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
     let res = match true { true => { ~100 }, _ => fail!() };
-    fail_unless!((*res == 100));
+    assert!((*res == 100));
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-alt.rs b/src/test/run-pass/expr-alt.rs
index de18290b7af..a6324b98ebc 100644
--- a/src/test/run-pass/expr-alt.rs
+++ b/src/test/run-pass/expr-alt.rs
@@ -16,14 +16,14 @@
 // Tests for using match as an expression
 fn test_basic() {
     let mut rs: bool = match true { true => { true } false => { false } };
-    fail_unless!((rs));
+    assert!((rs));
     rs = match false { true => { false } false => { true } };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_inferrence() {
     let mut rs = match true { true => { true } false => { false } };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_alt_as_alt_head() {
@@ -34,7 +34,7 @@ fn test_alt_as_alt_head() {
           true => { false }
           false => { true }
         };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_alt_as_block_result() {
@@ -43,7 +43,7 @@ fn test_alt_as_block_result() {
           true => { false }
           false => { match true { true => { true } false => { false } } }
         };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/expr-block-box.rs b/src/test/run-pass/expr-block-box.rs
index a3e55b739af..8385c95d999 100644
--- a/src/test/run-pass/expr-block-box.rs
+++ b/src/test/run-pass/expr-block-box.rs
@@ -12,4 +12,4 @@
 
 
 // -*- rust -*-
-pub fn main() { let x = { @100 }; fail_unless!((*x == 100)); }
+pub fn main() { let x = { @100 }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs
index 9967281612b..a44afac80f4 100644
--- a/src/test/run-pass/expr-block-fn.rs
+++ b/src/test/run-pass/expr-block-fn.rs
@@ -14,7 +14,7 @@ fn test_fn() {
     type t = @fn() -> int;
     fn ten() -> int { return 10; }
     let rs: t = { ten };
-    //fail_unless!((rs() == 10));
+    //assert!((rs() == 10));
 }
 
 pub fn main() { test_fn(); }
diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs
index 6aca1b994d9..5cd8d649e99 100644
--- a/src/test/run-pass/expr-block-generic-box1.rs
+++ b/src/test/run-pass/expr-block-generic-box1.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(@T, @T) -> bool;
 
 fn test_generic<T>(expected: @T, eq: compare<T>) {
     let actual: @T = { expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_box() {
diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs
index 9f2018a12e9..2fa9a9c768b 100644
--- a/src/test/run-pass/expr-block-generic-box2.rs
+++ b/src/test/run-pass/expr-block-generic-box2.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_vec() {
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index a9fe128661d..d00e9b7a78d 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -15,7 +15,7 @@ type compare<T> = @fn(~T, ~T) -> bool;
 
 fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
     let actual: ~T = { expected.clone() };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_box() {
diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs
index 3d5953494ae..e4a5d49736e 100644
--- a/src/test/run-pass/expr-block-generic-unique2.rs
+++ b/src/test/run-pass/expr-block-generic-unique2.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_vec() {
diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs
index c582a30fa25..e507700e6b2 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -17,7 +17,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, eq: compare<T>) {
     let actual: T = { expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_bool() {
diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs
index 474f5a1bf51..0a75d9074c6 100644
--- a/src/test/run-pass/expr-block-slot.rs
+++ b/src/test/run-pass/expr-block-slot.rs
@@ -15,7 +15,7 @@ struct V { v: int }
 
 pub fn main() {
     let a = { let b = A {a: 3}; b };
-    fail_unless!((a.a == 3));
+    assert!((a.a == 3));
     let c = { let d = V {v: 3}; d };
-    fail_unless!((c.v == 3));
+    assert!((c.v == 3));
 }
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index 8b9e77071ea..72151f7abe6 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -12,4 +12,4 @@
 
 
 // -*- rust -*-
-pub fn main() { let x = { ~100 }; fail_unless!((*x == 100)); }
+pub fn main() { let x = { ~100 }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs
index faa36ffa09a..ee5d41fdd32 100644
--- a/src/test/run-pass/expr-block.rs
+++ b/src/test/run-pass/expr-block.rs
@@ -14,15 +14,15 @@
 // -*- rust -*-
 
 // Tests for standalone blocks as expressions
-fn test_basic() { let rs: bool = { true }; fail_unless!((rs)); }
+fn test_basic() { let rs: bool = { true }; assert!((rs)); }
 
 struct RS { v1: int, v2: int }
 
-fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; fail_unless!((rs.v2 == 20)); }
+fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); }
 
 fn test_filled_with_stuff() {
     let rs = { let mut a = 0; while a < 10 { a += 1; } a };
-    fail_unless!((rs == 10));
+    assert!((rs == 10));
 }
 
 pub fn main() { test_basic(); test_rec(); test_filled_with_stuff(); }
diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs
index 287f935eef8..7dc0f8246bf 100644
--- a/src/test/run-pass/expr-copy.rs
+++ b/src/test/run-pass/expr-copy.rs
@@ -19,9 +19,9 @@ struct A { a: int }
 pub fn main() {
     let mut x = A {a: 10};
     f(&mut x);
-    fail_unless!(x.a == 100);
+    assert!(x.a == 100);
     x.a = 20;
     let mut y = copy x;
     f(&mut y);
-    fail_unless!(x.a == 20);
+    assert!(x.a == 20);
 }
diff --git a/src/test/run-pass/expr-elseif-ref.rs b/src/test/run-pass/expr-elseif-ref.rs
index 2bacf914a70..831ddfde445 100644
--- a/src/test/run-pass/expr-elseif-ref.rs
+++ b/src/test/run-pass/expr-elseif-ref.rs
@@ -13,5 +13,5 @@
 pub fn main() {
     let y: @uint = @10u;
     let x = if false { y } else if true { y } else { y };
-    fail_unless!((*y == 10u));
+    assert!((*y == 10u));
 }
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index 5695ea24d83..b7ea721464e 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -10,32 +10,32 @@
 
 fn test_int() {
     fn f() -> int { 10 }
-    fail_unless!((f() == 10));
+    assert!((f() == 10));
 }
 
 fn test_vec() {
     fn f() -> ~[int] { ~[10, 11] }
-    fail_unless!((f()[1] == 11));
+    assert!((f()[1] == 11));
 }
 
 fn test_generic() {
     fn f<T:Copy>(t: T) -> T { t }
-    fail_unless!((f(10) == 10));
+    assert!((f(10) == 10));
 }
 
 fn test_alt() {
     fn f() -> int { match true { false => { 10 } true => { 20 } } }
-    fail_unless!((f() == 20));
+    assert!((f() == 20));
 }
 
 fn test_if() {
     fn f() -> int { if true { 10 } else { 20 } }
-    fail_unless!((f() == 10));
+    assert!((f() == 10));
 }
 
 fn test_block() {
     fn f() -> int { { 10 } }
-    fail_unless!((f() == 10));
+    assert!((f() == 10));
 }
 
 fn test_ret() {
@@ -43,14 +43,14 @@ fn test_ret() {
         return 10 // no semi
 
     }
-    fail_unless!((f() == 10));
+    assert!((f() == 10));
 }
 
 
 // From issue #372
 fn test_372() {
     fn f() -> int { let x = { 3 }; x }
-    fail_unless!((f() == 3));
+    assert!((f() == 3));
 }
 
 fn test_nil() { () }
diff --git a/src/test/run-pass/expr-if-box.rs b/src/test/run-pass/expr-if-box.rs
index 4a38f9986b8..004137d065c 100644
--- a/src/test/run-pass/expr-if-box.rs
+++ b/src/test/run-pass/expr-if-box.rs
@@ -16,12 +16,12 @@
 // Tests for if as expressions returning boxed types
 fn test_box() {
     let rs = if true { @100 } else { @101 };
-    fail_unless!((*rs == 100));
+    assert!((*rs == 100));
 }
 
 fn test_str() {
     let rs = if true { ~"happy" } else { ~"sad" };
-    fail_unless!((rs == ~"happy"));
+    assert!((rs == ~"happy"));
 }
 
 pub fn main() { test_box(); test_str(); }
diff --git a/src/test/run-pass/expr-if-fail.rs b/src/test/run-pass/expr-if-fail.rs
index 813ce4edbae..7e2e0badb36 100644
--- a/src/test/run-pass/expr-if-fail.rs
+++ b/src/test/run-pass/expr-if-fail.rs
@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test_if_fail() { let x = if false { fail!() } else { 10 }; fail_unless!((x == 10)); }
+fn test_if_fail() { let x = if false { fail!() } else { 10 }; assert!((x == 10)); }
 
 fn test_else_fail() {
     let x = if true { 10 } else { fail!() };
-    fail_unless!((x == 10));
+    assert!((x == 10));
 }
 
 fn test_elseif_fail() {
     let x = if false { 0 } else if false { fail!() } else { 10 };
-    fail_unless!((x == 10));
+    assert!((x == 10));
 }
 
 pub fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); }
diff --git a/src/test/run-pass/expr-if-generic-box1.rs b/src/test/run-pass/expr-if-generic-box1.rs
index 036b99b344a..def991adea8 100644
--- a/src/test/run-pass/expr-if-generic-box1.rs
+++ b/src/test/run-pass/expr-if-generic-box1.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(@T, @T) -> bool;
 
 fn test_generic<T>(expected: @T, not_expected: @T, eq: compare<T>) {
     let actual: @T = if true { expected } else { not_expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_box() {
diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs
index 5868f45f3c8..910e0b2da95 100644
--- a/src/test/run-pass/expr-if-generic-box2.rs
+++ b/src/test/run-pass/expr-if-generic-box2.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, not_expected: T, eq: compare<T>) {
     let actual: T = if true { expected } else { not_expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_vec() {
diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs
index f4945a0fa21..8d2ce83c879 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -16,7 +16,7 @@ type compare<T> = @fn(T, T) -> bool;
 
 fn test_generic<T:Copy>(expected: T, not_expected: T, eq: compare<T>) {
     let actual: T = if true { expected } else { not_expected };
-    fail_unless!((eq(expected, actual)));
+    assert!((eq(expected, actual)));
 }
 
 fn test_bool() {
diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs
index 14212347835..b2bbfcaf9a5 100644
--- a/src/test/run-pass/expr-if-struct.rs
+++ b/src/test/run-pass/expr-if-struct.rs
@@ -19,7 +19,7 @@ struct I { i: int }
 
 fn test_rec() {
     let rs = if true { I {i: 100} } else { I {i: 101} };
-    fail_unless!((rs.i == 100));
+    assert!((rs.i == 100));
 }
 
 enum mood { happy, sad, }
@@ -33,7 +33,7 @@ impl cmp::Eq for mood {
 
 fn test_tag() {
     let rs = if true { happy } else { sad };
-    fail_unless!((rs == happy));
+    assert!((rs == happy));
 }
 
 pub fn main() { test_rec(); test_tag(); }
diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs
index 1b635431ba6..9f90ff32f83 100644
--- a/src/test/run-pass/expr-if-unique.rs
+++ b/src/test/run-pass/expr-if-unique.rs
@@ -16,7 +16,7 @@
 // Tests for if as expressions returning boxed types
 fn test_box() {
     let rs = if true { ~100 } else { ~101 };
-    fail_unless!((*rs == 100));
+    assert!((*rs == 100));
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs
index 55958f88ced..54f831e44b6 100644
--- a/src/test/run-pass/expr-if.rs
+++ b/src/test/run-pass/expr-if.rs
@@ -14,43 +14,43 @@
 // -*- rust -*-
 
 // Tests for if as expressions
-fn test_if() { let rs: bool = if true { true } else { false }; fail_unless!((rs)); }
+fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); }
 
 fn test_else() {
     let rs: bool = if false { false } else { true };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_elseif1() {
     let rs: bool = if true { true } else if true { false } else { false };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_elseif2() {
     let rs: bool = if false { false } else if true { true } else { false };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_elseif3() {
     let rs: bool = if false { false } else if false { false } else { true };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_inferrence() {
     let rs = if true { true } else { false };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 fn test_if_as_if_condition() {
     let rs1 = if if false { false } else { true } { true } else { false };
-    fail_unless!((rs1));
+    assert!((rs1));
     let rs2 = if if true { false } else { true } { false } else { true };
-    fail_unless!((rs2));
+    assert!((rs2));
 }
 
 fn test_if_as_block_result() {
     let rs = if true { if false { false } else { true } } else { false };
-    fail_unless!((rs));
+    assert!((rs));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs
index c5d52830686..eef0924f487 100644
--- a/src/test/run-pass/exterior.rs
+++ b/src/test/run-pass/exterior.rs
@@ -14,13 +14,13 @@
 // -*- rust -*-
 struct Point {x: int, y: int, z: int}
 
-fn f(p: @mut Point) { fail_unless!((p.z == 12)); p.z = 13; fail_unless!((p.z == 13)); }
+fn f(p: @mut Point) { assert!((p.z == 12)); p.z = 13; assert!((p.z == 13)); }
 
 pub fn main() {
     let a: Point = Point {x: 10, y: 11, z: 12};
     let b: @mut Point = @mut copy a;
-    fail_unless!((b.z == 12));
+    assert!((b.z == 12));
     f(b);
-    fail_unless!((a.z == 12));
-    fail_unless!((b.z == 13));
+    assert!((a.z == 12));
+    assert!((b.z == 13));
 }
diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs
index cf396695d26..c29eb2613ad 100644
--- a/src/test/run-pass/extern-call-deep.rs
+++ b/src/test/run-pass/extern-call-deep.rs
@@ -33,5 +33,5 @@ fn count(n: uint) -> uint {
 pub fn main() {
     let result = count(1000u);
     debug!("result = %?", result);
-    fail_unless!(result == 1000u);
+    assert!(result == 1000u);
 }
diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs
index 3175ddf9784..4e807f0f169 100644
--- a/src/test/run-pass/extern-call-deep2.rs
+++ b/src/test/run-pass/extern-call-deep2.rs
@@ -36,6 +36,6 @@ pub fn main() {
     do task::spawn {
         let result = count(1000u);
         debug!("result = %?", result);
-        fail_unless!(result == 1000u);
+        assert!(result == 1000u);
     };
 }
diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs
index e4566772556..eafdd3c5e99 100644
--- a/src/test/run-pass/extern-call-scrub.rs
+++ b/src/test/run-pass/extern-call-scrub.rs
@@ -40,6 +40,6 @@ pub fn main() {
     do task::spawn {
         let result = count(12u);
         debug!("result = %?", result);
-        fail_unless!(result == 2048u);
+        assert!(result == 2048u);
     };
 }
diff --git a/src/test/run-pass/extern-call.rs b/src/test/run-pass/extern-call.rs
index d0c75b7c739..6e41f91dcd7 100644
--- a/src/test/run-pass/extern-call.rs
+++ b/src/test/run-pass/extern-call.rs
@@ -33,5 +33,5 @@ fn fact(n: uint) -> uint {
 pub fn main() {
     let result = fact(10u);
     debug!("result = %?", result);
-    fail_unless!(result == 3628800u);
+    assert!(result == 3628800u);
 }
diff --git a/src/test/run-pass/extern-crosscrate.rs b/src/test/run-pass/extern-crosscrate.rs
index 7bc68333f4a..de7dd7e4c8c 100644
--- a/src/test/run-pass/extern-crosscrate.rs
+++ b/src/test/run-pass/extern-crosscrate.rs
@@ -23,5 +23,5 @@ fn fact(n: uint) -> uint {
 pub fn main() {
     let result = fact(10u);
     debug!("result = %?", result);
-    fail_unless!(result == 3628800u);
+    assert!(result == 3628800u);
 }
diff --git a/src/test/run-pass/extern-pass-TwoU64s-ref.rs b/src/test/run-pass/extern-pass-TwoU64s-ref.rs
index f04e9d086e9..87bec86d8de 100644
--- a/src/test/run-pass/extern-pass-TwoU64s-ref.rs
+++ b/src/test/run-pass/extern-pass-TwoU64s-ref.rs
@@ -25,7 +25,7 @@ pub fn main() {
     unsafe {
         let x = TwoU64s {one: 22, two: 23};
         let y = rust_dbg_extern_identity_TwoU64s(x);
-        fail_unless!(x == y);
+        assert!(x == y);
     }
 }
 
diff --git a/src/test/run-pass/extern-pass-TwoU64s.rs b/src/test/run-pass/extern-pass-TwoU64s.rs
index 1937ddaa9f4..fb91d5495e1 100644
--- a/src/test/run-pass/extern-pass-TwoU64s.rs
+++ b/src/test/run-pass/extern-pass-TwoU64s.rs
@@ -26,7 +26,7 @@ pub fn main() {
     unsafe {
         let x = TwoU64s {one: 22, two: 23};
         let y = rust_dbg_extern_identity_TwoU64s(x);
-        fail_unless!(x == y);
+        assert!(x == y);
     }
 }
 
diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs
index 104ea342cd5..f4fa6bde392 100644
--- a/src/test/run-pass/extern-pass-char.rs
+++ b/src/test/run-pass/extern-pass-char.rs
@@ -16,7 +16,7 @@ pub extern {
 
 pub fn main() {
     unsafe {
-        fail_unless!(22_u8 == rust_dbg_extern_identity_u8(22_u8));
+        assert!(22_u8 == rust_dbg_extern_identity_u8(22_u8));
     }
 }
 
diff --git a/src/test/run-pass/extern-pass-double.rs b/src/test/run-pass/extern-pass-double.rs
index afdec4d1002..4e16acb4ad5 100644
--- a/src/test/run-pass/extern-pass-double.rs
+++ b/src/test/run-pass/extern-pass-double.rs
@@ -14,7 +14,7 @@ pub extern {
 
 pub fn main() {
     unsafe {
-        fail_unless!(22.0_f64 == rust_dbg_extern_identity_double(22.0_f64));
+        assert!(22.0_f64 == rust_dbg_extern_identity_double(22.0_f64));
     }
 }
 
diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs
index 0d6220e7b25..14d05f82177 100644
--- a/src/test/run-pass/extern-pass-u32.rs
+++ b/src/test/run-pass/extern-pass-u32.rs
@@ -16,7 +16,7 @@ pub extern {
 
 pub fn main() {
     unsafe {
-        fail_unless!(22_u32 == rust_dbg_extern_identity_u32(22_u32));
+        assert!(22_u32 == rust_dbg_extern_identity_u32(22_u32));
     }
 }
 
diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs
index 31777035238..2b5a03a4d71 100644
--- a/src/test/run-pass/extern-pass-u64.rs
+++ b/src/test/run-pass/extern-pass-u64.rs
@@ -16,7 +16,7 @@ pub extern {
 
 pub fn main() {
     unsafe {
-        fail_unless!(22_u64 == rust_dbg_extern_identity_u64(22_u64));
+        assert!(22_u64 == rust_dbg_extern_identity_u64(22_u64));
     }
 }
 
diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs
index ed1567897eb..e334dabe883 100644
--- a/src/test/run-pass/extern-stress.rs
+++ b/src/test/run-pass/extern-stress.rs
@@ -36,7 +36,7 @@ fn count(n: uint) -> uint {
 pub fn main() {
     for iter::repeat(100u) {
         do task::spawn {
-            fail_unless!(count(5u) == 16u);
+            assert!(count(5u) == 16u);
         };
     }
 }
diff --git a/src/test/run-pass/extern-take-value.rs b/src/test/run-pass/extern-take-value.rs
index 513d9d284d0..c3815cf2a67 100644
--- a/src/test/run-pass/extern-take-value.rs
+++ b/src/test/run-pass/extern-take-value.rs
@@ -20,6 +20,6 @@ pub fn main() {
     let b: *u8 = f;
     let c: *u8 = g;
 
-    fail_unless!(a == b);
-    fail_unless!(a != c);
+    assert!(a == b);
+    assert!(a != c);
 }
diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs
index 4f94193b856..13c3fd44f39 100644
--- a/src/test/run-pass/extern-yield.rs
+++ b/src/test/run-pass/extern-yield.rs
@@ -35,7 +35,7 @@ pub fn main() {
         do task::spawn {
             let result = count(5u);
             debug!("result = %?", result);
-            fail_unless!(result == 16u);
+            assert!(result == 16u);
         };
     }
 }
diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs
index 958e2e1e79e..ec82db8644c 100644
--- a/src/test/run-pass/fact.rs
+++ b/src/test/run-pass/fact.rs
@@ -32,7 +32,7 @@ fn f(x: int) -> int {
 }
 
 pub fn main() {
-    fail_unless!((f(5) == 120));
+    assert!((f(5) == 120));
     // debug!("all done");
 
 }
diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs
index fc03eaf3b03..76b2309085a 100644
--- a/src/test/run-pass/fixed-point-bind-box.rs
+++ b/src/test/run-pass/fixed-point-bind-box.rs
@@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int {
 
 pub fn main() {
     let fact = fix(fact_);
-    fail_unless!((fact(5) == 120));
-    fail_unless!((fact(2) == 2));
+    assert!((fact(5) == 120));
+    assert!((fact(2) == 2));
 }
diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs
index d79cd36d8fc..83060baac51 100644
--- a/src/test/run-pass/fixed-point-bind-unique.rs
+++ b/src/test/run-pass/fixed-point-bind-unique.rs
@@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int {
 
 pub fn main() {
     let fact = fix(fact_);
-    fail_unless!((fact(5) == 120));
-    fail_unless!((fact(2) == 2));
+    assert!((fact(5) == 120));
+    assert!((fact(2) == 2));
 }
diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs
index 8c104f4f88b..5daa525d9b1 100644
--- a/src/test/run-pass/fixed_length_copy.rs
+++ b/src/test/run-pass/fixed_length_copy.rs
@@ -15,6 +15,6 @@
 pub fn main() {
     let arr = [1,2,3];
     let arr2 = arr;
-    fail_unless!((arr[1] == 2));
-    fail_unless!((arr2[2] == 3));
+    assert!((arr[1] == 2));
+    assert!((arr2[2] == 3));
 }
diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs
index a8752f444bf..b3ced135a4f 100644
--- a/src/test/run-pass/fixed_length_vec_glue.rs
+++ b/src/test/run-pass/fixed_length_vec_glue.rs
@@ -14,5 +14,5 @@ pub fn main() {
     let arr = [1,2,3];
     let struc = Struc {a: 13u8, b: arr, c: 42};
     let s = sys::log_str(&struc);
-    fail_unless!((s == ~"{a: 13, b: [1, 2, 3], c: 42}"));
+    assert!((s == ~"{a: 13, b: [1, 2, 3], c: 42}"));
 }
diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs
index 7ae38c45b99..918d45ad492 100644
--- a/src/test/run-pass/float-nan.rs
+++ b/src/test/run-pass/float-nan.rs
@@ -12,80 +12,80 @@ extern mod std;
 
 pub fn main() {
   let nan = float::NaN;
-  fail_unless!((float::is_NaN(nan)));
+  assert!((float::is_NaN(nan)));
 
   let inf = float::infinity;
-  fail_unless!((-inf == float::neg_infinity));
+  assert!((-inf == float::neg_infinity));
 
-  fail_unless!(( nan !=  nan));
-  fail_unless!(( nan != -nan));
-  fail_unless!((-nan != -nan));
-  fail_unless!((-nan !=  nan));
+  assert!(( nan !=  nan));
+  assert!(( nan != -nan));
+  assert!((-nan != -nan));
+  assert!((-nan !=  nan));
 
-  fail_unless!(( nan !=   1.));
-  fail_unless!(( nan !=   0.));
-  fail_unless!(( nan !=  inf));
-  fail_unless!(( nan != -inf));
+  assert!(( nan !=   1.));
+  assert!(( nan !=   0.));
+  assert!(( nan !=  inf));
+  assert!(( nan != -inf));
 
-  fail_unless!((  1. !=  nan));
-  fail_unless!((  0. !=  nan));
-  fail_unless!(( inf !=  nan));
-  fail_unless!((-inf !=  nan));
+  assert!((  1. !=  nan));
+  assert!((  0. !=  nan));
+  assert!(( inf !=  nan));
+  assert!((-inf !=  nan));
 
-  fail_unless!((!( nan ==  nan)));
-  fail_unless!((!( nan == -nan)));
-  fail_unless!((!( nan ==   1.)));
-  fail_unless!((!( nan ==   0.)));
-  fail_unless!((!( nan ==  inf)));
-  fail_unless!((!( nan == -inf)));
-  fail_unless!((!(  1. ==  nan)));
-  fail_unless!((!(  0. ==  nan)));
-  fail_unless!((!( inf ==  nan)));
-  fail_unless!((!(-inf ==  nan)));
-  fail_unless!((!(-nan ==  nan)));
-  fail_unless!((!(-nan == -nan)));
+  assert!((!( nan ==  nan)));
+  assert!((!( nan == -nan)));
+  assert!((!( nan ==   1.)));
+  assert!((!( nan ==   0.)));
+  assert!((!( nan ==  inf)));
+  assert!((!( nan == -inf)));
+  assert!((!(  1. ==  nan)));
+  assert!((!(  0. ==  nan)));
+  assert!((!( inf ==  nan)));
+  assert!((!(-inf ==  nan)));
+  assert!((!(-nan ==  nan)));
+  assert!((!(-nan == -nan)));
 
-  fail_unless!((!( nan >  nan)));
-  fail_unless!((!( nan > -nan)));
-  fail_unless!((!( nan >   0.)));
-  fail_unless!((!( nan >  inf)));
-  fail_unless!((!( nan > -inf)));
-  fail_unless!((!(  0. >  nan)));
-  fail_unless!((!( inf >  nan)));
-  fail_unless!((!(-inf >  nan)));
-  fail_unless!((!(-nan >  nan)));
+  assert!((!( nan >  nan)));
+  assert!((!( nan > -nan)));
+  assert!((!( nan >   0.)));
+  assert!((!( nan >  inf)));
+  assert!((!( nan > -inf)));
+  assert!((!(  0. >  nan)));
+  assert!((!( inf >  nan)));
+  assert!((!(-inf >  nan)));
+  assert!((!(-nan >  nan)));
 
-  fail_unless!((!(nan <   0.)));
-  fail_unless!((!(nan <   1.)));
-  fail_unless!((!(nan <  -1.)));
-  fail_unless!((!(nan <  inf)));
-  fail_unless!((!(nan < -inf)));
-  fail_unless!((!(nan <  nan)));
-  fail_unless!((!(nan < -nan)));
+  assert!((!(nan <   0.)));
+  assert!((!(nan <   1.)));
+  assert!((!(nan <  -1.)));
+  assert!((!(nan <  inf)));
+  assert!((!(nan < -inf)));
+  assert!((!(nan <  nan)));
+  assert!((!(nan < -nan)));
 
-  fail_unless!((!(  0. < nan)));
-  fail_unless!((!(  1. < nan)));
-  fail_unless!((!( -1. < nan)));
-  fail_unless!((!( inf < nan)));
-  fail_unless!((!(-inf < nan)));
-  fail_unless!((!(-nan < nan)));
+  assert!((!(  0. < nan)));
+  assert!((!(  1. < nan)));
+  assert!((!( -1. < nan)));
+  assert!((!( inf < nan)));
+  assert!((!(-inf < nan)));
+  assert!((!(-nan < nan)));
 
-  fail_unless!((float::is_NaN(nan + inf)));
-  fail_unless!((float::is_NaN(nan + -inf)));
-  fail_unless!((float::is_NaN(nan + 0.)));
-  fail_unless!((float::is_NaN(nan + 1.)));
-  fail_unless!((float::is_NaN(nan * 1.)));
-  fail_unless!((float::is_NaN(nan / 1.)));
-  fail_unless!((float::is_NaN(nan / 0.)));
-  fail_unless!((float::is_NaN(0. / 0.)));
-  fail_unless!((float::is_NaN(-inf + inf)));
-  fail_unless!((float::is_NaN(inf - inf)));
+  assert!((float::is_NaN(nan + inf)));
+  assert!((float::is_NaN(nan + -inf)));
+  assert!((float::is_NaN(nan + 0.)));
+  assert!((float::is_NaN(nan + 1.)));
+  assert!((float::is_NaN(nan * 1.)));
+  assert!((float::is_NaN(nan / 1.)));
+  assert!((float::is_NaN(nan / 0.)));
+  assert!((float::is_NaN(0. / 0.)));
+  assert!((float::is_NaN(-inf + inf)));
+  assert!((float::is_NaN(inf - inf)));
 
-  fail_unless!((!float::is_NaN(-1.)));
-  fail_unless!((!float::is_NaN(0.)));
-  fail_unless!((!float::is_NaN(0.1)));
-  fail_unless!((!float::is_NaN(1.)));
-  fail_unless!((!float::is_NaN(inf)));
-  fail_unless!((!float::is_NaN(-inf)));
-  fail_unless!((!float::is_NaN(1./-inf)));
+  assert!((!float::is_NaN(-1.)));
+  assert!((!float::is_NaN(0.)));
+  assert!((!float::is_NaN(0.1)));
+  assert!((!float::is_NaN(1.)));
+  assert!((!float::is_NaN(inf)));
+  assert!((!float::is_NaN(-inf)));
+  assert!((!float::is_NaN(1./-inf)));
 }
diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs
index b9de5c66fe0..d84c4930aa2 100644
--- a/src/test/run-pass/float2.rs
+++ b/src/test/run-pass/float2.rs
@@ -22,13 +22,13 @@ pub fn main() {
     let i = 1.0E7f64;
     let j = 3.1e+9;
     let k = 3.2e-10;
-    fail_unless!((a == b));
-    fail_unless!((c < b));
-    fail_unless!((c == d));
-    fail_unless!((e < g));
-    fail_unless!((f < h));
-    fail_unless!((g == 1000000.0f32));
-    fail_unless!((h == i));
-    fail_unless!((j > k));
-    fail_unless!((k < a));
+    assert!((a == b));
+    assert!((c < b));
+    assert!((c == d));
+    assert!((e < g));
+    assert!((f < h));
+    assert!((g == 1000000.0f32));
+    assert!((h == i));
+    assert!((j > k));
+    assert!((k < a));
 }
diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs
index bbb1ec5bfa7..d1300e7f30c 100644
--- a/src/test/run-pass/floatlits.rs
+++ b/src/test/run-pass/floatlits.rs
@@ -12,9 +12,9 @@
 
 pub fn main() {
     let f = 4.999999999999;
-    fail_unless!((f > 4.90));
-    fail_unless!((f < 5.0));
+    assert!((f > 4.90));
+    assert!((f < 5.0));
     let g = 4.90000000001e-10;
-    fail_unless!((g > 5e-11));
-    fail_unless!((g < 5e-9));
+    assert!((g > 5e-11));
+    assert!((g < 5e-9));
 }
diff --git a/src/test/run-pass/fn-assign-managed-to-bare-1.rs b/src/test/run-pass/fn-assign-managed-to-bare-1.rs
index 9ab6af0ac27..3a6d4486678 100644
--- a/src/test/run-pass/fn-assign-managed-to-bare-1.rs
+++ b/src/test/run-pass/fn-assign-managed-to-bare-1.rs
@@ -14,7 +14,7 @@ fn add(n: int) -> @fn(int) -> int {
 }
 
 pub fn main() {
-      fail_unless!(add(3)(4) == 7);
+      assert!(add(3)(4) == 7);
       let add3 : &fn(int)->int = add(3);
-      fail_unless!(add3(4) == 7);
+      assert!(add3(4) == 7);
 }
diff --git a/src/test/run-pass/fn-assign-managed-to-bare-2.rs b/src/test/run-pass/fn-assign-managed-to-bare-2.rs
index 3d788cd25d7..c7b7770d81f 100644
--- a/src/test/run-pass/fn-assign-managed-to-bare-2.rs
+++ b/src/test/run-pass/fn-assign-managed-to-bare-2.rs
@@ -15,14 +15,14 @@ fn add(n: int) -> @fn(int) -> int {
 
 pub fn main()
 {
-    fail_unless!(add(3)(4) == 7);
+    assert!(add(3)(4) == 7);
 
     let add1 : @fn(int)->int = add(1);
-    fail_unless!(add1(6) == 7);
+    assert!(add1(6) == 7);
 
     let add2 : &(@fn(int)->int) = &add(2);
-    fail_unless!((*add2)(5) == 7);
+    assert!((*add2)(5) == 7);
 
     let add3 : &fn(int)->int = add(3);
-    fail_unless!(add3(4) == 7);
+    assert!(add3(4) == 7);
 }
diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs
index 356777a64d3..7ad7d24df59 100644
--- a/src/test/run-pass/fn-bare-assign.rs
+++ b/src/test/run-pass/fn-bare-assign.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn f(i: int, called: &mut bool) {
-    fail_unless!(i == 10);
+    assert!(i == 10);
     *called = true;
 }
 
@@ -21,5 +21,5 @@ pub fn main() {
     let mut called = false;
     let h = f;
     g(h, &mut called);
-    fail_unless!(called == true);
+    assert!(called == true);
 }
diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs
index 06ec69624c4..424d829b5ea 100644
--- a/src/test/run-pass/fn-bare-size.rs
+++ b/src/test/run-pass/fn-bare-size.rs
@@ -14,6 +14,6 @@ extern mod std;
 
 pub fn main() {
     // Bare functions should just be a pointer
-    fail_unless!(sys::rustrt::size_of::<fn()>() ==
+    assert!(sys::rustrt::size_of::<fn()>() ==
         sys::rustrt::size_of::<int>());
 }
diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs
index 4bfd1756ce6..857a8cdb3d0 100644
--- a/src/test/run-pass/fn-bare-spawn.rs
+++ b/src/test/run-pass/fn-bare-spawn.rs
@@ -15,7 +15,7 @@ fn spawn<T:Owned>(val: T, f: extern fn(T)) {
 }
 
 fn f(+i: int) {
-    fail_unless!(i == 100);
+    assert!(i == 100);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs
index 3f5d3818e1c..dc3f33a1991 100644
--- a/src/test/run-pass/fn-pattern-expected-type.rs
+++ b/src/test/run-pass/fn-pattern-expected-type.rs
@@ -10,8 +10,8 @@
 
 pub fn main() {
     let f: &fn((int,int)) = |(x, y)| {
-        fail_unless!(x == 1);
-        fail_unless!(y == 2);
+        assert!(x == 1);
+        assert!(y == 2);
     };
     f((1, 2));
 }
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 4209791c87f..4c5084d9f1e 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -12,6 +12,6 @@ struct Pair { x: int, y: int }
 
 pub fn main() {
     for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| {
-        fail_unless!((elt.x + elt.y == 30));
+        assert!((elt.x + elt.y == 30));
     }
 }
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index a94131b36c0..b180e502023 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -20,8 +20,8 @@ pub fn main() {
     do two |i| {
         do two |j| { a[p] = 10 * i + j; p += 1; }
     }
-    fail_unless!((a[0] == 0));
-    fail_unless!((a[1] == 1));
-    fail_unless!((a[2] == 10));
-    fail_unless!((a[3] == 11));
+    assert!((a[0] == 0));
+    assert!((a[1] == 1));
+    assert!((a[2] == 10));
+    assert!((a[3] == 11));
 }
diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
index dfee5557124..421ee7ff2b0 100644
--- a/src/test/run-pass/foreach-put-structured.rs
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -23,9 +23,9 @@ pub fn main() {
         let (_0, _1) = p;
         debug!(_0);
         debug!(_1);
-        fail_unless!((_0 + 10 == i));
+        assert!((_0 + 10 == i));
         i += 1;
         j = _1;
     };
-    fail_unless!((j == 45));
+    assert!((j == 45));
 }
diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs
index 7e07232c32f..99848ddfc7b 100644
--- a/src/test/run-pass/foreach-simple-outer-slot.rs
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -17,7 +17,7 @@ pub fn main() {
     do first_ten |i| { debug!("main"); debug!(i); sum = sum + i; }
     debug!("sum");
     debug!(sum);
-    fail_unless!((sum == 45));
+    assert!((sum == 45));
 }
 
 fn first_ten(it: &fn(int)) {
diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs
index 516be9fcda8..08cb8db5131 100644
--- a/src/test/run-pass/foreign-call-no-runtime.rs
+++ b/src/test/run-pass/foreign-call-no-runtime.rs
@@ -19,6 +19,6 @@ pub fn main() {
 extern fn callback(data: libc::uintptr_t) {
     unsafe {
         let data: *int = cast::transmute(data);
-        fail_unless!(*data == 100);
+        assert!(*data == 100);
     }
 }
diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs
index 6d7e0a6cfcc..429e78b9c21 100644
--- a/src/test/run-pass/foreign-fn-linkname.rs
+++ b/src/test/run-pass/foreign-fn-linkname.rs
@@ -29,5 +29,5 @@ fn strlen(str: ~str) -> uint {
 
 pub fn main() {
     let len = strlen(~"Rust");
-    fail_unless!((len == 4u));
+    assert!((len == 4u));
 }
diff --git a/src/test/run-pass/foreign-lib-path.rs b/src/test/run-pass/foreign-lib-path.rs
index 337ec978858..61fc709d949 100644
--- a/src/test/run-pass/foreign-lib-path.rs
+++ b/src/test/run-pass/foreign-lib-path.rs
@@ -22,5 +22,5 @@ mod WHATGOESHERE {
 }
 
 pub fn main() {
-    fail_unless!(IDONTKNOW() == 0x_BAD_DOOD_u32);
+    assert!(IDONTKNOW() == 0x_BAD_DOOD_u32);
 }
diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs
index 5e611b260d0..c2baab090db 100644
--- a/src/test/run-pass/fun-call-variants.rs
+++ b/src/test/run-pass/fun-call-variants.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let a: int = direct(3); // direct
     let b: int = ho(direct); // indirect unbound
 
-    fail_unless!((a == b));
+    assert!((a == b));
 }
diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs
index 659c508e3a3..db39850e74e 100644
--- a/src/test/run-pass/fun-indirect-call.rs
+++ b/src/test/run-pass/fun-indirect-call.rs
@@ -17,5 +17,5 @@ fn f() -> int { return 42; }
 pub fn main() {
     let g: extern fn() -> int = f;
     let i: int = g();
-    fail_unless!((i == 42));
+    assert!((i == 42));
 }
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 3da699640ac..e5aa54534db 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -16,5 +16,5 @@ pub fn main() {
     let expected = @100;
     let actual = id::<@int>(expected);
     debug!(*actual);
-    fail_unless!((*expected == *actual));
+    assert!((*expected == *actual));
 }
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 287fc260bf8..5eb91b31740 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -16,5 +16,5 @@ pub fn main() {
     let expected = ~100;
     let actual = id::<~int>(expected.clone());
     debug!(*actual);
-    fail_unless!((*expected == *actual));
+    assert!((*expected == *actual));
 }
diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs
index 3c4e1a857a7..05062564595 100644
--- a/src/test/run-pass/generic-box.rs
+++ b/src/test/run-pass/generic-box.rs
@@ -16,5 +16,5 @@ struct Box<T> {x: T, y: T, z: T}
 
 pub fn main() {
     let x: @Box<int> = box::<int>(Box{x: 1, y: 2, z: 3});
-    fail_unless!((x.y == 2));
+    assert!((x.y == 2));
 }
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index e58fd884da6..747acca903b 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -24,6 +24,6 @@ pub fn main() {
     let b = f::<int>(10);
     debug!(b.a);
     debug!(b.b);
-    fail_unless!((b.a == 10));
-    fail_unless!((b.b == 10));
+    assert!((b.a == 10));
+    assert!((b.b == 10));
 }
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
index bd7e01d08d4..7708ffad367 100644
--- a/src/test/run-pass/generic-exterior-box.rs
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -17,5 +17,5 @@ fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: @t}; }
 pub fn main() {
     let foo: int = 17;
     let rbfoo: Recbox<int> = reclift::<int>(foo);
-    fail_unless!((*rbfoo.x == foo));
+    assert!((*rbfoo.x == foo));
 }
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index b0da35ac82c..693b83f1102 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -15,5 +15,5 @@ fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
 pub fn main() {
     let foo: int = 17;
     let rbfoo: Recbox<int> = reclift::<int>(foo);
-    fail_unless!((*rbfoo.x == foo));
+    assert!((*rbfoo.x == foo));
 }
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
index 3dbbd62ff7f..7c21bd52d46 100644
--- a/src/test/run-pass/generic-fn-infer.rs
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -16,4 +16,4 @@
 // Issue #45: infer type parameters in function applications
 fn id<T:Copy>(x: T) -> T { return x; }
 
-pub fn main() { let x: int = 42; let y: int = id(x); fail_unless!((x == y)); }
+pub fn main() { let x: int = 42; let y: int = id(x); assert!((x == y)); }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index 4c0248c488f..8108e15ee14 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -25,13 +25,13 @@ pub fn main() {
     let mut q: Triple = Triple {x: 68, y: 69, z: 70};
     y = id::<int>(x);
     debug!(y);
-    fail_unless!((x == y));
+    assert!((x == y));
     b = id::<char>(a);
     debug!(b);
-    fail_unless!((a == b));
+    assert!((a == b));
     q = id::<Triple>(p);
     x = p.z;
     y = q.z;
     debug!(y);
-    fail_unless!((x == y));
+    assert!((x == y));
 }
diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs
index acdd3fc4600..ebfc362c72c 100644
--- a/src/test/run-pass/generic-object.rs
+++ b/src/test/run-pass/generic-object.rs
@@ -25,6 +25,6 @@ impl Foo<int> for S {
 pub fn main() {
     let x = @S { x: 1 };
     let y = x as @Foo<int>;
-    fail_unless!(y.get() == 1);
+    assert!(y.get() == 1);
 }
 
diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs
index 1229f7df544..752dded83c4 100644
--- a/src/test/run-pass/generic-tag-alt.rs
+++ b/src/test/run-pass/generic-tag-alt.rs
@@ -15,7 +15,7 @@ enum foo<T> { arm(T), }
 fn altfoo<T>(f: foo<T>) {
     let mut hit = false;
     match f { arm::<T>(x) => { debug!("in arm"); hit = true; } }
-    fail_unless!((hit));
+    assert!((hit));
 }
 
 pub fn main() { altfoo::<int>(arm::<int>(10)); }
diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs
index 30738ee33fd..42f19e86fe8 100644
--- a/src/test/run-pass/generic-tag-values.rs
+++ b/src/test/run-pass/generic-tag-values.rs
@@ -18,14 +18,14 @@ struct Pair { x: int, y: int }
 
 pub fn main() {
     let nop: noption<int> = some::<int>(5);
-    match nop { some::<int>(n) => { debug!(n); fail_unless!((n == 5)); } }
+    match nop { some::<int>(n) => { debug!(n); assert!((n == 5)); } }
     let nop2: noption<Pair> = some(Pair{x: 17, y: 42});
     match nop2 {
       some(t) => {
         debug!(t.x);
         debug!(t.y);
-        fail_unless!((t.x == 17));
-        fail_unless!((t.y == 42));
+        assert!((t.x == 17));
+        assert!((t.y == 42));
       }
     }
 }
diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs
index ce419ff002f..cd5944ca0f1 100644
--- a/src/test/run-pass/generic-temporary.rs
+++ b/src/test/run-pass/generic-temporary.rs
@@ -12,7 +12,7 @@
 
 fn mk() -> int { return 1; }
 
-fn chk(a: int) { debug!(a); fail_unless!((a == 1)); }
+fn chk(a: int) { debug!(a); assert!((a == 1)); }
 
 fn apply<T>(produce: extern fn() -> T,
             consume: extern fn(T)) {
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index e80bc8da717..212e044dd14 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -12,6 +12,6 @@ fn get_third<T:Copy>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
 
 pub fn main() {
     debug!(get_third((1, 2, 3)));
-    fail_unless!((get_third((1, 2, 3)) == 3));
-    fail_unless!((get_third((5u8, 6u8, 7u8)) == 7u8));
+    assert!((get_third((1, 2, 3)) == 3));
+    assert!((get_third((5u8, 6u8, 7u8)) == 7u8));
 }
diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs
index 0579604faef..8f9208ea917 100644
--- a/src/test/run-pass/generic-type.rs
+++ b/src/test/run-pass/generic-type.rs
@@ -14,6 +14,6 @@ struct Pair<T> {x: T, y: T}
 
 pub fn main() {
     let x: Pair<int> = Pair {x: 10, y: 12};
-    fail_unless!((x.x == 10));
-    fail_unless!((x.y == 12));
+    assert!((x.x == 10));
+    assert!((x.y == 12));
 }
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 98c7c660e69..064e2f54628 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -14,5 +14,5 @@ fn box<T:Copy>(x: Triple<T>) -> ~Triple<T> { return ~x; }
 
 pub fn main() {
     let x: ~Triple<int> = box::<int>(Triple{x: 1, y: 2, z: 3});
-    fail_unless!((x.y == 2));
+    assert!((x.y == 2));
 }
diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs
index 83a6a9170cc..afd018de3bb 100644
--- a/src/test/run-pass/getopts_ref.rs
+++ b/src/test/run-pass/getopts_ref.rs
@@ -20,7 +20,7 @@ pub fn main() {
 
     match getopts(args, opts) {
         result::Ok(ref m)  =>
-            fail_unless!(!opt_present(m, "b")),
+            assert!(!opt_present(m, "b")),
         result::Err(ref f) => fail!(fail_str(copy *f))
     };
 
diff --git a/src/test/run-pass/global-scope.rs b/src/test/run-pass/global-scope.rs
index 272889e5b9a..3dd912dea9a 100644
--- a/src/test/run-pass/global-scope.rs
+++ b/src/test/run-pass/global-scope.rs
@@ -14,7 +14,7 @@ pub fn f() -> int { return 1; }
 
 pub mod foo {
     pub fn f() -> int { return 2; }
-    pub fn g() { fail_unless!((f() == 2)); fail_unless!((::f() == 1)); }
+    pub fn g() { assert!((f() == 2)); assert!((::f() == 1)); }
 }
 
 pub fn main() { return foo::g(); }
diff --git a/src/test/run-pass/guards-not-exhaustive.rs b/src/test/run-pass/guards-not-exhaustive.rs
index 1647fd53353..8f5b288b755 100644
--- a/src/test/run-pass/guards-not-exhaustive.rs
+++ b/src/test/run-pass/guards-not-exhaustive.rs
@@ -9,5 +9,5 @@ fn xyzzy(q: Q) -> uint {
 
 
 pub fn main() {
-    fail_unless!(xyzzy(R(Some(5))) == 0);
+    assert!(xyzzy(R(Some(5))) == 0);
 }
diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs
index 66667487001..8654e4a2a4b 100644
--- a/src/test/run-pass/guards.rs
+++ b/src/test/run-pass/guards.rs
@@ -13,7 +13,7 @@ struct Pair { x: int, y: int }
 pub fn main() {
     let a =
         match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
-    fail_unless!((a == 2));
+    assert!((a == 2));
 
     let b =
         match Pair {x: 10, y: 20} {
@@ -21,5 +21,5 @@ pub fn main() {
           Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
           Pair {x: x, y: y} => { 3 }
         };
-    fail_unless!((b == 2));
+    assert!((b == 2));
 }
diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs
index 71e4b9a8039..af3b724cfe2 100644
--- a/src/test/run-pass/i32-sub.rs
+++ b/src/test/run-pass/i32-sub.rs
@@ -12,4 +12,4 @@
 
 
 // -*- rust -*-
-pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; fail_unless!((x == 400_i32)); }
+pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert!((x == 400_i32)); }
diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs
index ca6254f84c2..9708e04058b 100644
--- a/src/test/run-pass/i8-incr.rs
+++ b/src/test/run-pass/i8-incr.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let y: i8 = -12i8;
     x = x + 1i8;
     x = x - 1i8;
-    fail_unless!((x == y));
+    assert!((x == y));
 }
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index 4fb3a0c1a16..a29b1ff0c69 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -17,5 +17,5 @@ use core::vec::*;
 pub fn main() {
     let mut v = from_elem(0u, 0);
     v = vec::append(v, ~[4, 2]);
-    fail_unless!((reversed(v) == ~[2, 4]));
+    assert!((reversed(v) == ~[2, 4]));
 }
diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
index baaa41f5bba..e9287f35622 100644
--- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs
+++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
@@ -14,19 +14,19 @@ pub fn main() {
       0 .. 1     => { ~"not many" }
       _          => { ~"lots" }
     };
-    fail_unless!(x_message == ~"lots");
+    assert!(x_message == ~"lots");
 
     let y = 2i;
     let y_message = match y {
       0 .. 1     => { ~"not many" }
       _          => { ~"lots" }
     };
-    fail_unless!(y_message == ~"lots");
+    assert!(y_message == ~"lots");
 
     let z = 1u64;
     let z_message = match z {
       0 .. 1     => { ~"not many" }
       _          => { ~"lots" }
     };
-    fail_unless!(z_message == ~"not many");
+    assert!(z_message == ~"not many");
 }
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index 5db8e34c7b5..98919e49a1a 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -37,7 +37,7 @@ fn test_box() {
     {
         let a = @r(i);
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 fn test_rec() {
@@ -45,7 +45,7 @@ fn test_rec() {
     {
         let a = Box {x: r(i)};
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 fn test_tag() {
@@ -57,7 +57,7 @@ fn test_tag() {
     {
         let a = t0(r(i));
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 fn test_tup() {
@@ -65,7 +65,7 @@ fn test_tup() {
     {
         let a = (r(i), 0);
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 fn test_unique() {
@@ -73,7 +73,7 @@ fn test_unique() {
     {
         let a = ~r(i);
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 fn test_box_rec() {
@@ -83,7 +83,7 @@ fn test_box_rec() {
             x: r(i)
         };
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/int-conversion-coherence.rs b/src/test/run-pass/int-conversion-coherence.rs
index d9fcbb4cb3e..235fab107e7 100644
--- a/src/test/run-pass/int-conversion-coherence.rs
+++ b/src/test/run-pass/int-conversion-coherence.rs
@@ -21,6 +21,6 @@ impl foo of plus for uint { fn plus() -> int { self as int + 20 } }
 impl foo of plus for int { fn plus() -> int { self + 10 } }
 
 pub fn main() {
-    fail_unless!(10.plus() == 20);
+    assert!(10.plus() == 20);
 }
 
diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs
index 711e4e9cdf4..9d30c738605 100644
--- a/src/test/run-pass/integral-indexing.rs
+++ b/src/test/run-pass/integral-indexing.rs
@@ -15,16 +15,16 @@
 pub fn main() {
     let v: ~[int] = ~[0, 1, 2, 3, 4, 5];
     let s: ~str = ~"abcdef";
-    fail_unless!((v[3u] == 3));
-    fail_unless!((v[3u8] == 3));
-    fail_unless!((v[3i8] == 3));
-    fail_unless!((v[3u32] == 3));
-    fail_unless!((v[3i32] == 3));
+    assert!((v[3u] == 3));
+    assert!((v[3u8] == 3));
+    assert!((v[3i8] == 3));
+    assert!((v[3u32] == 3));
+    assert!((v[3i32] == 3));
     debug!(v[3u8]);
-    fail_unless!((s[3u] == 'd' as u8));
-    fail_unless!((s[3u8] == 'd' as u8));
-    fail_unless!((s[3i8] == 'd' as u8));
-    fail_unless!((s[3u32] == 'd' as u8));
-    fail_unless!((s[3i32] == 'd' as u8));
+    assert!((s[3u] == 'd' as u8));
+    assert!((s[3u8] == 'd' as u8));
+    assert!((s[3i8] == 'd' as u8));
+    assert!((s[3u32] == 'd' as u8));
+    assert!((s[3i32] == 'd' as u8));
     debug!(s[3u8]);
 }
diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs
index 5d25dafdd06..5d1ed5f8692 100644
--- a/src/test/run-pass/intrinsic-alignment.rs
+++ b/src/test/run-pass/intrinsic-alignment.rs
@@ -25,16 +25,16 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            fail_unless!(::rusti::pref_align_of::<u64>() == 8u);
-            fail_unless!(::rusti::min_align_of::<u64>() == 4u);
+            assert!(::rusti::pref_align_of::<u64>() == 8u);
+            assert!(::rusti::min_align_of::<u64>() == 4u);
         }
     }
 
     #[cfg(target_arch = "x86_64")]
     pub fn main() {
         unsafe {
-            fail_unless!(::rusti::pref_align_of::<u64>() == 8u);
-            fail_unless!(::rusti::min_align_of::<u64>() == 8u);
+            assert!(::rusti::pref_align_of::<u64>() == 8u);
+            assert!(::rusti::min_align_of::<u64>() == 8u);
         }
     }
 }
@@ -44,8 +44,8 @@ mod m {
     #[cfg(target_arch = "x86")]
     pub fn main() {
         unsafe {
-            fail_unless!(::rusti::pref_align_of::<u64>() == 8u);
-            fail_unless!(::rusti::min_align_of::<u64>() == 8u);
+            assert!(::rusti::pref_align_of::<u64>() == 8u);
+            assert!(::rusti::min_align_of::<u64>() == 8u);
         }
     }
 }
diff --git a/src/test/run-pass/intrinsic-atomics-cc.rs b/src/test/run-pass/intrinsic-atomics-cc.rs
index f4025658f7f..da0c7e759f5 100644
--- a/src/test/run-pass/intrinsic-atomics-cc.rs
+++ b/src/test/run-pass/intrinsic-atomics-cc.rs
@@ -18,6 +18,6 @@ pub fn main() {
     unsafe {
         let mut x = 1;
         atomic_xchg(&mut x, 5);
-        fail_unless!(x == 5);
+        assert!(x == 5);
     }
 }
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index 4e571f90602..cd2079667c2 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -33,32 +33,32 @@ pub fn main() {
     unsafe {
         let mut x = ~1;
 
-        fail_unless!(rusti::atomic_cxchg(x, 1, 2) == 1);
-        fail_unless!(*x == 2);
+        assert!(rusti::atomic_cxchg(x, 1, 2) == 1);
+        assert!(*x == 2);
 
-        fail_unless!(rusti::atomic_cxchg_acq(x, 1, 3) == 2);
-        fail_unless!(*x == 2);
+        assert!(rusti::atomic_cxchg_acq(x, 1, 3) == 2);
+        assert!(*x == 2);
 
-        fail_unless!(rusti::atomic_cxchg_rel(x, 2, 1) == 2);
-        fail_unless!(*x == 1);
+        assert!(rusti::atomic_cxchg_rel(x, 2, 1) == 2);
+        assert!(*x == 1);
 
-        fail_unless!(rusti::atomic_xchg(x, 0) == 1);
-        fail_unless!(*x == 0);
+        assert!(rusti::atomic_xchg(x, 0) == 1);
+        assert!(*x == 0);
 
-        fail_unless!(rusti::atomic_xchg_acq(x, 1) == 0);
-        fail_unless!(*x == 1);
+        assert!(rusti::atomic_xchg_acq(x, 1) == 0);
+        assert!(*x == 1);
 
-        fail_unless!(rusti::atomic_xchg_rel(x, 0) == 1);
-        fail_unless!(*x == 0);
+        assert!(rusti::atomic_xchg_rel(x, 0) == 1);
+        assert!(*x == 0);
 
-        fail_unless!(rusti::atomic_xadd(x, 1) == 0);
-        fail_unless!(rusti::atomic_xadd_acq(x, 1) == 1);
-        fail_unless!(rusti::atomic_xadd_rel(x, 1) == 2);
-        fail_unless!(*x == 3);
+        assert!(rusti::atomic_xadd(x, 1) == 0);
+        assert!(rusti::atomic_xadd_acq(x, 1) == 1);
+        assert!(rusti::atomic_xadd_rel(x, 1) == 2);
+        assert!(*x == 3);
 
-        fail_unless!(rusti::atomic_xsub(x, 1) == 3);
-        fail_unless!(rusti::atomic_xsub_acq(x, 1) == 2);
-        fail_unless!(rusti::atomic_xsub_rel(x, 1) == 1);
-        fail_unless!(*x == 0);
+        assert!(rusti::atomic_xsub(x, 1) == 3);
+        assert!(rusti::atomic_xsub_acq(x, 1) == 2);
+        assert!(rusti::atomic_xsub_rel(x, 1) == 1);
+        assert!(*x == 0);
     }
 }
diff --git a/src/test/run-pass/intrinsic-frame-address.rs b/src/test/run-pass/intrinsic-frame-address.rs
index 6c25291c48d..5562d26677d 100644
--- a/src/test/run-pass/intrinsic-frame-address.rs
+++ b/src/test/run-pass/intrinsic-frame-address.rs
@@ -21,7 +21,7 @@ mod rusti {
 pub fn main() {
     unsafe {
         do rusti::frame_address |addr| {
-            fail_unless!(addr.is_not_null());
+            assert!(addr.is_not_null());
         }
     }
 }
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index 7544c89197b..21a471db480 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -21,6 +21,6 @@ pub fn main() {
         let mut x = @1;
         let mut y = @2;
         rusti::move_val(&mut y, x);
-        fail_unless!(*y == 1);
+        assert!(*y == 1);
     }
 }
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 8731b812f4a..75713d8c710 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -40,83 +40,83 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        fail_unless!((ctpop8(0i8) == 0i8));
-        fail_unless!((ctpop16(0i16) == 0i16));
-        fail_unless!((ctpop32(0i32) == 0i32));
-        fail_unless!((ctpop64(0i64) == 0i64));
-
-        fail_unless!((ctpop8(1i8) == 1i8));
-        fail_unless!((ctpop16(1i16) == 1i16));
-        fail_unless!((ctpop32(1i32) == 1i32));
-        fail_unless!((ctpop64(1i64) == 1i64));
-
-        fail_unless!((ctpop8(10i8) == 2i8));
-        fail_unless!((ctpop16(10i16) == 2i16));
-        fail_unless!((ctpop32(10i32) == 2i32));
-        fail_unless!((ctpop64(10i64) == 2i64));
-
-        fail_unless!((ctpop8(100i8) == 3i8));
-        fail_unless!((ctpop16(100i16) == 3i16));
-        fail_unless!((ctpop32(100i32) == 3i32));
-        fail_unless!((ctpop64(100i64) == 3i64));
-
-        fail_unless!((ctpop8(-1i8) == 8i8));
-        fail_unless!((ctpop16(-1i16) == 16i16));
-        fail_unless!((ctpop32(-1i32) == 32i32));
-        fail_unless!((ctpop64(-1i64) == 64i64));
-
-        fail_unless!((ctlz8(0i8) == 8i8));
-        fail_unless!((ctlz16(0i16) == 16i16));
-        fail_unless!((ctlz32(0i32) == 32i32));
-        fail_unless!((ctlz64(0i64) == 64i64));
-
-        fail_unless!((ctlz8(1i8) == 7i8));
-        fail_unless!((ctlz16(1i16) == 15i16));
-        fail_unless!((ctlz32(1i32) == 31i32));
-        fail_unless!((ctlz64(1i64) == 63i64));
-
-        fail_unless!((ctlz8(10i8) == 4i8));
-        fail_unless!((ctlz16(10i16) == 12i16));
-        fail_unless!((ctlz32(10i32) == 28i32));
-        fail_unless!((ctlz64(10i64) == 60i64));
-
-        fail_unless!((ctlz8(100i8) == 1i8));
-        fail_unless!((ctlz16(100i16) == 9i16));
-        fail_unless!((ctlz32(100i32) == 25i32));
-        fail_unless!((ctlz64(100i64) == 57i64));
-
-        fail_unless!((cttz8(-1i8) == 0i8));
-        fail_unless!((cttz16(-1i16) == 0i16));
-        fail_unless!((cttz32(-1i32) == 0i32));
-        fail_unless!((cttz64(-1i64) == 0i64));
+        assert!((ctpop8(0i8) == 0i8));
+        assert!((ctpop16(0i16) == 0i16));
+        assert!((ctpop32(0i32) == 0i32));
+        assert!((ctpop64(0i64) == 0i64));
+
+        assert!((ctpop8(1i8) == 1i8));
+        assert!((ctpop16(1i16) == 1i16));
+        assert!((ctpop32(1i32) == 1i32));
+        assert!((ctpop64(1i64) == 1i64));
+
+        assert!((ctpop8(10i8) == 2i8));
+        assert!((ctpop16(10i16) == 2i16));
+        assert!((ctpop32(10i32) == 2i32));
+        assert!((ctpop64(10i64) == 2i64));
+
+        assert!((ctpop8(100i8) == 3i8));
+        assert!((ctpop16(100i16) == 3i16));
+        assert!((ctpop32(100i32) == 3i32));
+        assert!((ctpop64(100i64) == 3i64));
+
+        assert!((ctpop8(-1i8) == 8i8));
+        assert!((ctpop16(-1i16) == 16i16));
+        assert!((ctpop32(-1i32) == 32i32));
+        assert!((ctpop64(-1i64) == 64i64));
+
+        assert!((ctlz8(0i8) == 8i8));
+        assert!((ctlz16(0i16) == 16i16));
+        assert!((ctlz32(0i32) == 32i32));
+        assert!((ctlz64(0i64) == 64i64));
+
+        assert!((ctlz8(1i8) == 7i8));
+        assert!((ctlz16(1i16) == 15i16));
+        assert!((ctlz32(1i32) == 31i32));
+        assert!((ctlz64(1i64) == 63i64));
+
+        assert!((ctlz8(10i8) == 4i8));
+        assert!((ctlz16(10i16) == 12i16));
+        assert!((ctlz32(10i32) == 28i32));
+        assert!((ctlz64(10i64) == 60i64));
+
+        assert!((ctlz8(100i8) == 1i8));
+        assert!((ctlz16(100i16) == 9i16));
+        assert!((ctlz32(100i32) == 25i32));
+        assert!((ctlz64(100i64) == 57i64));
+
+        assert!((cttz8(-1i8) == 0i8));
+        assert!((cttz16(-1i16) == 0i16));
+        assert!((cttz32(-1i32) == 0i32));
+        assert!((cttz64(-1i64) == 0i64));
         
-        fail_unless!((cttz8(0i8) == 8i8));
-        fail_unless!((cttz16(0i16) == 16i16));
-        fail_unless!((cttz32(0i32) == 32i32));
-        fail_unless!((cttz64(0i64) == 64i64));
-
-        fail_unless!((cttz8(1i8) == 0i8));
-        fail_unless!((cttz16(1i16) == 0i16));
-        fail_unless!((cttz32(1i32) == 0i32));
-        fail_unless!((cttz64(1i64) == 0i64));
-
-        fail_unless!((cttz8(10i8) == 1i8));
-        fail_unless!((cttz16(10i16) == 1i16));
-        fail_unless!((cttz32(10i32) == 1i32));
-        fail_unless!((cttz64(10i64) == 1i64));
-
-        fail_unless!((cttz8(100i8) == 2i8));
-        fail_unless!((cttz16(100i16) == 2i16));
-        fail_unless!((cttz32(100i32) == 2i32));
-        fail_unless!((cttz64(100i64) == 2i64));
-
-        fail_unless!((cttz8(-1i8) == 0i8));
-        fail_unless!((cttz16(-1i16) == 0i16));
-        fail_unless!((cttz32(-1i32) == 0i32));
-        fail_unless!((cttz64(-1i64) == 0i64));
-
-        fail_unless!((bswap16(0x0A0Bi16) == 0x0B0Ai16));
-        fail_unless!((bswap32(0x0ABBCC0Di32) == 0x0DCCBB0Ai32));
-        fail_unless!((bswap64(0x0122334455667708i64) == 0x0877665544332201i64));
+        assert!((cttz8(0i8) == 8i8));
+        assert!((cttz16(0i16) == 16i16));
+        assert!((cttz32(0i32) == 32i32));
+        assert!((cttz64(0i64) == 64i64));
+
+        assert!((cttz8(1i8) == 0i8));
+        assert!((cttz16(1i16) == 0i16));
+        assert!((cttz32(1i32) == 0i32));
+        assert!((cttz64(1i64) == 0i64));
+
+        assert!((cttz8(10i8) == 1i8));
+        assert!((cttz16(10i16) == 1i16));
+        assert!((cttz32(10i32) == 1i32));
+        assert!((cttz64(10i64) == 1i64));
+
+        assert!((cttz8(100i8) == 2i8));
+        assert!((cttz16(100i16) == 2i16));
+        assert!((cttz32(100i32) == 2i32));
+        assert!((cttz64(100i64) == 2i64));
+
+        assert!((cttz8(-1i8) == 0i8));
+        assert!((cttz16(-1i16) == 0i16));
+        assert!((cttz32(-1i32) == 0i32));
+        assert!((cttz64(-1i64) == 0i64));
+
+        assert!((bswap16(0x0A0Bi16) == 0x0B0Ai16));
+        assert!((bswap32(0x0ABBCC0Di32) == 0x0DCCBB0Ai32));
+        assert!((bswap64(0x0122334455667708i64) == 0x0877665544332201i64));
     }
 }
diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs
index b0db48057b1..500f06e0517 100644
--- a/src/test/run-pass/intrinsics-math.rs
+++ b/src/test/run-pass/intrinsics-math.rs
@@ -54,54 +54,54 @@ pub fn main() {
     unsafe {
         use rusti::*;
 
-        fail_unless!((sqrtf32(64f32).fuzzy_eq(&8f32)));
-        fail_unless!((sqrtf64(64f64).fuzzy_eq(&8f64)));
+        assert!((sqrtf32(64f32).fuzzy_eq(&8f32)));
+        assert!((sqrtf64(64f64).fuzzy_eq(&8f64)));
 
-        fail_unless!((powif32(25f32, -2i32).fuzzy_eq(&0.0016f32)));
-        fail_unless!((powif64(23.2f64, 2i32).fuzzy_eq(&538.24f64)));
+        assert!((powif32(25f32, -2i32).fuzzy_eq(&0.0016f32)));
+        assert!((powif64(23.2f64, 2i32).fuzzy_eq(&538.24f64)));
 
-        fail_unless!((sinf32(0f32).fuzzy_eq(&0f32)));
-        fail_unless!((sinf64(f64::consts::pi / 2f64).fuzzy_eq(&1f64)));
+        assert!((sinf32(0f32).fuzzy_eq(&0f32)));
+        assert!((sinf64(f64::consts::pi / 2f64).fuzzy_eq(&1f64)));
 
-        fail_unless!((cosf32(0f32).fuzzy_eq(&1f32)));
-        fail_unless!((cosf64(f64::consts::pi * 2f64).fuzzy_eq(&1f64)));
+        assert!((cosf32(0f32).fuzzy_eq(&1f32)));
+        assert!((cosf64(f64::consts::pi * 2f64).fuzzy_eq(&1f64)));
 
-        fail_unless!((powf32(25f32, -2f32).fuzzy_eq(&0.0016f32)));
-        fail_unless!((powf64(400f64, 0.5f64).fuzzy_eq(&20f64)));
+        assert!((powf32(25f32, -2f32).fuzzy_eq(&0.0016f32)));
+        assert!((powf64(400f64, 0.5f64).fuzzy_eq(&20f64)));
 
-        fail_unless!((fabsf32(expf32(1f32) - f32::consts::e).fuzzy_eq(&0f32)));
-        fail_unless!((expf64(1f64).fuzzy_eq(&f64::consts::e)));
+        assert!((fabsf32(expf32(1f32) - f32::consts::e).fuzzy_eq(&0f32)));
+        assert!((expf64(1f64).fuzzy_eq(&f64::consts::e)));
 
-        fail_unless!((exp2f32(10f32).fuzzy_eq(&1024f32)));
-        fail_unless!((exp2f64(50f64).fuzzy_eq(&1125899906842624f64)));
+        assert!((exp2f32(10f32).fuzzy_eq(&1024f32)));
+        assert!((exp2f64(50f64).fuzzy_eq(&1125899906842624f64)));
 
-        fail_unless!((fabsf32(logf32(f32::consts::e) - 1f32).fuzzy_eq(&0f32)));
-        fail_unless!((logf64(1f64).fuzzy_eq(&0f64)));
+        assert!((fabsf32(logf32(f32::consts::e) - 1f32).fuzzy_eq(&0f32)));
+        assert!((logf64(1f64).fuzzy_eq(&0f64)));
 
-        fail_unless!((log10f32(10f32).fuzzy_eq(&1f32)));
-        fail_unless!((log10f64(f64::consts::e).fuzzy_eq(&f64::consts::log10_e)));
+        assert!((log10f32(10f32).fuzzy_eq(&1f32)));
+        assert!((log10f64(f64::consts::e).fuzzy_eq(&f64::consts::log10_e)));
 
-        fail_unless!((log2f32(8f32).fuzzy_eq(&3f32)));
-        fail_unless!((log2f64(f64::consts::e).fuzzy_eq(&f64::consts::log2_e)));
+        assert!((log2f32(8f32).fuzzy_eq(&3f32)));
+        assert!((log2f64(f64::consts::e).fuzzy_eq(&f64::consts::log2_e)));
       
-        fail_unless!((fmaf32(1.0f32, 2.0f32, 5.0f32).fuzzy_eq(&7.0f32)));
-        fail_unless!((fmaf64(0.0f64, -2.0f64, f64::consts::e).fuzzy_eq(&f64::consts::e)));
+        assert!((fmaf32(1.0f32, 2.0f32, 5.0f32).fuzzy_eq(&7.0f32)));
+        assert!((fmaf64(0.0f64, -2.0f64, f64::consts::e).fuzzy_eq(&f64::consts::e)));
 
-        fail_unless!((fabsf32(-1.0f32).fuzzy_eq(&1.0f32)));
-        fail_unless!((fabsf64(34.2f64).fuzzy_eq(&34.2f64)));
+        assert!((fabsf32(-1.0f32).fuzzy_eq(&1.0f32)));
+        assert!((fabsf64(34.2f64).fuzzy_eq(&34.2f64)));
 
-        fail_unless!((floorf32(3.8f32).fuzzy_eq(&3.0f32)));
-        fail_unless!((floorf64(-1.1f64).fuzzy_eq(&-2.0f64)));
+        assert!((floorf32(3.8f32).fuzzy_eq(&3.0f32)));
+        assert!((floorf64(-1.1f64).fuzzy_eq(&-2.0f64)));
 
         // Causes linker error
         // undefined reference to llvm.ceil.f32/64
-        //fail_unless!((ceilf32(-2.3f32) == -2.0f32));
-        //fail_unless!((ceilf64(3.8f64) == 4.0f64));
+        //assert!((ceilf32(-2.3f32) == -2.0f32));
+        //assert!((ceilf64(3.8f64) == 4.0f64));
       
         // Causes linker error
         // undefined reference to llvm.trunc.f32/64
-        //fail_unless!((truncf32(0.1f32) == 0.0f32));
-        //fail_unless!((truncf64(-0.1f64) == 0.0f64));
+        //assert!((truncf32(0.1f32) == 0.0f32));
+        //assert!((truncf64(-0.1f64) == 0.0f64));
     }
 
 }
diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs
index 111dd43747f..cd15dfa2a0d 100644
--- a/src/test/run-pass/issue-1112.rs
+++ b/src/test/run-pass/issue-1112.rs
@@ -35,10 +35,10 @@ pub fn main() {
 }
 
 fn bar<T>(x: X<T>) {
-    fail_unless!(x.b == 9u8);
-    fail_unless!(x.c == true);
-    fail_unless!(x.d == 10u8);
-    fail_unless!(x.e == 11u16);
-    fail_unless!(x.f == 12u8);
-    fail_unless!(x.g == 13u8);
+    assert!(x.b == 9u8);
+    assert!(x.c == true);
+    assert!(x.d == 10u8);
+    assert!(x.e == 11u16);
+    assert!(x.f == 12u8);
+    assert!(x.g == 13u8);
 }
diff --git a/src/test/run-pass/issue-1458.rs b/src/test/run-pass/issue-1458.rs
index a6556895dda..0677c9dea74 100644
--- a/src/test/run-pass/issue-1458.rs
+++ b/src/test/run-pass/issue-1458.rs
@@ -18,5 +18,5 @@ fn ret_plus_one() -> extern fn(&fn() -> int) -> int {
 
 pub fn main() {
     let z = do (ret_plus_one()) || { 2 };
-    fail_unless!(z == 3);
+    assert!(z == 3);
 }
diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs
index 577d74c4118..c8937a2a628 100644
--- a/src/test/run-pass/issue-1701.rs
+++ b/src/test/run-pass/issue-1701.rs
@@ -24,8 +24,8 @@ fn noise(a: animal) -> Option<~str> {
 }
 
 pub fn main() {
-    fail_unless!(noise(cat(tabby)) == Some(~"meow"));
-    fail_unless!(noise(dog(pug)) == Some(~"woof"));
-    fail_unless!(noise(rabbit(~"Hilbert", upright)) == None);
-    fail_unless!(noise(tiger) == Some(~"roar"));
+    assert!(noise(cat(tabby)) == Some(~"meow"));
+    assert!(noise(dog(pug)) == Some(~"woof"));
+    assert!(noise(rabbit(~"Hilbert", upright)) == None);
+    assert!(noise(tiger) == Some(~"roar"));
 }
diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs
index 7cf255e0172..d5e9e8df91e 100644
--- a/src/test/run-pass/issue-2214.rs
+++ b/src/test/run-pass/issue-2214.rs
@@ -44,5 +44,5 @@ mod m {
 pub fn main() {
   let mut y: int = 5;
   let x: &mut int = &mut y;
-  fail_unless!((lgamma(1.0 as c_double, x) == 0.0 as c_double));
+  assert!((lgamma(1.0 as c_double, x) == 0.0 as c_double));
 }
diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs
index 22e69c92a1a..0be4084b083 100644
--- a/src/test/run-pass/issue-2216.rs
+++ b/src/test/run-pass/issue-2216.rs
@@ -28,5 +28,5 @@ pub fn main() {
     }
 
     error!("%?", x);
-    fail_unless!((x == 42));
+    assert!((x == 42));
 }
diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs
index a571c49c438..29fa357ba1a 100644
--- a/src/test/run-pass/issue-2428.rs
+++ b/src/test/run-pass/issue-2428.rs
@@ -16,5 +16,5 @@ pub fn main() {
         Bar = quux
     }
 
-    fail_unless!((Bar as int == quux));
+    assert!((Bar as int == quux));
 }
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 3acfa744117..35b92d994d2 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -73,7 +73,7 @@ pub mod pipes {
     pub fn send<T:Owned>(mut p: send_packet<T>, +payload: T) {
         let mut p = p.unwrap();
         let mut p = unsafe { uniquify(p) };
-        fail_unless!((*p).payload.is_none());
+        assert!((*p).payload.is_none());
         (*p).payload = Some(payload);
         let old_state = swap_state_rel(&mut (*p).state, full);
         match old_state {
@@ -110,7 +110,7 @@ pub mod pipes {
                 return Some(payload.unwrap())
               }
               terminated => {
-                fail_unless!(old_state == terminated);
+                assert!(old_state == terminated);
                 return None;
               }
             }
diff --git a/src/test/run-pass/issue-2735-2.rs b/src/test/run-pass/issue-2735-2.rs
index 396175716b2..96f76b0fd6b 100644
--- a/src/test/run-pass/issue-2735-2.rs
+++ b/src/test/run-pass/issue-2735-2.rs
@@ -31,5 +31,5 @@ fn defer<'r>(b: &'r mut bool) -> defer<'r> {
 pub fn main() {
     let mut dtor_ran = false;
     let _  = defer(&mut dtor_ran);
-    fail_unless!((dtor_ran));
+    assert!((dtor_ran));
 }
diff --git a/src/test/run-pass/issue-2735-3.rs b/src/test/run-pass/issue-2735-3.rs
index 7b5f19f1434..50e3c946f50 100644
--- a/src/test/run-pass/issue-2735-3.rs
+++ b/src/test/run-pass/issue-2735-3.rs
@@ -31,5 +31,5 @@ fn defer<'r>(b: &'r mut bool) -> defer<'r> {
 pub fn main() {
     let mut dtor_ran = false;
     defer(&mut dtor_ran);
-    fail_unless!((dtor_ran));
+    assert!((dtor_ran));
 }
diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs
index 630448d2782..b9efb441ae7 100644
--- a/src/test/run-pass/issue-2748-b.rs
+++ b/src/test/run-pass/issue-2748-b.rs
@@ -14,6 +14,6 @@ pub fn main() {
     let x = &[1,2,3];
     let y = x;
     let z = thing(x);
-    fail_unless!((z[2] == x[2]));
-    fail_unless!((z[1] == y[1]));
+    assert!((z[2] == x[2]));
+    assert!((z[1] == y[1]));
 }
diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs
index dee2483462d..2560c1ba77e 100644
--- a/src/test/run-pass/issue-2895.rs
+++ b/src/test/run-pass/issue-2895.rs
@@ -22,12 +22,12 @@ impl Drop for Kitty {
 
 #[cfg(target_arch = "x86_64")]
 pub fn main() {
-    fail_unless!((sys::size_of::<Cat>() == 8 as uint));
-    fail_unless!((sys::size_of::<Kitty>() == 16 as uint));
+    assert!((sys::size_of::<Cat>() == 8 as uint));
+    assert!((sys::size_of::<Kitty>() == 16 as uint));
 }
 
 #[cfg(target_arch = "x86")]
 pub fn main() {
-    fail_unless!((sys::size_of::<Cat>() == 4 as uint));
-    fail_unless!((sys::size_of::<Kitty>() == 8 as uint));
+    assert!((sys::size_of::<Cat>() == 4 as uint));
+    assert!((sys::size_of::<Kitty>() == 8 as uint));
 }
diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs
index 84a4083a628..ef7fd691577 100644
--- a/src/test/run-pass/issue-2904.rs
+++ b/src/test/run-pass/issue-2904.rs
@@ -70,14 +70,14 @@ fn read_board_grid<rdr:'static + io::Reader>(+in: rdr) -> ~[~[square]] {
         grid.push(row)
     }
     let width = grid[0].len();
-    for grid.each |row| { fail_unless!(row.len() == width) }
+    for grid.each |row| { assert!(row.len() == width) }
     grid
 }
 
 mod test {
     #[test]
     pub fn trivial_to_str() {
-        fail_unless!(lambda.to_str() == "\\")
+        assert!(lambda.to_str() == "\\")
     }
 
     #[test]
diff --git a/src/test/run-pass/issue-2936.rs b/src/test/run-pass/issue-2936.rs
index 5acae2da1ce..b989be0c182 100644
--- a/src/test/run-pass/issue-2936.rs
+++ b/src/test/run-pass/issue-2936.rs
@@ -34,5 +34,5 @@ fn cbar(x: int) -> cbar {
 
 pub fn main() {
     let x: int = foo::<int, cbar>(cbar(5));
-    fail_unless!(x == 5);
+    assert!(x == 5);
 }
diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs
index 10b845a923d..af8190f32a7 100644
--- a/src/test/run-pass/issue-2989.rs
+++ b/src/test/run-pass/issue-2989.rs
@@ -41,5 +41,5 @@ pub fn main() {
         io::println(fmt!("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint));
     }
 
-    fail_unless!(bools == bools2);
+    assert!(bools == bools2);
 }
diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs
index a218df591c5..aa0625aa110 100644
--- a/src/test/run-pass/issue-3091.rs
+++ b/src/test/run-pass/issue-3091.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let x = 1;
     let y = 1;
-    fail_unless!(&x == &y);
+    assert!(&x == &y);
 }
diff --git a/src/test/run-pass/issue-3168.rs b/src/test/run-pass/issue-3168.rs
index f0e1779ba37..d4eb0793dac 100644
--- a/src/test/run-pass/issue-3168.rs
+++ b/src/test/run-pass/issue-3168.rs
@@ -26,6 +26,6 @@ pub fn main() {
         p3.recv();
     };
     error!("parent tries");
-    fail_unless!(!p.recv().try_send(()));
+    assert!(!p.recv().try_send(()));
     error!("all done!");
 }
diff --git a/src/test/run-pass/issue-3176.rs b/src/test/run-pass/issue-3176.rs
index c1008e581ea..03b1c127c55 100644
--- a/src/test/run-pass/issue-3176.rs
+++ b/src/test/run-pass/issue-3176.rs
@@ -30,6 +30,6 @@ pub fn main() {
         c.send(());
     };  
     error!("parent tries");
-    fail_unless!(!p.recv().try_send(()));
+    assert!(!p.recv().try_send(()));
     error!("all done!");
 }
diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs
index c759ca1ad0f..02e61fc7ce2 100644
--- a/src/test/run-pass/issue-3211.rs
+++ b/src/test/run-pass/issue-3211.rs
@@ -3,6 +3,6 @@ pub fn main() {
     for 4096.times {
         x += 1;
     }
-    fail_unless!(x == 4096);
+    assert!(x == 4096);
     io::println(fmt!("x = %u", x));
 }
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index 6a1f00de21a..9791b6cdc53 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -12,4 +12,4 @@ fn quux<T:Copy>(x: T) -> T { let f = id::<T>; return f(x); }
 
 fn id<T:Copy>(x: T) -> T { return x; }
 
-pub fn main() { fail_unless!((quux(10) == 10)); }
+pub fn main() { assert!((quux(10) == 10)); }
diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs
index b472d3a105b..d79eef46f05 100644
--- a/src/test/run-pass/issue-3424.rs
+++ b/src/test/run-pass/issue-3424.rs
@@ -22,7 +22,7 @@ fn tester()
     let loader: rsrc_loader = |_path| {result::Ok(~"more blah")};
 
     let path = path::from_str("blah");
-    fail_unless!(loader(&path).is_ok());
+    assert!(loader(&path).is_ok());
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-3556.rs b/src/test/run-pass/issue-3556.rs
index 1df86da6cb7..703dcd54f0a 100644
--- a/src/test/run-pass/issue-3556.rs
+++ b/src/test/run-pass/issue-3556.rs
@@ -32,11 +32,11 @@ fn check_strs(actual: &str, expected: &str) -> bool
     
 pub fn main()
 {
- //       fail_unless!(check_strs(fmt!("%?", Text(@~"foo")), "Text(@~\"foo\")"));
- //       fail_unless!(check_strs(fmt!("%?", ETag(@~[~"foo"], @~"bar")), "ETag(@~[ ~\"foo\" ], @~\"bar\")"));
+ //       assert!(check_strs(fmt!("%?", Text(@~"foo")), "Text(@~\"foo\")"));
+ //       assert!(check_strs(fmt!("%?", ETag(@~[~"foo"], @~"bar")), "ETag(@~[ ~\"foo\" ], @~\"bar\")"));
     
         let t = Text(@~"foo");
         let u = Section(@~[~"alpha"], true, @~[t], @~"foo", @~"foo", @~"foo", @~"foo", @~"foo");
         let v = fmt!("%?", u);    // this is the line that causes the seg fault
-        fail_unless!(v.len() > 0);
+        assert!(v.len() > 0);
 }
diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs
index 46a02ff1592..f7b7605523c 100644
--- a/src/test/run-pass/issue-3559.rs
+++ b/src/test/run-pass/issue-3559.rs
@@ -32,7 +32,7 @@ fn tester()
     let mut table = core::hashmap::linear::LinearMap();
     table.insert(@~"one", 1);
     table.insert(@~"two", 2);
-    fail_unless!(check_strs(table.to_str(), ~"xxx"));   // not sure what expected should be
+    assert!(check_strs(table.to_str(), ~"xxx"));   // not sure what expected should be
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs
index fdbd7ec304e..9b7ab67c1a3 100644
--- a/src/test/run-pass/issue-3563-3.rs
+++ b/src/test/run-pass/issue-3563-3.rs
@@ -181,7 +181,7 @@ pub fn check_strs(actual: &str, expected: &str) -> bool
 fn test_ascii_art_ctor()
 {
     let art = AsciiArt(3, 3, '*');
-    fail_unless!(check_strs(art.to_str(), "...\n...\n..."));
+    assert!(check_strs(art.to_str(), "...\n...\n..."));
 }
 
 
@@ -191,7 +191,7 @@ fn test_add_pt()
     art.add_pt(0, 0);
     art.add_pt(0, -10);
     art.add_pt(1, 2);
-    fail_unless!(check_strs(art.to_str(), "*..\n...\n.*."));
+    assert!(check_strs(art.to_str(), "*..\n...\n.*."));
 }
 
 
@@ -200,7 +200,7 @@ fn test_shapes()
     let mut art = AsciiArt(4, 4, '*');
     art.add_rect(Rect {top_left: Point {x: 0, y: 0}, size: Size {width: 4, height: 4}});
     art.add_point(Point {x: 2, y: 2});
-    fail_unless!(check_strs(art.to_str(), "****\n*..*\n*.**\n****"));
+    assert!(check_strs(art.to_str(), "****\n*..*\n*.**\n****"));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/issue-3574.rs b/src/test/run-pass/issue-3574.rs
index 5d0d65820e1..db937e74503 100644
--- a/src/test/run-pass/issue-3574.rs
+++ b/src/test/run-pass/issue-3574.rs
@@ -22,6 +22,6 @@ fn compare(x: &str, y: &str) -> bool
 
 pub fn main()
 {
-    fail_unless!(compare("foo", "foo"));
-    fail_unless!(compare(@"foo", @"foo"));
+    assert!(compare("foo", "foo"));
+    assert!(compare(@"foo", @"foo"));
 }
diff --git a/src/test/run-pass/issue-3683.rs b/src/test/run-pass/issue-3683.rs
index edbc7852542..bdb191488b9 100644
--- a/src/test/run-pass/issue-3683.rs
+++ b/src/test/run-pass/issue-3683.rs
@@ -24,5 +24,5 @@ impl Foo for int {
 }
 
 pub fn main() {
-    fail_unless!((3.b() == 5));
+    assert!((3.b() == 5));
 }
diff --git a/src/test/run-pass/issue-3935.rs b/src/test/run-pass/issue-3935.rs
index 626932850cf..af1538c6e62 100644
--- a/src/test/run-pass/issue-3935.rs
+++ b/src/test/run-pass/issue-3935.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let town_bike = Bike { name: ~"schwinn" };
     let my_bike = Bike { name: ~"surly" };
 
-    fail_unless!(town_bike != my_bike);
+    assert!(town_bike != my_bike);
 }
diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs
index 84136b40a7b..d26e9f1ba7b 100644
--- a/src/test/run-pass/issue-3979-generics.rs
+++ b/src/test/run-pass/issue-3979-generics.rs
@@ -37,5 +37,5 @@ impl Point: Movable<int, int>;
 pub fn main() {
     let p = Point{ x: 1, y: 2};
     p.translate(3);
-    fail_unless!(p.X() == 4);
+    assert!(p.X() == 4);
 }
diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs
index e87e7692855..5ecf80f4812 100644
--- a/src/test/run-pass/issue-3979-xcrate.rs
+++ b/src/test/run-pass/issue-3979-xcrate.rs
@@ -29,5 +29,5 @@ impl Movable for Point;
 pub fn main() {
     let mut p = Point{ x: 1, y: 2};
     p.translate(3);
-    fail_unless!(p.X() == 4);
+    assert!(p.X() == 4);
 }
diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs
index 3ff677cf1fe..2303c52be58 100644
--- a/src/test/run-pass/issue-3979.rs
+++ b/src/test/run-pass/issue-3979.rs
@@ -40,5 +40,5 @@ impl Movable for Point;
 pub fn main() {
     let mut p = Point{ x: 1, y: 2};
     p.translate(3);
-    fail_unless!(p.X() == 4);
+    assert!(p.X() == 4);
 }
diff --git a/src/test/run-pass/issue-4241.rs b/src/test/run-pass/issue-4241.rs
index 32aa5a0c70a..18bc471afab 100644
--- a/src/test/run-pass/issue-4241.rs
+++ b/src/test/run-pass/issue-4241.rs
@@ -28,13 +28,13 @@ priv fn parse_data(len: uint, io: @io::Reader) -> Result {
   let res =
       if (len > 0) {
       let bytes = io.read_bytes(len as uint);
-      fail_unless!(bytes.len() == len);
+      assert!(bytes.len() == len);
       Data(bytes)
   } else {
       Data(~[])
   };
-  fail_unless!(io.read_char() == '\r');
-  fail_unless!(io.read_char() == '\n');
+  assert!(io.read_char() == '\r');
+  assert!(io.read_char() == '\n');
   return res;
 }
 
diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs
index ef947ef3cd7..e509cb828f8 100644
--- a/src/test/run-pass/issue-4401.rs
+++ b/src/test/run-pass/issue-4401.rs
@@ -3,6 +3,6 @@ pub fn main() {
     for 999_999.times() {
         count += 1;
     }
-    fail_unless!(count == 999_999);
+    assert!(count == 999_999);
     io::println(fmt!("%u", count));
 }
diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs
index 5284fe92ade..68abeef15de 100644
--- a/src/test/run-pass/issue-4448.rs
+++ b/src/test/run-pass/issue-4448.rs
@@ -12,7 +12,7 @@ pub fn main() {
     let (port, chan) = comm::stream::<&'static str>();
 
     do task::spawn {
-        fail_unless!(port.recv() == "hello, world");
+        assert!(port.recv() == "hello, world");
     }
 
     chan.send("hello, world");
diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs
index d5184efa4c3..70d7df3f787 100644
--- a/src/test/run-pass/issue-979.rs
+++ b/src/test/run-pass/issue-979.rs
@@ -33,5 +33,5 @@ pub fn main() {
         let p = Some(r(b));
     }
 
-    fail_unless!(*b == 1);
+    assert!(*b == 1);
 }
diff --git a/src/test/run-pass/issue2378c.rs b/src/test/run-pass/issue2378c.rs
index 86fa5be0a22..ea8c47a3eb9 100644
--- a/src/test/run-pass/issue2378c.rs
+++ b/src/test/run-pass/issue2378c.rs
@@ -20,5 +20,5 @@ use issue2378b::{methods};
 
 pub fn main() {
     let x = {a: just(3), b: just(5)};
-    fail_unless!(x[0u] == (3, 5));
+    assert!(x[0u] == (3, 5));
 }
diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs
index e6e39311626..2f641993467 100644
--- a/src/test/run-pass/istr.rs
+++ b/src/test/run-pass/istr.rs
@@ -12,9 +12,9 @@ fn test_stack_assign() {
     let s: ~str = ~"a";
     debug!(s.clone());
     let t: ~str = ~"a";
-    fail_unless!((s == t));
+    assert!((s == t));
     let u: ~str = ~"b";
-    fail_unless!((s != u));
+    assert!((s != u));
 }
 
 fn test_heap_lit() { ~"a big string"; }
@@ -22,42 +22,42 @@ fn test_heap_lit() { ~"a big string"; }
 fn test_heap_assign() {
     let s: ~str = ~"a big ol' string";
     let t: ~str = ~"a big ol' string";
-    fail_unless!((s == t));
+    assert!((s == t));
     let u: ~str = ~"a bad ol' string";
-    fail_unless!((s != u));
+    assert!((s != u));
 }
 
 fn test_heap_log() { let s = ~"a big ol' string"; debug!(s); }
 
 fn test_stack_add() {
-    fail_unless!((~"a" + ~"b" == ~"ab"));
+    assert!((~"a" + ~"b" == ~"ab"));
     let s: ~str = ~"a";
-    fail_unless!((s + s == ~"aa"));
-    fail_unless!((~"" + ~"" == ~""));
+    assert!((s + s == ~"aa"));
+    assert!((~"" + ~"" == ~""));
 }
 
-fn test_stack_heap_add() { fail_unless!((~"a" + ~"bracadabra" == ~"abracadabra")); }
+fn test_stack_heap_add() { assert!((~"a" + ~"bracadabra" == ~"abracadabra")); }
 
 fn test_heap_add() {
-    fail_unless!((~"this should" + ~" totally work" == ~"this should totally work"));
+    assert!((~"this should" + ~" totally work" == ~"this should totally work"));
 }
 
 fn test_append() {
     let mut s = ~"";
     s += ~"a";
-    fail_unless!((s == ~"a"));
+    assert!((s == ~"a"));
 
     let mut s = ~"a";
     s += ~"b";
     debug!(s.clone());
-    fail_unless!((s == ~"ab"));
+    assert!((s == ~"ab"));
 
     let mut s = ~"c";
     s += ~"offee";
-    fail_unless!((s == ~"coffee"));
+    assert!((s == ~"coffee"));
 
     s += ~"&tea";
-    fail_unless!((s == ~"coffee&tea"));
+    assert!((s == ~"coffee&tea"));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs
index 62b4825067f..1e81c72148f 100644
--- a/src/test/run-pass/iter-all.rs
+++ b/src/test/run-pass/iter-all.rs
@@ -11,11 +11,11 @@
 fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 pub fn main() {
-    fail_unless!(![1u, 2u].all(is_even));
-    fail_unless!([2u, 4u].all(is_even));
-    fail_unless!([].all(is_even));
+    assert!(![1u, 2u].all(is_even));
+    assert!([2u, 4u].all(is_even));
+    assert!([].all(is_even));
 
-    fail_unless!(!iter::all(&Some(1u), is_even));
-    fail_unless!(iter::all(&Some(2u), is_even));
-    fail_unless!(iter::all(&None::<uint>, is_even));
+    assert!(!iter::all(&Some(1u), is_even));
+    assert!(iter::all(&Some(2u), is_even));
+    assert!(iter::all(&None::<uint>, is_even));
 }
diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs
index e23a87287e7..6f3114f1290 100644
--- a/src/test/run-pass/iter-any.rs
+++ b/src/test/run-pass/iter-any.rs
@@ -11,11 +11,11 @@
 fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 pub fn main() {
-    fail_unless!(![1u, 3u].any(is_even));
-    fail_unless!([1u, 2u].any(is_even));
-    fail_unless!(![].any(is_even));
+    assert!(![1u, 3u].any(is_even));
+    assert!([1u, 2u].any(is_even));
+    assert!(![].any(is_even));
 
-    fail_unless!(!iter::any(&Some(1u), is_even));
-    fail_unless!(iter::any(&Some(2u), is_even));
-    fail_unless!(!iter::any(&None::<uint>, is_even));
+    assert!(!iter::any(&Some(1u), is_even));
+    assert!(iter::any(&Some(2u), is_even));
+    assert!(!iter::any(&None::<uint>, is_even));
 }
diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs
index f56779a3c7a..7b8beda9bf1 100644
--- a/src/test/run-pass/iter-contains.rs
+++ b/src/test/run-pass/iter-contains.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!([].contains(&22u) == false);
-    fail_unless!([1u, 3u].contains(&22u) == false);
-    fail_unless!([22u, 1u, 3u].contains(&22u) == true);
-    fail_unless!([1u, 22u, 3u].contains(&22u) == true);
-    fail_unless!([1u, 3u, 22u].contains(&22u) == true);
-    fail_unless!(iter::contains(&None::<uint>, &22u) == false);
-    fail_unless!(iter::contains(&Some(1u), &22u) == false);
-    fail_unless!(iter::contains(&Some(22u), &22u) == true);
+    assert!([].contains(&22u) == false);
+    assert!([1u, 3u].contains(&22u) == false);
+    assert!([22u, 1u, 3u].contains(&22u) == true);
+    assert!([1u, 22u, 3u].contains(&22u) == true);
+    assert!([1u, 3u, 22u].contains(&22u) == true);
+    assert!(iter::contains(&None::<uint>, &22u) == false);
+    assert!(iter::contains(&Some(1u), &22u) == false);
+    assert!(iter::contains(&Some(22u), &22u) == true);
 }
diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs
index 8de0a727a52..8f67e489486 100644
--- a/src/test/run-pass/iter-count.rs
+++ b/src/test/run-pass/iter-count.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!([].count(&22u) == 0u);
-    fail_unless!([1u, 3u].count(&22u) == 0u);
-    fail_unless!([22u, 1u, 3u].count(&22u) == 1u);
-    fail_unless!([22u, 1u, 22u].count(&22u) == 2u);
-    fail_unless!(iter::count(&None::<uint>, &22u) == 0u);
-    fail_unless!(iter::count(&Some(1u), &22u) == 0u);
-    fail_unless!(iter::count(&Some(22u), &22u) == 1u);
+    assert!([].count(&22u) == 0u);
+    assert!([1u, 3u].count(&22u) == 0u);
+    assert!([22u, 1u, 3u].count(&22u) == 1u);
+    assert!([22u, 1u, 22u].count(&22u) == 2u);
+    assert!(iter::count(&None::<uint>, &22u) == 0u);
+    assert!(iter::count(&Some(1u), &22u) == 0u);
+    assert!(iter::count(&Some(22u), &22u) == 1u);
 }
diff --git a/src/test/run-pass/iter-eachi.rs b/src/test/run-pass/iter-eachi.rs
index 150b435bd5c..cbf4243c409 100644
--- a/src/test/run-pass/iter-eachi.rs
+++ b/src/test/run-pass/iter-eachi.rs
@@ -11,17 +11,17 @@
 pub fn main() {
     let mut c = 0u;
     for [1u, 2u, 3u, 4u, 5u].eachi |i, v| {
-        fail_unless!((i + 1u) == *v);
+        assert!((i + 1u) == *v);
         c += 1u;
     }
-    fail_unless!(c == 5u);
+    assert!(c == 5u);
 
     for iter::eachi(&None::<uint>) |i, v| { fail!(); }
 
     let mut c = 0u;
     for iter::eachi(&Some(1u)) |i, v| {
-        fail_unless!((i + 1u) == *v);
+        assert!((i + 1u) == *v);
         c += 1u;
     }
-    fail_unless!(c == 1u);
+    assert!(c == 1u);
 }
diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs
index f96ff5efd81..4fd523ea2c0 100644
--- a/src/test/run-pass/iter-filter-to-vec.rs
+++ b/src/test/run-pass/iter-filter-to-vec.rs
@@ -11,9 +11,9 @@
 fn is_even(x: &uint) -> bool { (*x % 2) == 0 }
 
 pub fn main() {
-    fail_unless!([1, 3].filter_to_vec(is_even) == ~[]);
-    fail_unless!([1, 2, 3].filter_to_vec(is_even) == ~[2]);
-    fail_unless!(iter::filter_to_vec(&None::<uint>, is_even) == ~[]);
-    fail_unless!(iter::filter_to_vec(&Some(1u), is_even) == ~[]);
-    fail_unless!(iter::filter_to_vec(&Some(2u), is_even) == ~[2]);
+    assert!([1, 3].filter_to_vec(is_even) == ~[]);
+    assert!([1, 2, 3].filter_to_vec(is_even) == ~[2]);
+    assert!(iter::filter_to_vec(&None::<uint>, is_even) == ~[]);
+    assert!(iter::filter_to_vec(&Some(1u), is_even) == ~[]);
+    assert!(iter::filter_to_vec(&Some(2u), is_even) == ~[2]);
 }
diff --git a/src/test/run-pass/iter-flat-map-to-vec.rs b/src/test/run-pass/iter-flat-map-to-vec.rs
index 2ed6f95e455..b392b8efd21 100644
--- a/src/test/run-pass/iter-flat-map-to-vec.rs
+++ b/src/test/run-pass/iter-flat-map-to-vec.rs
@@ -15,15 +15,15 @@ fn incd_if_even(x: &uint) -> Option<uint> {
 }
 
 pub fn main() {
-    fail_unless!((~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u]);
-    fail_unless!((~[]).flat_map_to_vec(repeat) == ~[]);
-    fail_unless!(iter::flat_map_to_vec(&None::<uint>, repeat) == ~[]);
-    fail_unless!(iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u]);
-    fail_unless!(iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u]);
+    assert!((~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u]);
+    assert!((~[]).flat_map_to_vec(repeat) == ~[]);
+    assert!(iter::flat_map_to_vec(&None::<uint>, repeat) == ~[]);
+    assert!(iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u]);
+    assert!(iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u]);
 
-    fail_unless!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u]);
-    fail_unless!((~[]).flat_map_to_vec(incd_if_even) == ~[]);
-    fail_unless!(iter::flat_map_to_vec(&None::<uint>, incd_if_even) == ~[]);
-    fail_unless!(iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[]);
-    fail_unless!(iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u]);
+    assert!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u]);
+    assert!((~[]).flat_map_to_vec(incd_if_even) == ~[]);
+    assert!(iter::flat_map_to_vec(&None::<uint>, incd_if_even) == ~[]);
+    assert!(iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[]);
+    assert!(iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u]);
 }
diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs
index cbfb2fb7bc6..e5e5cd44032 100644
--- a/src/test/run-pass/iter-foldl.rs
+++ b/src/test/run-pass/iter-foldl.rs
@@ -11,9 +11,9 @@
 fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) }
 
 pub fn main() {
-    fail_unless!([1u, 3u].foldl(20f, add) == 24f);
-    fail_unless!([].foldl(20f, add) == 20f);
-    fail_unless!(iter::foldl(&None::<uint>, 20f, add) == 20f);
-    fail_unless!(iter::foldl(&Some(1u), 20f, add) == 21f);
-    fail_unless!(iter::foldl(&Some(2u), 20f, add) == 22f);
+    assert!([1u, 3u].foldl(20f, add) == 24f);
+    assert!([].foldl(20f, add) == 20f);
+    assert!(iter::foldl(&None::<uint>, 20f, add) == 20f);
+    assert!(iter::foldl(&Some(1u), 20f, add) == 21f);
+    assert!(iter::foldl(&Some(2u), 20f, add) == 22f);
 }
diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs
index f2361376fd8..17af47d8733 100644
--- a/src/test/run-pass/iter-map-to-vec.rs
+++ b/src/test/run-pass/iter-map-to-vec.rs
@@ -11,9 +11,9 @@
 fn inc(x: &uint) -> uint { *x + 1 }
 
 pub fn main() {
-    fail_unless!([1, 3].map_to_vec(inc) == ~[2, 4]);
-    fail_unless!([1, 2, 3].map_to_vec(inc) == ~[2, 3, 4]);
-    fail_unless!(iter::map_to_vec(&None::<uint>, inc) == ~[]);
-    fail_unless!(iter::map_to_vec(&Some(1u), inc) == ~[2]);
-    fail_unless!(iter::map_to_vec(&Some(2u), inc) == ~[3]);
+    assert!([1, 3].map_to_vec(inc) == ~[2, 4]);
+    assert!([1, 2, 3].map_to_vec(inc) == ~[2, 3, 4]);
+    assert!(iter::map_to_vec(&None::<uint>, inc) == ~[]);
+    assert!(iter::map_to_vec(&Some(1u), inc) == ~[2]);
+    assert!(iter::map_to_vec(&Some(2u), inc) == ~[3]);
 }
diff --git a/src/test/run-pass/iter-min-max.rs b/src/test/run-pass/iter-min-max.rs
index 188aff44007..a7160615dbd 100644
--- a/src/test/run-pass/iter-min-max.rs
+++ b/src/test/run-pass/iter-min-max.rs
@@ -11,11 +11,11 @@
 fn is_even(&&x: uint) -> bool { (x % 2u) == 0u }
 
 pub fn main() {
-    fail_unless!([1u, 3u].min() == 1u);
-    fail_unless!([3u, 1u].min() == 1u);
-    fail_unless!(iter::min(&Some(1u)) == 1u);
+    assert!([1u, 3u].min() == 1u);
+    assert!([3u, 1u].min() == 1u);
+    assert!(iter::min(&Some(1u)) == 1u);
 
-    fail_unless!([1u, 3u].max() == 3u);
-    fail_unless!([3u, 1u].max() == 3u);
-    fail_unless!(iter::max(&Some(3u)) == 3u);
+    assert!([1u, 3u].max() == 3u);
+    assert!([3u, 1u].max() == 3u);
+    assert!(iter::max(&Some(3u)) == 3u);
 }
diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs
index 983f47e8ab7..0fbca65e6fb 100644
--- a/src/test/run-pass/iter-range.rs
+++ b/src/test/run-pass/iter-range.rs
@@ -11,7 +11,7 @@
 
 
 fn range(a: int, b: int, it: &fn(int)) {
-    fail_unless!((a < b));
+    assert!((a < b));
     let mut i: int = a;
     while i < b { it(i); i += 1; }
 }
diff --git a/src/test/run-pass/iter-to-vec.rs b/src/test/run-pass/iter-to-vec.rs
index 00fcb17a0b0..944e9f5b0a5 100644
--- a/src/test/run-pass/iter-to-vec.rs
+++ b/src/test/run-pass/iter-to-vec.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!([1u, 3u].to_vec() == ~[1u, 3u]);
+    assert!([1u, 3u].to_vec() == ~[1u, 3u]);
     let e: ~[uint] = ~[];
-    fail_unless!(e.to_vec() == ~[]);
-    fail_unless!(iter::to_vec(&None::<uint>) == ~[]);
-    fail_unless!(iter::to_vec(&Some(1u)) == ~[1u]);
-    fail_unless!(iter::to_vec(&Some(2u)) == ~[2u]);
+    assert!(e.to_vec() == ~[]);
+    assert!(iter::to_vec(&None::<uint>) == ~[]);
+    assert!(iter::to_vec(&Some(1u)) == ~[1u]);
+    assert!(iter::to_vec(&Some(2u)) == ~[2u]);
 }
diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs
index 410286d683f..1b9e818421e 100644
--- a/src/test/run-pass/ivec-add.rs
+++ b/src/test/run-pass/ivec-add.rs
@@ -14,11 +14,11 @@ fn double_int(a: int) -> ~[int] { return ~[a] + ~[a]; }
 
 pub fn main() {
     let mut d = double(1);
-    fail_unless!((d[0] == 1));
-    fail_unless!((d[1] == 1));
+    assert!((d[0] == 1));
+    assert!((d[1] == 1));
 
     d = double_int(1);
-    fail_unless!((d[0] == 1));
-    fail_unless!((d[1] == 1));
+    assert!((d[0] == 1));
+    assert!((d[1] == 1));
 }
 
diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs
index 0a39472025d..3fb554dc450 100644
--- a/src/test/run-pass/kindck-owned-trait-contains-1.rs
+++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs
@@ -22,5 +22,5 @@ fn repeater<A:Copy>(v: @A) -> @repeat<A> {
 pub fn main() {
     let x = &3;
     let y = repeater(@x);
-    fail_unless!(*x == *(y.get()));
+    assert!(*x == *(y.get()));
 }
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 3d121d08745..442e79bde77 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -20,5 +20,5 @@ fn foo() -> @fn() -> int {
 }
 
 pub fn main() {
-    fail_unless!(foo()() == 22);
+    assert!(foo()() == 22);
 }
diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
index e16229eec53..1a1e4816a36 100644
--- a/src/test/run-pass/lazy-and-or.rs
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -10,13 +10,13 @@
 
 
 
-fn incr(x: &mut int) -> bool { *x += 1; fail_unless!((false)); return false; }
+fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }
 
 pub fn main() {
     let x = 1 == 2 || 3 == 3;
-    fail_unless!((x));
+    assert!((x));
     let mut y: int = 10;
     debug!(x || incr(&mut y));
-    fail_unless!((y == 10));
-    if true && x { fail_unless!((true)); } else { fail_unless!((false)); }
+    assert!((y == 10));
+    if true && x { assert!((true)); } else { assert!((false)); }
 }
diff --git a/src/test/run-pass/let-destruct-fresh-mem.rs b/src/test/run-pass/let-destruct-fresh-mem.rs
index 0b085f1fd32..ae6118d063e 100644
--- a/src/test/run-pass/let-destruct-fresh-mem.rs
+++ b/src/test/run-pass/let-destruct-fresh-mem.rs
@@ -16,8 +16,8 @@ pub fn main() {
     let mut X {x: x, y: @A {a: a}} = u;
     x = 100;
     a = 100;
-    fail_unless!((x == 100));
-    fail_unless!((a == 100));
-    fail_unless!((u.x == 10));
-    fail_unless!((u.y.a == 20));
+    assert!((x == 100));
+    assert!((a == 100));
+    assert!((u.x == 10));
+    assert!((u.y.a == 20));
 }
diff --git a/src/test/run-pass/let-destruct.rs b/src/test/run-pass/let-destruct.rs
index 05e50e3e660..6e2ce508928 100644
--- a/src/test/run-pass/let-destruct.rs
+++ b/src/test/run-pass/let-destruct.rs
@@ -14,5 +14,5 @@ struct X { x: xx, y: int }
 
 pub fn main() {
     let @X {x: xx(x), y: y} = @X{x: xx(10), y: 20};
-    fail_unless!((x + y == 30));
+    assert!((x + y == 30));
 }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 1d8662de7c2..f2fb63cfc9e 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -15,20 +15,20 @@ pub fn main() {
     let mut y = 0;
     for x.each |i| { debug!(*i); y += *i; }
     debug!(y);
-    fail_unless!((y == 6));
+    assert!((y == 6));
     let s = ~"hello there";
     let mut i: int = 0;
     for str::each(s) |c| {
-        if i == 0 { fail_unless!((c == 'h' as u8)); }
-        if i == 1 { fail_unless!((c == 'e' as u8)); }
-        if i == 2 { fail_unless!((c == 'l' as u8)); }
-        if i == 3 { fail_unless!((c == 'l' as u8)); }
-        if i == 4 { fail_unless!((c == 'o' as u8)); }
+        if i == 0 { assert!((c == 'h' as u8)); }
+        if i == 1 { assert!((c == 'e' as u8)); }
+        if i == 2 { assert!((c == 'l' as u8)); }
+        if i == 3 { assert!((c == 'l' as u8)); }
+        if i == 4 { assert!((c == 'o' as u8)); }
         // ...
 
         i += 1;
         debug!(i);
         debug!(c);
     }
-    fail_unless!((i == 11));
+    assert!((i == 11));
 }
diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
index a521b5fe478..44e1292d9b1 100644
--- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
+++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
@@ -19,13 +19,13 @@ enum foo {
 }
 
 fn check_log<T>(exp: ~str, v: T) {
-    fail_unless!(exp == fmt!("%?", v));
+    assert!(exp == fmt!("%?", v));
 }
 
 pub fn main() {
     let x = list::from_vec(~[a(22u), b(~"hi")]);
     let exp = ~"@Cons(a(22), @Cons(b(~\"hi\"), @Nil))";
     let act = fmt!("%?", x);
-    fail_unless!(act == exp);
+    assert!(act == exp);
     check_log(exp, x);
 }
diff --git a/src/test/run-pass/log-knows-the-names-of-variants.rs b/src/test/run-pass/log-knows-the-names-of-variants.rs
index bbd05daf49f..641d6155e23 100644
--- a/src/test/run-pass/log-knows-the-names-of-variants.rs
+++ b/src/test/run-pass/log-knows-the-names-of-variants.rs
@@ -19,8 +19,8 @@ enum bar {
 }
 
 pub fn main() {
-    fail_unless!(~"a(22)" == fmt!("%?", a(22u)));
-    fail_unless!(~"b(~\"hi\")" == fmt!("%?", b(~"hi")));
-    fail_unless!(~"c" == fmt!("%?", c));
-    fail_unless!(~"d" == fmt!("%?", d));
+    assert!(~"a(22)" == fmt!("%?", a(22u)));
+    assert!(~"b(~\"hi\")" == fmt!("%?", b(~"hi")));
+    assert!(~"c" == fmt!("%?", c));
+    assert!(~"d" == fmt!("%?", d));
 }
diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs
index d41867f1722..e321789a2b1 100644
--- a/src/test/run-pass/log-str.rs
+++ b/src/test/run-pass/log-str.rs
@@ -10,8 +10,8 @@
 
 pub fn main() {
     let act = sys::log_str(&~[1, 2, 3]);
-    fail_unless!(~"~[1, 2, 3]" == act);
+    assert!(~"~[1, 2, 3]" == act);
 
     let act = fmt!("%?/%6?", ~[1, 2, 3], ~"hi");
-    fail_unless!(act == ~"~[1, 2, 3]/ ~\"hi\"");
+    assert!(act == ~"~[1, 2, 3]/ ~\"hi\"");
 }
diff --git a/src/test/run-pass/loop-break-cont-1.rs b/src/test/run-pass/loop-break-cont-1.rs
index a07203c9e13..7ed4a0ba5ce 100644
--- a/src/test/run-pass/loop-break-cont-1.rs
+++ b/src/test/run-pass/loop-break-cont-1.rs
@@ -13,5 +13,5 @@ pub fn main() {
   loop {
     break;
   }
-  fail_unless!(true);
+  assert!(true);
 }
diff --git a/src/test/run-pass/loop-break-cont.rs b/src/test/run-pass/loop-break-cont.rs
index b0ea375228f..4a4da79367f 100644
--- a/src/test/run-pass/loop-break-cont.rs
+++ b/src/test/run-pass/loop-break-cont.rs
@@ -17,7 +17,7 @@ pub fn main() {
       break;
     }
   }
-  fail_unless!((i == 10u));
+  assert!((i == 10u));
   let mut is_even = false;
   loop {
     if i == 21u {
@@ -31,7 +31,7 @@ pub fn main() {
     }
     is_even = true;
   }
-  fail_unless!(!is_even);
+  assert!(!is_even);
   loop {
     error!(~"c");
     if i == 22u {
@@ -44,5 +44,5 @@ pub fn main() {
     }
     is_even = true;
   }
-  fail_unless!(is_even);
+  assert!(is_even);
 }
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 55697a086aa..a3caf1e4800 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -12,5 +12,5 @@ pub fn main() {
     let x = ~[10, 20, 30];
     let mut sum = 0;
     for x.each |x| { sum += *x; }
-    fail_unless!((sum == 60));
+    assert!((sum == 60));
 }
diff --git a/src/test/run-pass/macro-2.rs b/src/test/run-pass/macro-2.rs
index 0606385ed7d..b4ae81a3204 100644
--- a/src/test/run-pass/macro-2.rs
+++ b/src/test/run-pass/macro-2.rs
@@ -19,5 +19,5 @@ pub fn main() {
         })
     )
 
-    fail_unless!(mylambda_tt!(y, y * 2)(8) == 16)
+    assert!(mylambda_tt!(y, y * 2)(8) == 16)
 }
diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs
index 91410fea16e..45c8669eae2 100644
--- a/src/test/run-pass/macro-interpolation.rs
+++ b/src/test/run-pass/macro-interpolation.rs
@@ -23,7 +23,7 @@ macro_rules! overly_complicated (
 
 )
 pub fn main() {
-    fail_unless!(overly_complicated!(f, x, Option<uint>, { return Some(x); },
+    assert!(overly_complicated!(f, x, Option<uint>, { return Some(x); },
                                Some(8u), Some(y), y) == 8u)
 
 }
diff --git a/src/test/run-pass/macro-path.rs b/src/test/run-pass/macro-path.rs
index da5d79baadf..a3bd03c80bc 100644
--- a/src/test/run-pass/macro-path.rs
+++ b/src/test/run-pass/macro-path.rs
@@ -20,5 +20,5 @@ macro_rules! foo {
 }
 
 pub fn main() {
-    fail_unless!(foo!(m::t) == 10);
+    assert!(foo!(m::t) == 10);
 }
diff --git a/src/test/run-pass/macro-stmt.rs b/src/test/run-pass/macro-stmt.rs
index 26ad97ce21d..d9417ee0a19 100644
--- a/src/test/run-pass/macro-stmt.rs
+++ b/src/test/run-pass/macro-stmt.rs
@@ -27,16 +27,16 @@ pub fn main() {
     );
 
     mylet!(y, 8*2);
-    fail_unless!((y == 16));
+    assert!((y == 16));
 
     myfn!(mult, (a,b), { a*b } );
 
-    fail_unless!((mult(2, add(4,4)) == 16));
+    assert!((mult(2, add(4,4)) == 16));
 
     macro_rules! actually_an_expr_macro (
         () => ( 16 )
     )
 
-    fail_unless!({ actually_an_expr_macro!() } == 16);
+    assert!({ actually_an_expr_macro!() } == 16);
 
 }
diff --git a/src/test/run-pass/mod-inside-fn.rs b/src/test/run-pass/mod-inside-fn.rs
index 768578d691e..e4bc850644e 100644
--- a/src/test/run-pass/mod-inside-fn.rs
+++ b/src/test/run-pass/mod-inside-fn.rs
@@ -17,5 +17,5 @@ fn f() -> int {
 }
 
 pub fn main() {
-    fail_unless!(f() == 720);
+    assert!(f() == 720);
 }
diff --git a/src/test/run-pass/mod-merge-hack.rs b/src/test/run-pass/mod-merge-hack.rs
index 2f910fdbc2c..10f661b4f8d 100644
--- a/src/test/run-pass/mod-merge-hack.rs
+++ b/src/test/run-pass/mod-merge-hack.rs
@@ -14,6 +14,6 @@
 mod myint32;
 
 pub fn main() {
-    fail_unless!(myint32::bits == 32);
-    fail_unless!(myint32::min(10, 20) == 10);
+    assert!(myint32::bits == 32);
+    assert!(myint32::min(10, 20) == 10);
 }
diff --git a/src/test/run-pass/mod_dir_path.rs b/src/test/run-pass/mod_dir_path.rs
index 0d43e24809d..f0cc4aa52d6 100644
--- a/src/test/run-pass/mod_dir_path.rs
+++ b/src/test/run-pass/mod_dir_path.rs
@@ -17,5 +17,5 @@ mod mod_dir_simple {
 }
 
 pub fn main() {
-    fail_unless!(mod_dir_simple::syrup::foo() == 10);
+    assert!(mod_dir_simple::syrup::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_dir_path2.rs b/src/test/run-pass/mod_dir_path2.rs
index 0f6e94bce33..2635084a072 100644
--- a/src/test/run-pass/mod_dir_path2.rs
+++ b/src/test/run-pass/mod_dir_path2.rs
@@ -18,5 +18,5 @@ mod pancakes {
 }
 
 pub fn main() {
-    fail_unless!(pancakes::syrup::foo() == 10);
+    assert!(pancakes::syrup::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_dir_path3.rs b/src/test/run-pass/mod_dir_path3.rs
index 881eac72ebd..0971120eb6f 100644
--- a/src/test/run-pass/mod_dir_path3.rs
+++ b/src/test/run-pass/mod_dir_path3.rs
@@ -17,5 +17,5 @@ mod pancakes {
 }
 
 pub fn main() {
-    fail_unless!(pancakes::test::foo() == 10);
+    assert!(pancakes::test::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_dir_path_multi.rs b/src/test/run-pass/mod_dir_path_multi.rs
index c0019bcfd7c..c6ab45d1b3a 100644
--- a/src/test/run-pass/mod_dir_path_multi.rs
+++ b/src/test/run-pass/mod_dir_path_multi.rs
@@ -22,6 +22,6 @@ mod gravy {
 }
 
 pub fn main() {
-    fail_unless!(biscuits::test::foo() == 10);
-    fail_unless!(gravy::test::foo() == 10);
+    assert!(biscuits::test::foo() == 10);
+    assert!(gravy::test::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_dir_recursive.rs b/src/test/run-pass/mod_dir_recursive.rs
index 5c8ae86dfbc..5392671651d 100644
--- a/src/test/run-pass/mod_dir_recursive.rs
+++ b/src/test/run-pass/mod_dir_recursive.rs
@@ -20,5 +20,5 @@ mod mod_dir_simple {
 }
 
 pub fn main() {
-    fail_unless!(mod_dir_simple::load_another_mod::test::foo() == 10);
+    assert!(mod_dir_simple::load_another_mod::test::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_dir_simple.rs b/src/test/run-pass/mod_dir_simple.rs
index 0ec7ce8ecc4..382911d4979 100644
--- a/src/test/run-pass/mod_dir_simple.rs
+++ b/src/test/run-pass/mod_dir_simple.rs
@@ -16,5 +16,5 @@ mod mod_dir_simple {
 }
 
 pub fn main() {
-    fail_unless!(mod_dir_simple::test::foo() == 10);
+    assert!(mod_dir_simple::test::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_file.rs b/src/test/run-pass/mod_file.rs
index 56169456318..a03dc044011 100644
--- a/src/test/run-pass/mod_file.rs
+++ b/src/test/run-pass/mod_file.rs
@@ -15,5 +15,5 @@
 mod mod_file_aux;
 
 pub fn main() {
-    fail_unless!(mod_file_aux::foo() == 10);
+    assert!(mod_file_aux::foo() == 10);
 }
diff --git a/src/test/run-pass/mod_file_with_path_attr.rs b/src/test/run-pass/mod_file_with_path_attr.rs
index 0130d62867d..ecd4fd73a06 100644
--- a/src/test/run-pass/mod_file_with_path_attr.rs
+++ b/src/test/run-pass/mod_file_with_path_attr.rs
@@ -16,5 +16,5 @@
 mod m;
 
 pub fn main() {
-    fail_unless!(m::foo() == 10);
+    assert!(m::foo() == 10);
 }
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index f046adc30b4..303d5bc1b41 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -40,9 +40,9 @@ fn transform(x: Option<int>) -> Option<~str> {
 }
 
 pub fn main() {
-    fail_unless!(transform(Some(10)) == Some(~"11"));
-    fail_unless!(transform(None) == None);
-    fail_unless!((~[~"hi"])
+    assert!(transform(Some(10)) == Some(~"11"));
+    assert!(transform(None) == None);
+    assert!((~[~"hi"])
         .bind(|x| ~[x.clone(), *x + ~"!"] )
         .bind(|x| ~[x.clone(), *x + ~"?"] ) ==
         ~[~"hi", ~"hi?", ~"hi!", ~"hi!?"]);
diff --git a/src/test/run-pass/monomorphize-trait-in-fn-at.rs b/src/test/run-pass/monomorphize-trait-in-fn-at.rs
index a591c3034d2..61d9456296e 100644
--- a/src/test/run-pass/monomorphize-trait-in-fn-at.rs
+++ b/src/test/run-pass/monomorphize-trait-in-fn-at.rs
@@ -26,5 +26,5 @@ impl ty_ops for () {
 
 pub fn main() {
     let fn_env: @fn() -> uint = || mk_nil(());
-    fail_unless!(fn_env() == 22u);
+    assert!(fn_env() == 22u);
 }
diff --git a/src/test/run-pass/morestack-address.rs b/src/test/run-pass/morestack-address.rs
index 9497ca83ecc..8089a2dc034 100644
--- a/src/test/run-pass/morestack-address.rs
+++ b/src/test/run-pass/morestack-address.rs
@@ -19,7 +19,7 @@ mod rusti {
 pub fn main() {
     unsafe {
         let addr = rusti::morestack_addr();
-        fail_unless!(addr.is_not_null());
+        assert!(addr.is_not_null());
         error!("%?", addr);
     }
 }
diff --git a/src/test/run-pass/morestack3.rs b/src/test/run-pass/morestack3.rs
index de624d22588..07edf0d2e1c 100644
--- a/src/test/run-pass/morestack3.rs
+++ b/src/test/run-pass/morestack3.rs
@@ -21,15 +21,15 @@ fn getbig(a0: int,
           a8: int,
           a9: int) -> int {
 
-    fail_unless!(a0 + 1 == a1);
-    fail_unless!(a1 + 1 == a2);
-    fail_unless!(a2 + 1 == a3);
-    fail_unless!(a3 + 1 == a4);
-    fail_unless!(a4 + 1 == a5);
-    fail_unless!(a5 + 1 == a6);
-    fail_unless!(a6 + 1 == a7);
-    fail_unless!(a7 + 1 == a8);
-    fail_unless!(a8 + 1 == a9);
+    assert!(a0 + 1 == a1);
+    assert!(a1 + 1 == a2);
+    assert!(a2 + 1 == a3);
+    assert!(a3 + 1 == a4);
+    assert!(a4 + 1 == a5);
+    assert!(a5 + 1 == a6);
+    assert!(a6 + 1 == a7);
+    assert!(a7 + 1 == a8);
+    assert!(a8 + 1 == a9);
     if a0 != 0 {
         let j = getbig(a0 - 1,
                        a1 - 1,
@@ -41,7 +41,7 @@ fn getbig(a0: int,
                        a7 - 1,
                        a8 - 1,
                        a9 - 1);
-        fail_unless!(j == a0 - 1);
+        assert!(j == a0 - 1);
     }
     return a0;
 }
diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs
index 06c4586cdfc..47902363db7 100644
--- a/src/test/run-pass/move-1-unique.rs
+++ b/src/test/run-pass/move-1-unique.rs
@@ -19,8 +19,8 @@ fn test(x: bool, foo: ~Triple) -> int {
 
 pub fn main() {
     let x = ~Triple{x: 1, y: 2, z: 3};
-    fail_unless!((test(true, copy x) == 2));
-    fail_unless!((test(true, copy x) == 2));
-    fail_unless!((test(true, copy x) == 2));
-    fail_unless!((test(false, x) == 5));
+    assert!((test(true, copy x) == 2));
+    assert!((test(true, copy x) == 2));
+    assert!((test(true, copy x) == 2));
+    assert!((test(false, x) == 5));
 }
diff --git a/src/test/run-pass/move-1.rs b/src/test/run-pass/move-1.rs
index f7e5758c462..04354d74159 100644
--- a/src/test/run-pass/move-1.rs
+++ b/src/test/run-pass/move-1.rs
@@ -19,8 +19,8 @@ fn test(x: bool, foo: @Triple) -> int {
 
 pub fn main() {
     let x = @Triple {x: 1, y: 2, z: 3};
-    fail_unless!((test(true, x) == 2));
-    fail_unless!((test(true, x) == 2));
-    fail_unless!((test(true, x) == 2));
-    fail_unless!((test(false, x) == 5));
+    assert!((test(true, x) == 2));
+    assert!((test(true, x) == 2));
+    assert!((test(true, x) == 2));
+    assert!((test(false, x) == 5));
 }
diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs
index 08f67a7fa5c..e3595d4ac9a 100644
--- a/src/test/run-pass/move-2-unique.rs
+++ b/src/test/run-pass/move-2-unique.rs
@@ -11,4 +11,4 @@
 
 struct X { x: int, y: int, z: int }
 
-pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = x; fail_unless!((y.y == 2)); }
+pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); }
diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs
index 0294ff99733..fb5f3e11ab7 100644
--- a/src/test/run-pass/move-2.rs
+++ b/src/test/run-pass/move-2.rs
@@ -11,4 +11,4 @@
 
 struct X { x: int, y: int, z: int }
 
-pub fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = x; fail_unless!((y.y == 2)); }
+pub fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); }
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index be6dc8b2004..36c9c787b75 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/src/test/run-pass/move-3-unique.rs
@@ -22,7 +22,7 @@ fn test(x: bool, foo: ~Triple) -> int {
 pub fn main() {
     let x = ~Triple{x: 1, y: 2, z: 3};
     for uint::range(0u, 10000u) |_i| {
-        fail_unless!((test(true, copy x) == 2));
+        assert!((test(true, copy x) == 2));
     }
-    fail_unless!((test(false, x) == 5));
+    assert!((test(false, x) == 5));
 }
diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs
index 01d56282d7e..f2b6b2f9980 100644
--- a/src/test/run-pass/move-3.rs
+++ b/src/test/run-pass/move-3.rs
@@ -22,7 +22,7 @@ fn test(x: bool, foo: @Triple) -> int {
 pub fn main() {
     let x = @Triple{x: 1, y: 2, z: 3};
     for uint::range(0u, 10000u) |i| {
-        fail_unless!((test(true, x) == 2));
+        assert!((test(true, x) == 2));
     }
-    fail_unless!((test(false, x) == 5));
+    assert!((test(false, x) == 5));
 }
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 2f393b156ea..2ed3523ef86 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/src/test/run-pass/move-4-unique.rs
@@ -20,4 +20,4 @@ fn test(foo: ~Triple) -> ~Triple {
     return quux;
 }
 
-pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); fail_unless!((y.c == 3)); }
+pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert!((y.c == 3)); }
diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs
index a1a76040593..fe544e54742 100644
--- a/src/test/run-pass/move-4.rs
+++ b/src/test/run-pass/move-4.rs
@@ -24,5 +24,5 @@ fn test(foo: @Triple) -> @Triple {
 pub fn main() {
     let x = @Triple{a: 1, b: 2, c: 3};
     let y = test(x);
-    fail_unless!((y.c == 3));
+    assert!((y.c == 3));
 }
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index c0adcc8c03c..dbc73c20e6b 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test(+foo: ~~[int]) { fail_unless!((foo[0] == 10)); }
+fn test(+foo: ~~[int]) { assert!((foo[0] == 10)); }
 
 pub fn main() {
     let x = ~~[10];
diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs
index 41a82977175..5cc309d1a3e 100644
--- a/src/test/run-pass/move-arg-2.rs
+++ b/src/test/run-pass/move-arg-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test(+foo: @~[int]) { fail_unless!((foo[0] == 10)); }
+fn test(+foo: @~[int]) { assert!((foo[0] == 10)); }
 
 pub fn main() {
     let x = @~[10];
diff --git a/src/test/run-pass/move-arg.rs b/src/test/run-pass/move-arg.rs
index b763317dfe1..ca3a5509c5c 100644
--- a/src/test/run-pass/move-arg.rs
+++ b/src/test/run-pass/move-arg.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test(+foo: int) { fail_unless!((foo == 10)); }
+fn test(+foo: int) { assert!((foo == 10)); }
 
 pub fn main() { let x = 10; test(x); }
diff --git a/src/test/run-pass/move-scalar.rs b/src/test/run-pass/move-scalar.rs
index 5fdef34b33a..6a8091d7b77 100644
--- a/src/test/run-pass/move-scalar.rs
+++ b/src/test/run-pass/move-scalar.rs
@@ -13,5 +13,5 @@ pub fn main() {
     let y: int = 42;
     let mut x: int;
     x = y;
-    fail_unless!((x == 42));
+    assert!((x == 42));
 }
diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs
index 275fee25d72..a7c3c80fba7 100644
--- a/src/test/run-pass/multi-let.rs
+++ b/src/test/run-pass/multi-let.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let x = 10, y = x; fail_unless!((y == 10)); }
+pub fn main() { let x = 10, y = x; assert!((y == 10)); }
diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs
index f61ffc1bc3e..20813bb4a03 100644
--- a/src/test/run-pass/mut-function-arguments.rs
+++ b/src/test/run-pass/mut-function-arguments.rs
@@ -10,11 +10,11 @@
 
 fn f(mut y: ~int) {
     *y = 5;
-    fail_unless!(*y == 5);
+    assert!(*y == 5);
 }
 
 fn g() {
-    let frob: &fn(~int) = |mut q| { *q = 2; fail_unless!(*q == 2); };
+    let frob: &fn(~int) = |mut q| { *q = 2; assert!(*q == 2); };
     let w = ~37;
     frob(w);
 
diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
index d63f1b40dc8..c4caf716df2 100644
--- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
+++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
@@ -11,13 +11,13 @@
 fn test1() {
     let mut ints = [0, ..32];
     ints[0] += 1;
-    fail_unless!(ints[0] == 1);
+    assert!(ints[0] == 1);
 }
 
 fn test2() {
     let mut ints = [0, ..32];
     for vec::each_mut(ints) |i| { *i += 22; }
-    for ints.each |i| { fail_unless!(*i == 22); }
+    for ints.each |i| { assert!(*i == 22); }
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs
index e08bd5f85a9..c6bf07536b1 100644
--- a/src/test/run-pass/mutable-alias-vec.rs
+++ b/src/test/run-pass/mutable-alias-vec.rs
@@ -22,5 +22,5 @@ pub fn main() {
     grow(&mut v);
     let len = vec::len::<int>(v);
     debug!(len);
-    fail_unless!((len == 3 as uint));
+    assert!((len == 3 as uint));
 }
diff --git a/src/test/run-pass/nested-class.rs b/src/test/run-pass/nested-class.rs
index 6447d46ad89..44348223b60 100644
--- a/src/test/run-pass/nested-class.rs
+++ b/src/test/run-pass/nested-class.rs
@@ -27,7 +27,7 @@ pub fn main() {
   //  fn b(x:int) -> int { fail!(); }
 
   let z = b(42);
-  fail_unless!((z.i == 42));
-  fail_unless!((z.do_stuff() == 37));
+  assert!((z.i == 42));
+  assert!((z.do_stuff() == 37));
   
 }
diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs
index 9da3f44fc6d..6c56e39d2d3 100644
--- a/src/test/run-pass/nested-patterns.rs
+++ b/src/test/run-pass/nested-patterns.rs
@@ -15,13 +15,13 @@ struct C { c: int }
 
 pub fn main() {
     match A {a: 10, b: @20} {
-        x@A {a, b: @20} => { fail_unless!(x.a == 10); fail_unless!(a == 10); }
+        x@A {a, b: @20} => { assert!(x.a == 10); assert!(a == 10); }
         A {b, _} => { fail!(); }
     }
     let mut x@B {b, _} = B {a: 10, b: C {c: 20}};
     x.b.c = 30;
-    fail_unless!(b.c == 20);
+    assert!(b.c == 20);
     let mut y@D {d, _} = D {a: 10, d: C {c: 20}};
     y.d.c = 30;
-    fail_unless!(d.c == 20);
+    assert!(d.c == 20);
 }
diff --git a/src/test/run-pass/newlambdas.rs b/src/test/run-pass/newlambdas.rs
index 076e019bab4..1fb98d54adc 100644
--- a/src/test/run-pass/newlambdas.rs
+++ b/src/test/run-pass/newlambdas.rs
@@ -19,11 +19,11 @@ fn ff() -> @fn(int) -> int {
 }
 
 pub fn main() {
-    fail_unless!(f(10, |a| a) == 10);
+    assert!(f(10, |a| a) == 10);
     g(||());
-    fail_unless!(do f(10) |a| { a } == 10);
+    assert!(do f(10) |a| { a } == 10);
     do g() { }
     let _x: @fn() -> int = || 10;
     let _y: @fn(int) -> int = |a| a;
-    fail_unless!(ff()(10) == 11);
+    assert!(ff()(10) == 11);
 }
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index 18132d15d57..6b1b97cfd5f 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -16,7 +16,7 @@ fn myvec_elt<X:Copy>(mv: myvec<X>) -> X { return mv[0]; }
 
 pub fn main() {
     let mv = myvec(~[1, 2, 3]);
-    fail_unless!((myvec_deref(copy mv)[1] == 2));
-    fail_unless!((myvec_elt(copy mv) == 1));
-    fail_unless!((mv[2] == 3));
+    assert!((myvec_deref(copy mv)[1] == 2));
+    assert!((myvec_elt(copy mv) == 1));
+    assert!((mv[2] == 3));
 }
diff --git a/src/test/run-pass/newtype.rs b/src/test/run-pass/newtype.rs
index 6a82f70d915..ad2c502f20e 100644
--- a/src/test/run-pass/newtype.rs
+++ b/src/test/run-pass/newtype.rs
@@ -17,5 +17,5 @@ fn compute(i: mytype) -> int { return i.val + 20; }
 pub fn main() {
     let myval = mytype(Mytype{compute: compute, val: 30});
     io::println(fmt!("%d", compute(myval)));
-    fail_unless!(((myval.compute)(myval) == 50));
+    assert!(((myval.compute)(myval) == 50));
 }
diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs
index ae241e458fc..6a76f9d1646 100644
--- a/src/test/run-pass/non-boolean-pure-fns.rs
+++ b/src/test/run-pass/non-boolean-pure-fns.rs
@@ -23,12 +23,12 @@ fn pure_length<T:Copy>(ls: @List<T>) -> uint { pure_length_go(ls, 0u) }
 fn nonempty_list<T:Copy>(ls: @List<T>) -> bool { pure_length(ls) > 0u }
 
 fn safe_head<T:Copy>(ls: @List<T>) -> T {
-    fail_unless!(!is_empty(ls));
+    assert!(!is_empty(ls));
     return head(ls);
 }
 
 pub fn main() {
     let mylist = @Cons(@1u, @Nil);
-    fail_unless!((nonempty_list(mylist)));
-    fail_unless!((*safe_head(mylist) == 1u));
+    assert!((nonempty_list(mylist)));
+    assert!((*safe_head(mylist) == 1u));
 }
diff --git a/src/test/run-pass/non-legacy-modes.rs b/src/test/run-pass/non-legacy-modes.rs
index 330a9b9de7b..69feae49157 100644
--- a/src/test/run-pass/non-legacy-modes.rs
+++ b/src/test/run-pass/non-legacy-modes.rs
@@ -17,7 +17,7 @@ fn apply<T>(x: T, f: &fn(T)) {
 }
 
 fn check_int(x: int) {
-    fail_unless!(x == 22);
+    assert!(x == 22);
 }
 
 fn check_struct(x: X) {
diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs
index cda68d72ed6..6a92c1c993c 100644
--- a/src/test/run-pass/nullary-or-pattern.rs
+++ b/src/test/run-pass/nullary-or-pattern.rs
@@ -15,6 +15,6 @@ fn or_alt(q: blah) -> int {
 }
 
 pub fn main() {
-    fail_unless!((or_alt(a) == 42));
-    fail_unless!((or_alt(b) == 42));
+    assert!((or_alt(a) == 42));
+    assert!((or_alt(b) == 42));
 }
diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs
index 714852dbb86..719f1015684 100644
--- a/src/test/run-pass/numeric-method-autoexport.rs
+++ b/src/test/run-pass/numeric-method-autoexport.rs
@@ -17,26 +17,26 @@
 pub fn main() {
 // ints
     // num
-    fail_unless!(15i.add(&6) == 21);
-    fail_unless!(15i8.add(&6i8) == 21i8);
-    fail_unless!(15i16.add(&6i16) == 21i16);
-    fail_unless!(15i32.add(&6i32) == 21i32);
-    fail_unless!(15i64.add(&6i64) == 21i64);
+    assert!(15i.add(&6) == 21);
+    assert!(15i8.add(&6i8) == 21i8);
+    assert!(15i16.add(&6i16) == 21i16);
+    assert!(15i32.add(&6i32) == 21i32);
+    assert!(15i64.add(&6i64) == 21i64);
 
 // uints
     // num
-    fail_unless!(15u.add(&6u) == 21u);
-    fail_unless!(15u8.add(&6u8) == 21u8);
-    fail_unless!(15u16.add(&6u16) == 21u16);
-    fail_unless!(15u32.add(&6u32) == 21u32);
-    fail_unless!(15u64.add(&6u64) == 21u64);
+    assert!(15u.add(&6u) == 21u);
+    assert!(15u8.add(&6u8) == 21u8);
+    assert!(15u16.add(&6u16) == 21u16);
+    assert!(15u32.add(&6u32) == 21u32);
+    assert!(15u64.add(&6u64) == 21u64);
 
     // times
      15u.times(|| false);
 
 // floats
     // num
-    fail_unless!(10f.to_int() == 10);
-    fail_unless!(10f32.to_int() == 10);
-    fail_unless!(10f64.to_int() == 10);
+    assert!(10f.to_int() == 10);
+    assert!(10f32.to_int() == 10);
+    assert!(10f64.to_int() == 10);
 }
diff --git a/src/test/run-pass/one-tuple.rs b/src/test/run-pass/one-tuple.rs
index 0e483390bee..2efa0b98b6a 100644
--- a/src/test/run-pass/one-tuple.rs
+++ b/src/test/run-pass/one-tuple.rs
@@ -13,12 +13,12 @@
 pub fn main() {
     match ('c',) {
         (x,) => {
-            fail_unless!(x == 'c');
+            assert!(x == 'c');
         }
     }
     // test the 1-tuple type too
     let x: (char,) = ('d',);
     let (y,) = x;
-    fail_unless!(y == 'd');
+    assert!(y == 'd');
 }
 
diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs
index 98bec28e398..004aa864f99 100644
--- a/src/test/run-pass/opeq.rs
+++ b/src/test/run-pass/opeq.rs
@@ -16,14 +16,14 @@ pub fn main() {
     let mut x: int = 1;
     x *= 2;
     debug!(x);
-    fail_unless!((x == 2));
+    assert!((x == 2));
     x += 3;
     debug!(x);
-    fail_unless!((x == 5));
+    assert!((x == 5));
     x *= x;
     debug!(x);
-    fail_unless!((x == 25));
+    assert!((x == 25));
     x /= 5;
     debug!(x);
-    fail_unless!((x == 5));
+    assert!((x == 5));
 }
diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs
index a1af35be653..bee6d23a27d 100644
--- a/src/test/run-pass/operator-associativity.rs
+++ b/src/test/run-pass/operator-associativity.rs
@@ -12,4 +12,4 @@
 
 
 // Testcase for issue #130, operator associativity.
-pub fn main() { fail_unless!((3 * 5 / 2 == 7)); }
+pub fn main() { assert!((3 * 5 / 2 == 7)); }
diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs
index 6f479140d73..ffd6903d7f7 100644
--- a/src/test/run-pass/operator-overloading.rs
+++ b/src/test/run-pass/operator-overloading.rs
@@ -56,14 +56,14 @@ pub fn main() {
     let mut p = Point {x: 10, y: 20};
     p += Point {x: 101, y: 102};
     p = p - Point {x: 100, y: 100};
-    fail_unless!(p + Point {x: 5, y: 5} == Point {x: 16, y: 27});
-    fail_unless!(-p == Point {x: -11, y: -22});
-    fail_unless!(p[true] == 11);
-    fail_unless!(p[false] == 22);
+    assert!(p + Point {x: 5, y: 5} == Point {x: 16, y: 27});
+    assert!(-p == Point {x: -11, y: -22});
+    assert!(p[true] == 11);
+    assert!(p[false] == 22);
 
     let q = !p;
-    fail_unless!(q.x == !(p.x));
-    fail_unless!(q.y == !(p.y));
+    assert!(q.x == !(p.x));
+    assert!(q.y == !(p.y));
 
     // Issue #1733
     let result: ~fn(int) = |_|();
diff --git a/src/test/run-pass/option-unwrap.rs b/src/test/run-pass/option-unwrap.rs
index 207428c2cec..0efed2708f4 100644
--- a/src/test/run-pass/option-unwrap.rs
+++ b/src/test/run-pass/option-unwrap.rs
@@ -38,5 +38,5 @@ pub fn main() {
         let c = unwrap(b);
     }
 
-    fail_unless!(*x == 0);
+    assert!(*x == 0);
 }
diff --git a/src/test/run-pass/option_addition.rs b/src/test/run-pass/option_addition.rs
index f42d3054e5c..0bd61d1a67d 100644
--- a/src/test/run-pass/option_addition.rs
+++ b/src/test/run-pass/option_addition.rs
@@ -22,9 +22,9 @@ pub fn main() {
         None => (),
         Some(foo) => fail!(fmt!("expected None, but found %?", foo))
     }
-    fail_unless!(foo == somefoo.get());
-    fail_unless!(bar == somebar.get());
-    fail_unless!(foobar == somefoobar.get());
+    assert!(foo == somefoo.get());
+    assert!(bar == somebar.get());
+    assert!(foobar == somefoobar.get());
 }
 
 fn optint(in: int) -> Option<int> {
diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs
index c787b8dbbf2..93d51ab7e8b 100644
--- a/src/test/run-pass/or-pattern.rs
+++ b/src/test/run-pass/or-pattern.rs
@@ -15,7 +15,7 @@ fn or_alt(q: blah) -> int {
 }
 
 pub fn main() {
-    fail_unless!((or_alt(c) == 0));
-    fail_unless!((or_alt(a(10, 100, 0u)) == 110));
-    fail_unless!((or_alt(b(20, 200)) == 220));
+    assert!((or_alt(c) == 0));
+    assert!((or_alt(a(10, 100, 0u)) == 110));
+    assert!((or_alt(b(20, 200)) == 220));
 }
diff --git a/src/test/run-pass/overload-index-operator.rs b/src/test/run-pass/overload-index-operator.rs
index 7d1d0c6be0e..3030bedcccc 100644
--- a/src/test/run-pass/overload-index-operator.rs
+++ b/src/test/run-pass/overload-index-operator.rs
@@ -47,9 +47,9 @@ pub fn main() {
     list.push(copy foo, 22);
     list.push(copy bar, 44);
 
-    fail_unless!(list[foo] == 22)
-    fail_unless!(list[bar] == 44)
+    assert!(list[foo] == 22)
+    assert!(list[bar] == 44)
 
-    fail_unless!(list[foo] == 22)
-    fail_unless!(list[bar] == 44)
+    assert!(list[foo] == 22)
+    assert!(list[bar] == 44)
 }
\ No newline at end of file
diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs
index a60a761e277..63d9ec17ccb 100644
--- a/src/test/run-pass/pattern-bound-var-in-for-each.rs
+++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs
@@ -18,7 +18,7 @@ fn foo(src: uint) {
       Some(src_id) => {
         for uint::range(0u, 10u) |i| {
             let yyy = src_id;
-            fail_unless!((yyy == 0u));
+            assert!((yyy == 0u));
         }
       }
       _ => { }
diff --git a/src/test/run-pass/pipe-peek.rs b/src/test/run-pass/pipe-peek.rs
index 4058e5a492d..46fbb88aef2 100644
--- a/src/test/run-pass/pipe-peek.rs
+++ b/src/test/run-pass/pipe-peek.rs
@@ -24,9 +24,9 @@ proto! oneshot (
 pub fn main() {
     let (c, p) = oneshot::init();
 
-    fail_unless!(!pipes::peek(&p));
+    assert!(!pipes::peek(&p));
 
     oneshot::client::signal(c);
 
-    fail_unless!(pipes::peek(&p));
+    assert!(pipes::peek(&p));
 }
diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs
index 0c80fdb3a34..221ecbfcf02 100644
--- a/src/test/run-pass/pipe-select.rs
+++ b/src/test/run-pass/pipe-select.rs
@@ -48,7 +48,7 @@ pub fn main() {
         error!("selecting");
         let (i, _, _) = select(~[left, right]);
         error!("selected");
-        fail_unless!(i == 0);
+        assert!(i == 0);
 
         error!("waiting for pipes");
         let stream::send(x, _) = recv(p);
@@ -60,7 +60,7 @@ pub fn main() {
         let (i, m, _) = select(~[left, right]);
         error!("selected %?", i);
         if m.is_some() {
-            fail_unless!(i == 1);
+            assert!(i == 1);
         }
     });
 
diff --git a/src/test/run-pass/placement-new-arena.rs b/src/test/run-pass/placement-new-arena.rs
index cbee1801768..12c80421932 100644
--- a/src/test/run-pass/placement-new-arena.rs
+++ b/src/test/run-pass/placement-new-arena.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let p = &arena::Arena();
     let x = p.alloc(|| 4u);
     io::print(fmt!("%u", *x));
-    fail_unless!(*x == 4u);
+    assert!(*x == 4u);
 }
diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs
index cb92125c5d8..75f933ac769 100644
--- a/src/test/run-pass/private-class-field.rs
+++ b/src/test/run-pass/private-class-field.rs
@@ -27,5 +27,5 @@ fn cat(in_x : uint, in_y : int) -> cat {
 
 pub fn main() {
     let mut nyan : cat = cat(52u, 99);
-    fail_unless!((nyan.meow_count() == 52u));
+    assert!((nyan.meow_count() == 52u));
 }
diff --git a/src/test/run-pass/propagate-expected-type-through-block.rs b/src/test/run-pass/propagate-expected-type-through-block.rs
index c68771e4a94..aeeae0da9e3 100644
--- a/src/test/run-pass/propagate-expected-type-through-block.rs
+++ b/src/test/run-pass/propagate-expected-type-through-block.rs
@@ -8,5 +8,5 @@ pub fn main() {
         let y = y.clone();
         |x| *x + *y
     };
-    fail_unless!(foo(@22) == 25);
+    assert!(foo(@22) == 25);
 }
diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs
index f9a132f8a2c..04f86fdad01 100644
--- a/src/test/run-pass/rcvr-borrowed-to-region.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-region.rs
@@ -26,26 +26,26 @@ pub fn main() {
     /*
     let x = @mut 6;
     let y = x.get();
-    fail_unless!(y == 6);
+    assert!(y == 6);
     */
 
     let x = @6;
     let y = x.get();
     debug!("y=%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 
     let mut x = ~6;
     let y = x.get();
     debug!("y=%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 
     let x = ~6;
     let y = x.get();
     debug!("y=%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 
     let x = &6;
     let y = x.get();
     debug!("y=%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 }
diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs
index fc62ea67eab..483a2ee25e5 100644
--- a/src/test/run-pass/rcvr-borrowed-to-slice.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs
@@ -27,15 +27,15 @@ pub fn main() {
     let x = ~[1, 2, 3];
     let y = call_sum(x);
     debug!("y==%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 
     let mut x = ~[1, 2, 3];
     let y = x.sum();
     debug!("y==%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 
     let x = ~[1, 2, 3];
     let y = x.sum();
     debug!("y==%d", y);
-    fail_unless!(y == 6);
+    assert!(y == 6);
 }
diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs
index b5327638327..7447073b47c 100644
--- a/src/test/run-pass/readalias.rs
+++ b/src/test/run-pass/readalias.rs
@@ -14,6 +14,6 @@
 // -*- rust -*-
 struct Point {x: int, y: int, z: int}
 
-fn f(p: Point) { fail_unless!((p.z == 12)); }
+fn f(p: Point) { assert!((p.z == 12)); }
 
 pub fn main() { let x: Point = Point {x: 10, y: 11, z: 12}; f(x); }
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index e5a13fe9c54..5cf978b5b60 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -55,12 +55,12 @@ pub fn main() {
         debug!("y = %s", y);
 
         // per clang/gcc the alignment of `inner` is 4 on x86.
-        fail_unless!(rusti::min_align_of::<Inner>() == m::align());
+        assert!(rusti::min_align_of::<Inner>() == m::align());
 
         // per clang/gcc the size of `outer` should be 12
         // because `inner`s alignment was 4.
-        fail_unless!(sys::size_of::<Outer>() == m::size());
+        assert!(sys::size_of::<Outer>() == m::size());
 
-        fail_unless!(y == ~"{c8: 22, t: {c64: 44}}");
+        assert!(y == ~"{c8: 22, t: {c64: 44}}");
     }
 }
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index e02a1edf8a6..cd4c8640424 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -69,12 +69,12 @@ pub fn main() {
         debug!("y = %s", y);
 
         // per clang/gcc the alignment of `Inner` is 4 on x86.
-        fail_unless!(rusti::min_align_of::<Inner>() == m::m::align());
+        assert!(rusti::min_align_of::<Inner>() == m::m::align());
 
         // per clang/gcc the size of `Outer` should be 12
         // because `Inner`s alignment was 4.
-        fail_unless!(sys::size_of::<Outer>() == m::m::size());
+        assert!(sys::size_of::<Outer>() == m::m::size());
 
-        fail_unless!(y == ~"{c8: 22, t: {c64: 44}}");
+        assert!(y == ~"{c8: 22, t: {c64: 44}}");
     }
 }
diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs
index a15c8e07a2f..c352c06247b 100644
--- a/src/test/run-pass/rec-extend.rs
+++ b/src/test/run-pass/rec-extend.rs
@@ -18,10 +18,10 @@ pub fn main() {
     let origin: Point = Point {x: 0, y: 0};
     let right: Point = Point {x: origin.x + 10,.. origin};
     let up: Point = Point {y: origin.y + 10,.. origin};
-    fail_unless!((origin.x == 0));
-    fail_unless!((origin.y == 0));
-    fail_unless!((right.x == 10));
-    fail_unless!((right.y == 0));
-    fail_unless!((up.x == 0));
-    fail_unless!((up.y == 10));
+    assert!((origin.x == 0));
+    assert!((origin.y == 0));
+    assert!((right.x == 10));
+    assert!((right.y == 0));
+    assert!((up.x == 0));
+    assert!((up.y == 10));
 }
diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs
index f6bee493478..46fb619fd80 100644
--- a/src/test/run-pass/rec-tup.rs
+++ b/src/test/run-pass/rec-tup.rs
@@ -17,21 +17,21 @@ fn fst(r: rect) -> Point { let (fst, _) = r; return fst; }
 fn snd(r: rect) -> Point { let (_, snd) = r; return snd; }
 
 fn f(r: rect, x1: int, y1: int, x2: int, y2: int) {
-    fail_unless!((fst(r).x == x1));
-    fail_unless!((fst(r).y == y1));
-    fail_unless!((snd(r).x == x2));
-    fail_unless!((snd(r).y == y2));
+    assert!((fst(r).x == x1));
+    assert!((fst(r).y == y1));
+    assert!((snd(r).x == x2));
+    assert!((snd(r).y == y2));
 }
 
 pub fn main() {
     let r: rect = (Point {x: 10, y: 20}, Point {x: 11, y: 22});
-    fail_unless!((fst(r).x == 10));
-    fail_unless!((fst(r).y == 20));
-    fail_unless!((snd(r).x == 11));
-    fail_unless!((snd(r).y == 22));
+    assert!((fst(r).x == 10));
+    assert!((fst(r).y == 20));
+    assert!((snd(r).x == 11));
+    assert!((snd(r).y == 22));
     let r2 = r;
     let x: int = fst(r2).x;
-    fail_unless!((x == 10));
+    assert!((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
index 3dd35a3f519..9d9322f7f3d 100644
--- a/src/test/run-pass/rec.rs
+++ b/src/test/run-pass/rec.rs
@@ -15,21 +15,21 @@
 struct Rect {x: int, y: int, w: int, h: int}
 
 fn f(r: Rect, x: int, y: int, w: int, h: int) {
-    fail_unless!((r.x == x));
-    fail_unless!((r.y == y));
-    fail_unless!((r.w == w));
-    fail_unless!((r.h == h));
+    assert!((r.x == x));
+    assert!((r.y == y));
+    assert!((r.w == w));
+    assert!((r.h == h));
 }
 
 pub fn main() {
     let r: Rect = Rect {x: 10, y: 20, w: 100, h: 200};
-    fail_unless!((r.x == 10));
-    fail_unless!((r.y == 20));
-    fail_unless!((r.w == 100));
-    fail_unless!((r.h == 200));
+    assert!((r.x == 10));
+    assert!((r.y == 20));
+    assert!((r.w == 100));
+    assert!((r.h == 200));
     let r2: Rect = r;
     let x: int = r2.x;
-    fail_unless!((x == 10));
+    assert!((x == 10));
     f(r, 10, 20, 100, 200);
     f(r2, 10, 20, 100, 200);
 }
diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs
index 40d99fa805c..0019f1dc23b 100644
--- a/src/test/run-pass/record-pat.rs
+++ b/src/test/run-pass/record-pat.rs
@@ -20,6 +20,6 @@ fn m(in: t3) -> int {
 }
 
 pub fn main() {
-    fail_unless!((m(c(T2 {x: a(10), y: 5}, 4u)) == 10));
-    fail_unless!((m(c(T2 {x: b(10u), y: 5}, 4u)) == 19));
+    assert!((m(c(T2 {x: a(10), y: 5}, 4u)) == 10));
+    assert!((m(c(T2 {x: b(10u), y: 5}, 4u)) == 19));
 }
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index 8e363c3d5db..565c06fb8c8 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -651,7 +651,7 @@ pub fn main() {
             io::println(fmt!("val: %s", *s));
         }
         error!("%?", u.vals.clone());
-        fail_unless!(u.vals == ~[
+        assert!(u.vals == ~[
             ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"
         ]);
     }
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index 6576a6c3fa9..8a7fef95614 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -153,6 +153,6 @@ pub fn main() {
     for (v.types.clone()).each {|s|
         io::println(fmt!("type: %s", s));
     }
-    fail_unless!(v.types == ["bool", "int", "i8", "i16",
+    assert!(v.types == ["bool", "int", "i8", "i16",
                        "[", "int", "]"]);
 }
diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs
index e7edeca3b9a..42784200b66 100644
--- a/src/test/run-pass/region-dependent-addr-of.rs
+++ b/src/test/run-pass/region-dependent-addr-of.rs
@@ -87,29 +87,29 @@ pub fn main() {
                          v6: Some(C { f: 31 })}};
 
     let p = get_v1(&a);
-    fail_unless!(*p == a.value.v1);
+    assert!(*p == a.value.v1);
 
     let p = get_v2(&a, 1);
-    fail_unless!(*p == a.value.v2[1]);
+    assert!(*p == a.value.v2[1]);
 
     let p = get_v3(&a, 1);
-    fail_unless!(*p == a.value.v3[1]);
+    assert!(*p == a.value.v3[1]);
 
     let p = get_v4(&a, 1);
-    fail_unless!(*p == a.value.v4.f);
+    assert!(*p == a.value.v4.f);
 
     let p = get_v5(&a, 1);
-    fail_unless!(*p == a.value.v5.f);
+    assert!(*p == a.value.v5.f);
 
     let p = get_v6_a(&a, 1);
-    fail_unless!(*p == a.value.v6.get().f);
+    assert!(*p == a.value.v6.get().f);
 
     let p = get_v6_b(&a, 1);
-    fail_unless!(*p == a.value.v6.get().f);
+    assert!(*p == a.value.v6.get().f);
 
     let p = get_v6_c(&a, 1);
-    fail_unless!(*p == a.value.v6.get().f);
+    assert!(*p == a.value.v6.get().f);
 
     let p = get_v5_ref(&a, 1);
-    fail_unless!(*p == a.value.v5.f);
+    assert!(*p == a.value.v5.f);
 }
diff --git a/src/test/run-pass/region-return-interior-of-option.rs b/src/test/run-pass/region-return-interior-of-option.rs
index 5fd3da67a17..45090e908bb 100644
--- a/src/test/run-pass/region-return-interior-of-option.rs
+++ b/src/test/run-pass/region-return-interior-of-option.rs
@@ -20,13 +20,13 @@ pub fn main() {
 
     {
         let y = get(&x);
-        fail_unless!(*y == 23);
+        assert!(*y == 23);
     }
 
     x = Some(24);
 
     {
         let y = get(&x);
-        fail_unless!(*y == 24);
+        assert!(*y == 24);
     }
 }
diff --git a/src/test/run-pass/regions-appearance-constraint.rs b/src/test/run-pass/regions-appearance-constraint.rs
index aa2e2598697..cfe721612e1 100644
--- a/src/test/run-pass/regions-appearance-constraint.rs
+++ b/src/test/run-pass/regions-appearance-constraint.rs
@@ -25,7 +25,7 @@ fn testfn(cond: bool) {
 
     x = @5;
     y = @6;
-    fail_unless!(*a == exp);
+    assert!(*a == exp);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs
index 8ef3eaf41fe..f12c80c2e88 100644
--- a/src/test/run-pass/regions-borrow-at.rs
+++ b/src/test/run-pass/regions-borrow-at.rs
@@ -16,5 +16,5 @@ pub fn main() {
     let p = @22u;
     let r = foo(p);
     debug!("r=%u", r);
-    fail_unless!(r == 22u);
+    assert!(r == 22u);
 }
diff --git a/src/test/run-pass/regions-borrow-estr-uniq.rs b/src/test/run-pass/regions-borrow-estr-uniq.rs
index 7edc0879101..18082e85751 100644
--- a/src/test/run-pass/regions-borrow-estr-uniq.rs
+++ b/src/test/run-pass/regions-borrow-estr-uniq.rs
@@ -15,9 +15,9 @@ fn foo(x: &str) -> u8 {
 pub fn main() {
     let p = ~"hello";
     let r = foo(p);
-    fail_unless!(r == 'h' as u8);
+    assert!(r == 'h' as u8);
 
     let p = ~"hello";
     let r = foo(p);
-    fail_unless!(r == 'h' as u8);
+    assert!(r == 'h' as u8);
 }
diff --git a/src/test/run-pass/regions-borrow-evec-at.rs b/src/test/run-pass/regions-borrow-evec-at.rs
index b3c62fb0ead..3247f9df30d 100644
--- a/src/test/run-pass/regions-borrow-evec-at.rs
+++ b/src/test/run-pass/regions-borrow-evec-at.rs
@@ -17,5 +17,5 @@ fn foo(x: &[uint]) -> uint {
 pub fn main() {
     let p = @[22u];
     let r = foo(p);
-    fail_unless!(r == 22u);
+    assert!(r == 22u);
 }
diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs
index 010daac8cc1..557b66735c0 100644
--- a/src/test/run-pass/regions-borrow-evec-fixed.rs
+++ b/src/test/run-pass/regions-borrow-evec-fixed.rs
@@ -16,5 +16,5 @@ fn foo(x: &[int]) -> int {
 
 pub fn main() {
     let p = [1,2,3,4,5];
-    fail_unless!(foo(p) == 1);
+    assert!(foo(p) == 1);
 }
diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs
index d55caa9b46e..80ea1bb452d 100644
--- a/src/test/run-pass/regions-borrow-evec-uniq.rs
+++ b/src/test/run-pass/regions-borrow-evec-uniq.rs
@@ -15,9 +15,9 @@ fn foo(x: &[int]) -> int {
 pub fn main() {
     let p = ~[1,2,3,4,5];
     let r = foo(p);
-    fail_unless!(r == 1);
+    assert!(r == 1);
 
     let p = ~[5,4,3,2,1];
     let r = foo(p);
-    fail_unless!(r == 5);
+    assert!(r == 5);
 }
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index a2d06b6e23b..e59352667c2 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -15,5 +15,5 @@ fn foo(x: &uint) -> uint {
 pub fn main() {
     let p = ~3u;
     let r = foo(p);
-    fail_unless!(r == 3u);
+    assert!(r == 3u);
 }
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index 54cfb5f5fcc..308528ef572 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -19,7 +19,7 @@ fn box_it<'r>(+x: &'r fn()) -> closure_box<'r> {
 pub fn main() {
     let mut i = 3;
     let cl_box = box_it(|| i += 1);
-    fail_unless!(i == 3);
+    assert!(i == 3);
     (cl_box.cl)();
-    fail_unless!(i == 4);
+    assert!(i == 4);
 }
diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs
index d9e58310246..22b98726fb1 100644
--- a/src/test/run-pass/regions-escape-into-other-fn.rs
+++ b/src/test/run-pass/regions-escape-into-other-fn.rs
@@ -13,5 +13,5 @@ fn bar(x: &uint) -> uint { *x }
 
 pub fn main() {
     let p = @3u;
-    fail_unless!(bar(foo(p)) == 3);
+    assert!(bar(foo(p)) == 3);
 }
diff --git a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
index 619a79b1ab5..ee2682ff4ab 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs
@@ -20,7 +20,7 @@ pub fn main() {
         match i {
           i => {
             let y = &x;
-            fail_unless!(i < *y);
+            assert!(i < *y);
           }
         }
         let mut y = 4;
diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs
index 7c970253b98..9358ea8a777 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-view.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs
@@ -14,6 +14,6 @@ pub fn main() {
     let v = ~[1, 2, 3];
     let x = view(v);
     let y = view(x);
-    fail_unless!((v[0] == x[0]) && (v[0] == y[0]));
+    assert!((v[0] == x[0]) && (v[0] == y[0]));
 }
 
diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
index a184f47b65f..08c54c790b1 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
@@ -14,7 +14,7 @@ pub fn main() {
     let x = @3;
     loop {
         let y = borrow(x);
-        fail_unless!(*x == *y);
+        assert!(*x == *y);
 	break;
     }
 }
diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs
index a3cb1e32eb5..e06a2fea1c1 100644
--- a/src/test/run-pass/regions-infer-borrow-scope.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope.rs
@@ -17,6 +17,6 @@ fn x_coord<'r>(p: &'r Point) -> &'r int {
 pub fn main() {
     let p = @Point {x: 3, y: 4};
     let xc = x_coord(p);
-    fail_unless!(*xc == 3);
+    assert!(*xc == 3);
 }
 
diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs
index 9933d55f747..2772660ff83 100644
--- a/src/test/run-pass/regions-infer-call-2.rs
+++ b/src/test/run-pass/regions-infer-call-2.rs
@@ -19,5 +19,5 @@ fn has_one<'a>(x: &'a int) -> int {
 }
 
 pub fn main() {
-    fail_unless!(has_one(&2) == 22);
+    assert!(has_one(&2) == 22);
 }
diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs
index e83f11de31d..39dec6c8133 100644
--- a/src/test/run-pass/regions-infer-call.rs
+++ b/src/test/run-pass/regions-infer-call.rs
@@ -15,5 +15,5 @@ fn has_two<'a,'b>(x: &'a int, y: &'b int) -> int {
 }
 
 pub fn main() {
-    fail_unless!(has_two(&20, &2) == 22);
+    assert!(has_two(&20, &2) == 22);
 }
diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
index d45925229fa..46581e4f3d0 100644
--- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
+++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs
@@ -24,5 +24,5 @@ fn with(bi: &boxed_int) -> int {
 pub fn main() {
     let g = 21;
     let foo = boxed_int { f: &g };
-    fail_unless!(with(&foo) == 22);
+    assert!(with(&foo) == 22);
 }
diff --git a/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs b/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs
index cef3e6e8243..346a0fcfe07 100644
--- a/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs
+++ b/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs
@@ -34,5 +34,5 @@ fn get_int<G: Getter>(g: &G) -> int {
 
 pub fn main() {
     let foo = Foo { field: 22 };
-    fail_unless!(get_int(&foo) == 22);
+    assert!(get_int(&foo) == 22);
 }
diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs
index cc5b89405aa..8a8147e42d9 100644
--- a/src/test/run-pass/regions-params.rs
+++ b/src/test/run-pass/regions-params.rs
@@ -23,5 +23,5 @@ fn parameterized(x: &uint) -> uint {
 
 pub fn main() {
     let x = 3u;
-    fail_unless!(parameterized(&x) == 3u);
+    assert!(parameterized(&x) == 3u);
 }
diff --git a/src/test/run-pass/regions-trait.rs b/src/test/run-pass/regions-trait.rs
index 92ef18967b3..f4532720579 100644
--- a/src/test/run-pass/regions-trait.rs
+++ b/src/test/run-pass/regions-trait.rs
@@ -30,5 +30,5 @@ pub fn main() {
     let ctxt = Ctxt { v: 22 };
     let hc = HasCtxt { c: &ctxt };
 
-    fail_unless!(get_v(@hc as @get_ctxt) == 22);
+    assert!(get_v(@hc as @get_ctxt) == 22);
 }
diff --git a/src/test/run-pass/resolve-issue-2428.rs b/src/test/run-pass/resolve-issue-2428.rs
index 799db4ed212..6d00210898b 100644
--- a/src/test/run-pass/resolve-issue-2428.rs
+++ b/src/test/run-pass/resolve-issue-2428.rs
@@ -12,4 +12,4 @@
 
 static foo: int = 4 >> 1;
 enum bs { thing = foo }
-pub fn main() { fail_unless!((thing as int == foo)); }
+pub fn main() { assert!((thing as int == foo)); }
diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs
index 7d9c01cd2e3..68ec3fc4d42 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -36,5 +36,5 @@ pub fn main() {
         let (c, _d) = b;
         debug!(c);
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs
index cc9a27fd9e4..1fcf677a0b3 100644
--- a/src/test/run-pass/resource-destruct.rs
+++ b/src/test/run-pass/resource-destruct.rs
@@ -33,7 +33,7 @@ fn shrinky_pointer(i: @@mut int) -> shrinky_pointer {
 
 pub fn main() {
     let my_total = @@mut 10;
-    { let pt = shrinky_pointer(my_total); fail_unless!((pt.look_at() == 10)); }
+    { let pt = shrinky_pointer(my_total); assert!((pt.look_at() == 10)); }
     error!("my_total = %d", **my_total);
-    fail_unless!((**my_total == 9));
+    assert!((**my_total == 9));
 }
diff --git a/src/test/run-pass/resource-generic.rs b/src/test/run-pass/resource-generic.rs
index 4ce6a37956c..8a1835d6585 100644
--- a/src/test/run-pass/resource-generic.rs
+++ b/src/test/run-pass/resource-generic.rs
@@ -36,5 +36,5 @@ pub fn main() {
     fn dec_box(i: @mut int) { *i -= 1; }
 
     { let _i = finish(Arg{val: box, fin: dec_box}); }
-    fail_unless!((*box == 9));
+    assert!((*box == 9));
 }
diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs
index 9eb680ed7cc..d74ec61d3c0 100644
--- a/src/test/run-pass/resource-in-struct.rs
+++ b/src/test/run-pass/resource-in-struct.rs
@@ -41,5 +41,5 @@ pub fn main() {
     let c = @mut true;
     sink(none);
     sink(some(close_res(c)));
-    fail_unless!((!*c));
+    assert!((!*c));
 }
diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs
index 6fe5831644f..ab61cee4223 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -33,11 +33,11 @@ fn bail_deep(x: ~[~[bool]]) {
     let mut seen = false;
     for iter(x.clone()) |x| {
         for iter(x.clone()) |x| {
-            fail_unless!(!seen);
+            assert!(!seen);
             if *x { seen = true; return; }
         }
     }
-    fail_unless!(!seen);
+    assert!(!seen);
 }
 
 fn ret_deep() -> ~str {
@@ -55,17 +55,17 @@ pub fn main() {
         last = *e;
         if *e == 5 { break; }
         if *e % 2 == 1 { loop; }
-        fail_unless!(*e % 2 == 0);
+        assert!(*e % 2 == 0);
     };
-    fail_unless!(last == 5);
+    assert!(last == 5);
 
-    fail_unless!(find_pos(1, ~[0, 1, 2, 3]) == Some(1u));
-    fail_unless!(find_pos(1, ~[0, 4, 2, 3]) == None);
-    fail_unless!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == Some(3u));
+    assert!(find_pos(1, ~[0, 1, 2, 3]) == Some(1u));
+    assert!(find_pos(1, ~[0, 4, 2, 3]) == None);
+    assert!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == Some(3u));
 
     bail_deep(~[~[false, false], ~[true, true], ~[false, true]]);
     bail_deep(~[~[true]]);
     bail_deep(~[~[false, false, false]]);
 
-    fail_unless!(ret_deep() == ~"hi");
+    assert!(ret_deep() == ~"hi");
 }
diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs
index cb0a531929a..8bf5627b4cd 100644
--- a/src/test/run-pass/rt-sched-1.rs
+++ b/src/test/run-pass/rt-sched-1.rs
@@ -38,13 +38,13 @@ pub fn main() {
         let new_sched_id = rustrt::rust_new_sched(num_threads);
         error!("new_sched_id %?", new_sched_id);
         let new_task_id = rustrt::rust_new_task_in_sched(new_sched_id);
-        fail_unless!(!new_task_id.is_null());
+        assert!(!new_task_id.is_null());
         let f: ~fn() = || {
             unsafe {
                 let child_sched_id = rustrt::rust_get_sched_id();
                 error!("child_sched_id %?", child_sched_id);
-                fail_unless!(child_sched_id != parent_sched_id);
-                fail_unless!(child_sched_id == new_sched_id);
+                assert!(child_sched_id != parent_sched_id);
+                assert!(child_sched_id == new_sched_id);
                 ch.send(());
             }
         };
diff --git a/src/test/run-pass/self-shadowing-import.rs b/src/test/run-pass/self-shadowing-import.rs
index a5b2d07bdc6..b1d36422487 100644
--- a/src/test/run-pass/self-shadowing-import.rs
+++ b/src/test/run-pass/self-shadowing-import.rs
@@ -20,7 +20,7 @@ mod a {
 
 mod c {
     use a::b::a;
-    pub fn bar() { fail_unless!((a::foo() == 1)); }
+    pub fn bar() { assert!((a::foo() == 1)); }
 }
 
 pub fn main() { c::bar(); }
diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs
index 6322d24ffd9..2351540baa9 100644
--- a/src/test/run-pass/sendfn-generic-fn.rs
+++ b/src/test/run-pass/sendfn-generic-fn.rs
@@ -21,13 +21,13 @@ fn make_generic_record<A:Copy,B:Copy>(a: A, b: B) -> Pair<A,B> {
 fn test05_start(f: &~fn(v: float, v: ~str) -> Pair<float, ~str>) {
     let p = (*f)(22.22f, ~"Hi");
     debug!(copy p);
-    fail_unless!(p.a == 22.22f);
-    fail_unless!(p.b == ~"Hi");
+    assert!(p.a == 22.22f);
+    assert!(p.b == ~"Hi");
 
     let q = (*f)(44.44f, ~"Ho");
     debug!(copy q);
-    fail_unless!(q.a == 44.44f);
-    fail_unless!(q.b == ~"Ho");
+    assert!(q.a == 44.44f);
+    assert!(q.b == ~"Ho");
 }
 
 fn spawn<A:Copy,B:Copy>(f: extern fn(&~fn(A,B)->Pair<A,B>)) {
diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs
index 0d9d01f9e70..8ccc6bb5efb 100644
--- a/src/test/run-pass/sendfn-is-a-block.rs
+++ b/src/test/run-pass/sendfn-is-a-block.rs
@@ -16,5 +16,5 @@ fn test(f: &fn(uint) -> uint) -> uint {
 
 pub fn main() {
     let y = test(|x| 4u * x);
-    fail_unless!(y == 88u);
+    assert!(y == 88u);
 }
diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index a4d88e7f25b..a91a6a92820 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -18,7 +18,7 @@ fn test05() {
     let three = ~3;
     let fn_to_send: ~fn(int) = |n| {
         error!(*three + n); // will copy x into the closure
-        fail_unless!((*three == 3));
+        assert!((*three == 3));
     };
     task::spawn(|| {
         test05_start(fn_to_send);
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index 22df0553718..5fb52973600 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -11,16 +11,16 @@
 
 
 pub fn main() {
-    fail_unless!((~"hello" < ~"hellr"));
-    fail_unless!((~"hello " > ~"hello"));
-    fail_unless!((~"hello" != ~"there"));
-    fail_unless!((~[1, 2, 3, 4] > ~[1, 2, 3]));
-    fail_unless!((~[1, 2, 3] < ~[1, 2, 3, 4]));
-    fail_unless!((~[1, 2, 4, 4] > ~[1, 2, 3, 4]));
-    fail_unless!((~[1, 2, 3, 4] < ~[1, 2, 4, 4]));
-    fail_unless!((~[1, 2, 3] <= ~[1, 2, 3]));
-    fail_unless!((~[1, 2, 3] <= ~[1, 2, 3, 3]));
-    fail_unless!((~[1, 2, 3, 4] > ~[1, 2, 3]));
-    fail_unless!((~[1, 2, 3] == ~[1, 2, 3]));
-    fail_unless!((~[1, 2, 3] != ~[1, 1, 3]));
+    assert!((~"hello" < ~"hellr"));
+    assert!((~"hello " > ~"hello"));
+    assert!((~"hello" != ~"there"));
+    assert!((~[1, 2, 3, 4] > ~[1, 2, 3]));
+    assert!((~[1, 2, 3] < ~[1, 2, 3, 4]));
+    assert!((~[1, 2, 4, 4] > ~[1, 2, 3, 4]));
+    assert!((~[1, 2, 3, 4] < ~[1, 2, 4, 4]));
+    assert!((~[1, 2, 3] <= ~[1, 2, 3]));
+    assert!((~[1, 2, 3] <= ~[1, 2, 3, 3]));
+    assert!((~[1, 2, 3, 4] > ~[1, 2, 3]));
+    assert!((~[1, 2, 3] == ~[1, 2, 3]));
+    assert!((~[1, 2, 3] != ~[1, 1, 3]));
 }
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index 716138a30ed..99553cfcf79 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -28,4 +28,4 @@ fn foo(c: ~[int]) {
 
 enum t<T> { none, some(T), }
 
-pub fn main() { let x = 10; let x = x + 20; fail_unless!((x == 30)); foo(~[]); }
+pub fn main() { let x = 10; let x = x + 20; assert!((x == 30)); foo(~[]); }
diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs
index cea32fc745e..d839825a773 100644
--- a/src/test/run-pass/shift.rs
+++ b/src/test/run-pass/shift.rs
@@ -18,64 +18,64 @@ pub fn main() {
 }
 
 fn test_misc() {
-    fail_unless!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64 == 32);
+    assert!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64 == 32);
 }
 
 fn test_expr() {
     let v10 = 10 as uint;
     let v4 = 4 as u8;
     let v2 = 2 as u8;
-    fail_unless!((v10 >> v2 == v2 as uint));
-    fail_unless!((v10 << v4 == 160 as uint));
+    assert!((v10 >> v2 == v2 as uint));
+    assert!((v10 << v4 == 160 as uint));
 
     let v10 = 10 as u8;
     let v4 = 4 as uint;
     let v2 = 2 as uint;
-    fail_unless!((v10 >> v2 == v2 as u8));
-    fail_unless!((v10 << v4 == 160 as u8));
+    assert!((v10 >> v2 == v2 as u8));
+    assert!((v10 << v4 == 160 as u8));
 
     let v10 = 10 as int;
     let v4 = 4 as i8;
     let v2 = 2 as i8;
-    fail_unless!((v10 >> v2 == v2 as int));
-    fail_unless!((v10 << v4 == 160 as int));
+    assert!((v10 >> v2 == v2 as int));
+    assert!((v10 << v4 == 160 as int));
 
     let v10 = 10 as i8;
     let v4 = 4 as int;
     let v2 = 2 as int;
-    fail_unless!((v10 >> v2 == v2 as i8));
-    fail_unless!((v10 << v4 == 160 as i8));
+    assert!((v10 >> v2 == v2 as i8));
+    assert!((v10 << v4 == 160 as i8));
 
     let v10 = 10 as uint;
     let v4 = 4 as int;
     let v2 = 2 as int;
-    fail_unless!((v10 >> v2 == v2 as uint));
-    fail_unless!((v10 << v4 == 160 as uint));
+    assert!((v10 >> v2 == v2 as uint));
+    assert!((v10 << v4 == 160 as uint));
 }
 
 fn test_const() {
     static r1_1: uint = 10u >> 2u8;
     static r2_1: uint = 10u << 4u8;
-    fail_unless!(r1_1 == 2 as uint);
-    fail_unless!(r2_1 == 160 as uint);
+    assert!(r1_1 == 2 as uint);
+    assert!(r2_1 == 160 as uint);
 
     static r1_2: u8 = 10u8 >> 2u;
     static r2_2: u8 = 10u8 << 4u;
-    fail_unless!(r1_2 == 2 as u8);
-    fail_unless!(r2_2 == 160 as u8);
+    assert!(r1_2 == 2 as u8);
+    assert!(r2_2 == 160 as u8);
 
     static r1_3: int = 10 >> 2i8;
     static r2_3: int = 10 << 4i8;
-    fail_unless!(r1_3 == 2 as int);
-    fail_unless!(r2_3 == 160 as int);
+    assert!(r1_3 == 2 as int);
+    assert!(r2_3 == 160 as int);
 
     static r1_4: i8 = 10i8 >> 2;
     static r2_4: i8 = 10i8 << 4;
-    fail_unless!(r1_4 == 2 as i8);
-    fail_unless!(r2_4 == 160 as i8);
+    assert!(r1_4 == 2 as i8);
+    assert!(r2_4 == 160 as i8);
 
     static r1_5: uint = 10u >> 2i8;
     static r2_5: uint = 10u << 4i8;
-    fail_unless!(r1_5 == 2 as uint);
-    fail_unless!(r2_5 == 160 as uint);
+    assert!(r1_5 == 2 as uint);
+    assert!(r2_5 == 160 as uint);
 }
diff --git a/src/test/run-pass/signed-shift-const-eval.rs b/src/test/run-pass/signed-shift-const-eval.rs
index e7e954bd787..0d3ecae01fb 100644
--- a/src/test/run-pass/signed-shift-const-eval.rs
+++ b/src/test/run-pass/signed-shift-const-eval.rs
@@ -10,5 +10,5 @@
 
 enum test { thing = -5 >> 1u }
 pub fn main() {
-    fail_unless!((thing as int == -3));
+    assert!((thing as int == -3));
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index a9daf15e433..7bc55d647df 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -19,7 +19,7 @@ use core::comm::*;
 type ctx = Chan<int>;
 
 fn iotask(cx: &ctx, ip: ~str) {
-    fail_unless!((ip == ~"localhost"));
+    assert!((ip == ~"localhost"));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index 4da560b8b92..db4ca7b3ed8 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -17,7 +17,7 @@ pub fn main() {
     task::spawn(|| child(10) );
 }
 
-fn child(&&i: int) { error!(i); fail_unless!((i == 10)); }
+fn child(&&i: int) { error!(i); assert!((i == 10)); }
 
 // Local Variables:
 // mode: rust;
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 6bd3af73dd0..f9350746349 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -22,15 +22,15 @@ fn child(&&args: (int, int, int, int, int, int, int, int, int)) {
     error!(i7);
     error!(i8);
     error!(i9);
-    fail_unless!((i1 == 10));
-    fail_unless!((i2 == 20));
-    fail_unless!((i3 == 30));
-    fail_unless!((i4 == 40));
-    fail_unless!((i5 == 50));
-    fail_unless!((i6 == 60));
-    fail_unless!((i7 == 70));
-    fail_unless!((i8 == 80));
-    fail_unless!((i9 == 90));
+    assert!((i1 == 10));
+    assert!((i2 == 20));
+    assert!((i3 == 30));
+    assert!((i4 == 40));
+    assert!((i5 == 50));
+    assert!((i6 == 60));
+    assert!((i7 == 70));
+    assert!((i8 == 80));
+    assert!((i9 == 90));
 }
 
 // Local Variables:
diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs
index 1b623fa6426..a2e43f14898 100644
--- a/src/test/run-pass/stable-addr-of.rs
+++ b/src/test/run-pass/stable-addr-of.rs
@@ -12,5 +12,5 @@
 
 pub fn main() {
     let foo = 1;
-    fail_unless!(ptr::addr_of(&foo) == ptr::addr_of(&foo));
+    assert!(ptr::addr_of(&foo) == ptr::addr_of(&foo));
 }
diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs
index 6b3a37a9d79..0967eaf0615 100644
--- a/src/test/run-pass/stat.rs
+++ b/src/test/run-pass/stat.rs
@@ -29,8 +29,8 @@ pub fn main() {
         }
     }
 
-    fail_unless!(path.exists());
-    fail_unless!(path.get_size() == Some(1000));
+    assert!(path.exists());
+    assert!(path.get_size() == Some(1000));
 
     os::remove_dir(&dir);
 }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 560406c9c40..3f4a956b3a4 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -54,13 +54,13 @@ impl<T> vec_utils<T> for ~[T] {
 }
 
 pub fn main() {
-    fail_unless!(10u.plus() == 30);
-    fail_unless!((~"hi").plus() == 200);
+    assert!(10u.plus() == 30);
+    assert!((~"hi").plus() == 200);
 
-    fail_unless!((~[1]).length_().str() == ~"1");
-    fail_unless!((~[3, 4]).map_(|a| *a + 4 )[0] == 7);
-    fail_unless!((~[3, 4]).map_::<uint>(|a| *a as uint + 4u )[0] == 7u);
+    assert!((~[1]).length_().str() == ~"1");
+    assert!((~[3, 4]).map_(|a| *a + 4 )[0] == 7);
+    assert!((~[3, 4]).map_::<uint>(|a| *a as uint + 4u )[0] == 7u);
     let mut x = 0u;
     10u.multi(|_n| x += 2u );
-    fail_unless!(x == 20u);
+    assert!(x == 20u);
 }
diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
index 1b5cb86360b..e8bb9c485ea 100644
--- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
+++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs
@@ -31,5 +31,5 @@ impl Deserializer for FromThinAir {
 pub fn main() {
     let d = FromThinAir { dummy: () };
     let i: int = Deserializable::deserialize(&d);
-    fail_unless!(i == 22);
+    assert!(i == 22);
 }
diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs
index 624a38b789b..388a7100daf 100644
--- a/src/test/run-pass/static-method-test.rs
+++ b/src/test/run-pass/static-method-test.rs
@@ -77,15 +77,15 @@ fn seq_range<BT:buildable<int>>(lo: uint, hi: uint) -> BT {
 
 pub fn main() {
     let v: @[int] = seq_range(0, 10);
-    fail_unless!(v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    assert!(v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
     let v: @[int] = map(&[1,2,3], |x| 1+x);
-    fail_unless!(v == @[2, 3, 4]);
+    assert!(v == @[2, 3, 4]);
     let v: ~[int] = map(&[1,2,3], |x| 1+x);
-    fail_unless!(v == ~[2, 3, 4]);
+    assert!(v == ~[2, 3, 4]);
 
-    fail_unless!(bool_like::select(true, 9, 14) == 9);
-    fail_unless!(!andand(true, false));
-    fail_unless!(andand(7, 12) == 12);
-    fail_unless!(andand(0, 12) == 0);
+    assert!(bool_like::select(true, 9, 14) == 9);
+    assert!(!andand(true, false));
+    assert!(andand(7, 12) == 12);
+    assert!(andand(0, 12) == 0);
 }
diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs
index f768edf7b9b..aa4f65669ad 100644
--- a/src/test/run-pass/static-method-xcrate.rs
+++ b/src/test/run-pass/static-method-xcrate.rs
@@ -17,7 +17,7 @@ use readMaybeRenamed = static_methods_crate::read::readMaybe;
 
 pub fn main() {
     let result: int = read(~"5");
-    fail_unless!(result == 5);
-    fail_unless!(readMaybeRenamed(~"false") == Some(false));
-    fail_unless!(readMaybeRenamed(~"foo") == None::<bool>);
+    assert!(result == 5);
+    assert!(readMaybeRenamed(~"false") == Some(false));
+    assert!(readMaybeRenamed(~"foo") == None::<bool>);
 }
diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs
index 24bcfcef1e7..d171434aa48 100644
--- a/src/test/run-pass/static-methods-in-traits.rs
+++ b/src/test/run-pass/static-methods-in-traits.rs
@@ -29,7 +29,7 @@ mod a {
 pub fn main() {
 	let x: int = a::Foo::foo();
 	let y: uint = a::Foo::foo();
-	fail_unless!(x == 3);
-	fail_unless!(y == 5);
+	assert!(x == 3);
+	assert!(y == 5);
 }
 
diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs
index d1592c46dc9..4332a184eda 100644
--- a/src/test/run-pass/str-append.rs
+++ b/src/test/run-pass/str-append.rs
@@ -17,7 +17,7 @@ fn test1() {
     let mut s: ~str = ~"hello";
     s += ~"world";
     debug!(s.clone());
-    fail_unless!((s[9] == 'd' as u8));
+    assert!((s[9] == 'd' as u8));
 }
 
 fn test2() {
@@ -28,8 +28,8 @@ fn test2() {
     let b: ~str = ~"ABC" + ff + ~"ABC";
     debug!(a.clone());
     debug!(b.clone());
-    fail_unless!((a == ~"abcABCabc"));
-    fail_unless!((b == ~"ABCabcABC"));
+    assert!((a == ~"abcABCabc"));
+    assert!((b == ~"ABCabcABC"));
 }
 
 pub fn main() { test1(); test2(); }
diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
index 107998d3def..0d43329baae 100644
--- a/src/test/run-pass/str-concat.rs
+++ b/src/test/run-pass/str-concat.rs
@@ -17,5 +17,5 @@ pub fn main() {
     let b: ~str = ~"world";
     let s: ~str = a + b;
     debug!(s.clone());
-    fail_unless!((s[9] == 'd' as u8));
+    assert!((s[9] == 'd' as u8));
 }
diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs
index 72d198cc63d..fe9721a92e0 100644
--- a/src/test/run-pass/str-growth.rs
+++ b/src/test/run-pass/str-growth.rs
@@ -13,12 +13,12 @@
 pub fn main() {
     let mut s = ~"a";
     s += ~"b";
-    fail_unless!((s[0] == 'a' as u8));
-    fail_unless!((s[1] == 'b' as u8));
+    assert!((s[0] == 'a' as u8));
+    assert!((s[1] == 'b' as u8));
     s += ~"c";
     s += ~"d";
-    fail_unless!((s[0] == 'a' as u8));
-    fail_unless!((s[1] == 'b' as u8));
-    fail_unless!((s[2] == 'c' as u8));
-    fail_unless!((s[3] == 'd' as u8));
+    assert!((s[0] == 'a' as u8));
+    assert!((s[1] == 'b' as u8));
+    assert!((s[2] == 'c' as u8));
+    assert!((s[3] == 'd' as u8));
 }
diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs
index a2146d8770a..24d2438e868 100644
--- a/src/test/run-pass/str-idx.rs
+++ b/src/test/run-pass/str-idx.rs
@@ -14,5 +14,5 @@ pub fn main() {
     let s = ~"hello";
     let c: u8 = s[4];
     debug!(c);
-    fail_unless!((c == 0x6f as u8));
+    assert!((c == 0x6f as u8));
 }
diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs
index 254bffecf61..ae400acdb8f 100644
--- a/src/test/run-pass/str-multiline.rs
+++ b/src/test/run-pass/str-multiline.rs
@@ -21,6 +21,6 @@ is a test";
                is \
                another \
                test";
-    fail_unless!((a == ~"this is a test"));
-    fail_unless!((b == ~"this is another test"));
+    assert!((a == ~"this is a test"));
+    assert!((b == ~"this is another test"));
 }
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index a1243d33062..c19a2afbd41 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -17,7 +17,7 @@ pub fn main() {
     let mut expected_len = 1u;
     while i > 0 {
         error!(str::len(a));
-        fail_unless!((str::len(a) == expected_len));
+        assert!((str::len(a) == expected_len));
         a = a + a; // FIXME(#3387)---can't write a += a
         i -= 1;
         expected_len *= 2u;
diff --git a/src/test/run-pass/struct-deref.rs b/src/test/run-pass/struct-deref.rs
index f560c72eec3..f71bc06a1cf 100644
--- a/src/test/run-pass/struct-deref.rs
+++ b/src/test/run-pass/struct-deref.rs
@@ -12,6 +12,6 @@ struct Foo(int);
 
 pub fn main() {
     let x: Foo = Foo(2);
-    fail_unless!(*x == 2);
+    assert!(*x == 2);
 }
 
diff --git a/src/test/run-pass/struct-destructuring-cross-crate.rs b/src/test/run-pass/struct-destructuring-cross-crate.rs
index a32c6204a99..55d25845971 100644
--- a/src/test/run-pass/struct-destructuring-cross-crate.rs
+++ b/src/test/run-pass/struct-destructuring-cross-crate.rs
@@ -16,6 +16,6 @@ extern mod struct_destructuring_cross_crate;
 pub fn main() {
     let x = struct_destructuring_cross_crate::S { x: 1, y: 2 };
     let struct_destructuring_cross_crate::S { x: a, y: b } = x;
-    fail_unless!(a == 1);
-    fail_unless!(b == 2);
+    assert!(a == 1);
+    assert!(b == 2);
 }
diff --git a/src/test/run-pass/struct-field-assignability.rs b/src/test/run-pass/struct-field-assignability.rs
index f877a766ead..1e13c7b86bf 100644
--- a/src/test/run-pass/struct-field-assignability.rs
+++ b/src/test/run-pass/struct-field-assignability.rs
@@ -4,6 +4,6 @@ struct Foo<'self> {
 
 pub fn main() {
     let f = Foo { x: @3 };
-    fail_unless!(*f.x == 3);
+    assert!(*f.x == 3);
 }
 
diff --git a/src/test/run-pass/struct-like-variant-match.rs b/src/test/run-pass/struct-like-variant-match.rs
index 0658b72af6b..3158d2836dd 100644
--- a/src/test/run-pass/struct-like-variant-match.rs
+++ b/src/test/run-pass/struct-like-variant-match.rs
@@ -22,12 +22,12 @@ enum Foo {
 fn f(x: &Foo) {
     match *x {
         Baz { x: x, y: y } => {
-            fail_unless!(x == 1.0);
-            fail_unless!(y == 2.0);
+            assert!(x == 1.0);
+            assert!(y == 2.0);
         }
         Bar { y: y, x: x } => {
-            fail_unless!(x == 1);
-            fail_unless!(y == 2);
+            assert!(x == 1);
+            assert!(y == 2);
         }
     }
 }
diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs
index dbee7226228..f702ca5144e 100644
--- a/src/test/run-pass/struct-return.rs
+++ b/src/test/run-pass/struct-return.rs
@@ -32,10 +32,10 @@ fn test1() {
         error!("b: %x", qq.b as uint);
         error!("c: %x", qq.c as uint);
         error!("d: %x", qq.d as uint);
-        fail_unless!(qq.a == q.c + 1u64);
-        fail_unless!(qq.b == q.d - 1u64);
-        fail_unless!(qq.c == q.a + 1u64);
-        fail_unless!(qq.d == q.b - 1u64);
+        assert!(qq.a == q.c + 1u64);
+        assert!(qq.b == q.d - 1u64);
+        assert!(qq.c == q.a + 1u64);
+        assert!(qq.d == q.b - 1u64);
     }
 }
 
@@ -49,9 +49,9 @@ fn test2() {
         error!("a: %f", ff.a as float);
         error!("b: %u", ff.b as uint);
         error!("c: %f", ff.c as float);
-        fail_unless!(ff.a == f.c + 1.0f64);
-        fail_unless!(ff.b == 0xff_u8);
-        fail_unless!(ff.c == f.a - 1.0f64);
+        assert!(ff.a == f.c + 1.0f64);
+        assert!(ff.b == 0xff_u8);
+        assert!(ff.c == f.a - 1.0f64);
     }
 }
 
diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs
index d9872033447..4a8d155c739 100644
--- a/src/test/run-pass/structured-compare.rs
+++ b/src/test/run-pass/structured-compare.rs
@@ -22,15 +22,15 @@ impl cmp::Eq for foo {
 pub fn main() {
     let a = (1, 2, 3);
     let b = (1, 2, 3);
-    fail_unless!((a == b));
-    fail_unless!((a != (1, 2, 4)));
-    fail_unless!((a < (1, 2, 4)));
-    fail_unless!((a <= (1, 2, 4)));
-    fail_unless!(((1, 2, 4) > a));
-    fail_unless!(((1, 2, 4) >= a));
+    assert!((a == b));
+    assert!((a != (1, 2, 4)));
+    assert!((a < (1, 2, 4)));
+    assert!((a <= (1, 2, 4)));
+    assert!(((1, 2, 4) > a));
+    assert!(((1, 2, 4) >= a));
     let x = large;
     let y = small;
-    fail_unless!((x != y));
-    fail_unless!((x == large));
-    fail_unless!((x != small));
+    assert!((x != y));
+    assert!((x == large));
+    assert!((x != small));
 }
diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs
index ff114e8084a..feb7a88dc34 100644
--- a/src/test/run-pass/swap-1.rs
+++ b/src/test/run-pass/swap-1.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let mut x = 3; let mut y = 7;
-    x <-> y; fail_unless!((x == 7)); fail_unless!((y == 3));
+    x <-> y; assert!((x == 7)); assert!((y == 3));
 }
diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index 7f63e87235f..24794b03591 100644
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -13,10 +13,10 @@ fn swap<T>(v: &mut [T], i: int, j: int) { v[i] <-> v[j]; }
 pub fn main() {
     let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6];
     swap(a, 2, 4);
-    fail_unless!((a[2] == 4));
-    fail_unless!((a[4] == 2));
+    assert!((a[2] == 4));
+    assert!((a[4] == 2));
     let mut n = 42;
     n <-> a[0];
-    fail_unless!((a[0] == 42));
-    fail_unless!((n == 0));
+    assert!((a[0] == 42));
+    assert!((n == 0));
 }
diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs
index 3af58274bfb..a61feadfc94 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -13,7 +13,7 @@ extern mod std;
 fn test(actual: ~str, expected: ~str) {
     debug!(actual.clone());
     debug!(expected.clone());
-    fail_unless!((actual == expected));
+    assert!((actual == expected));
 }
 
 pub fn main() {
@@ -250,13 +250,13 @@ fn part6() {
 
 fn percent() {
     let s = fmt!("ab%%cd");
-    fail_unless!((s == ~"ab%cd"));
+    assert!((s == ~"ab%cd"));
 }
 
 fn more_floats() {
-    fail_unless!(~"3.1416"      == fmt!("%.4f", 3.14159));
-    fail_unless!(~"3"           == fmt!("%.0f", 3.14159));
-    fail_unless!(~"99"          == fmt!("%.0f", 98.5));
-    fail_unless!(~"7.0000"      == fmt!("%.4f", 6.999999999));
-    fail_unless!(~"3.141590000" == fmt!("%.9f", 3.14159));
+    assert!(~"3.1416"      == fmt!("%.4f", 3.14159));
+    assert!(~"3"           == fmt!("%.0f", 3.14159));
+    assert!(~"99"          == fmt!("%.0f", 98.5));
+    assert!(~"7.0000"      == fmt!("%.4f", 6.999999999));
+    assert!(~"3.141590000" == fmt!("%.9f", 3.14159));
 }
diff --git a/src/test/run-pass/syntax-extension-minor.rs b/src/test/run-pass/syntax-extension-minor.rs
index 419380fba22..ac0b63e98ca 100644
--- a/src/test/run-pass/syntax-extension-minor.rs
+++ b/src/test/run-pass/syntax-extension-minor.rs
@@ -11,8 +11,8 @@
 
 pub fn main() {
     let asdf_fdsa = ~"<.<";
-    fail_unless!((concat_idents!(asd, f_f, dsa) == ~"<.<"));
+    assert!((concat_idents!(asd, f_f, dsa) == ~"<.<"));
 
-    fail_unless!(stringify!(use_mention_distinction) ==
+    assert!(stringify!(use_mention_distinction) ==
                 ~"use_mention_distinction");
 }
diff --git a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment
index 4ff0fc7a9f2..d5cfb94fd0b 100644
--- a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment
+++ b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment
@@ -1,7 +1,7 @@
 /* this is for run-pass/syntax-extension-source-utils.rs */
 
 {
-    fail_unless!(file!().ends_with("includeme.fragment"));
-    fail_unless!(line!() == 5u);
+    assert!(file!().ends_with("includeme.fragment"));
+    assert!(line!() == 5u);
     fmt!("victory robot %u", line!())
 }
diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs
index 64055f5a88b..7b52f52137e 100644
--- a/src/test/run-pass/syntax-extension-source-utils.rs
+++ b/src/test/run-pass/syntax-extension-source-utils.rs
@@ -20,20 +20,20 @@ pub mod m1 {
 macro_rules! indirect_line( () => ( line!() ) )
 
 pub fn main() {
-    fail_unless!((line!() == 23));
-    //fail_unless!((col!() == 11));
-    fail_unless!((indirect_line!() == 25));
-    fail_unless!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs")));
-    fail_unless!((stringify!((2*3) + 5).to_owned() == ~"( 2 * 3 ) + 5"));
-    fail_unless!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned()
+    assert!((line!() == 23));
+    //assert!((col!() == 11));
+    assert!((indirect_line!() == 25));
+    assert!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs")));
+    assert!((stringify!((2*3) + 5).to_owned() == ~"( 2 * 3 ) + 5"));
+    assert!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned()
            == ~"victory robot 6");
 
-    fail_unless!(
+    assert!(
         include_str!("syntax-extension-source-utils-files/includeme.fragment").to_owned()
         .starts_with(~"/* this is for "));
-    fail_unless!(
+    assert!(
         include_bin!("syntax-extension-source-utils-files/includeme.fragment")
         [1] == (42 as u8)); // '*'
     // The Windows tests are wrapped in an extra module for some reason
-    fail_unless!((m1::m2::where_am_i().ends_with(~"m1::m2")));
+    assert!((m1::m2::where_am_i().ends_with(~"m1::m2")));
 }
diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs
index 23b9d5d4a3f..1798bb688bd 100644
--- a/src/test/run-pass/tag-align-dyn-u64.rs
+++ b/src/test/run-pass/tag-align-dyn-u64.rs
@@ -30,5 +30,5 @@ fn is_8_byte_aligned(&&u: a_tag<u64>) -> bool {
 
 pub fn main() {
     let x = mk_rec();
-    fail_unless!(is_8_byte_aligned(x.t));
+    assert!(is_8_byte_aligned(x.t));
 }
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index 4d7c669ba7d..80e300596b9 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -40,32 +40,32 @@ fn variant_data_is_aligned<A,B>(amnt: uint, &&u: a_tag<A,B>) -> bool {
 
 pub fn main() {
     let x = mk_rec(22u64, 23u64);
-    fail_unless!(is_aligned(8u, x.tA));
-    fail_unless!(variant_data_is_aligned(8u, x.tA));
-    fail_unless!(is_aligned(8u, x.tB));
-    fail_unless!(variant_data_is_aligned(8u, x.tB));
+    assert!(is_aligned(8u, x.tA));
+    assert!(variant_data_is_aligned(8u, x.tA));
+    assert!(is_aligned(8u, x.tB));
+    assert!(variant_data_is_aligned(8u, x.tB));
 
     let x = mk_rec(22u64, 23u32);
-    fail_unless!(is_aligned(8u, x.tA));
-    fail_unless!(variant_data_is_aligned(8u, x.tA));
-    fail_unless!(is_aligned(8u, x.tB));
-    fail_unless!(variant_data_is_aligned(4u, x.tB));
+    assert!(is_aligned(8u, x.tA));
+    assert!(variant_data_is_aligned(8u, x.tA));
+    assert!(is_aligned(8u, x.tB));
+    assert!(variant_data_is_aligned(4u, x.tB));
 
     let x = mk_rec(22u32, 23u64);
-    fail_unless!(is_aligned(8u, x.tA));
-    fail_unless!(variant_data_is_aligned(4u, x.tA));
-    fail_unless!(is_aligned(8u, x.tB));
-    fail_unless!(variant_data_is_aligned(8u, x.tB));
+    assert!(is_aligned(8u, x.tA));
+    assert!(variant_data_is_aligned(4u, x.tA));
+    assert!(is_aligned(8u, x.tB));
+    assert!(variant_data_is_aligned(8u, x.tB));
 
     let x = mk_rec(22u32, 23u32);
-    fail_unless!(is_aligned(4u, x.tA));
-    fail_unless!(variant_data_is_aligned(4u, x.tA));
-    fail_unless!(is_aligned(4u, x.tB));
-    fail_unless!(variant_data_is_aligned(4u, x.tB));
+    assert!(is_aligned(4u, x.tA));
+    assert!(variant_data_is_aligned(4u, x.tA));
+    assert!(is_aligned(4u, x.tB));
+    assert!(variant_data_is_aligned(4u, x.tB));
 
     let x = mk_rec(22f64, 23f64);
-    fail_unless!(is_aligned(8u, x.tA));
-    fail_unless!(variant_data_is_aligned(8u, x.tA));
-    fail_unless!(is_aligned(8u, x.tB));
-    fail_unless!(variant_data_is_aligned(8u, x.tB));
+    assert!(is_aligned(8u, x.tA));
+    assert!(variant_data_is_aligned(8u, x.tA));
+    assert!(is_aligned(8u, x.tB));
+    assert!(variant_data_is_aligned(8u, x.tB));
 }
diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs
index cb2f9522df0..052bacad7ce 100644
--- a/src/test/run-pass/tag-align-shape.rs
+++ b/src/test/run-pass/tag-align-shape.rs
@@ -25,5 +25,5 @@ pub fn main() {
     let x = {c8: 22u8, t: a_tag(44u64)};
     let y = fmt!("%?", x);
     debug!("y = %s", y);
-    fail_unless!(y == "(22, a_tag(44))");
+    assert!(y == "(22, a_tag(44))");
 }
diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs
index a4cbffbc120..21c51220be8 100644
--- a/src/test/run-pass/tag-align-u64.rs
+++ b/src/test/run-pass/tag-align-u64.rs
@@ -30,5 +30,5 @@ fn is_8_byte_aligned(&&u: a_tag) -> bool {
 
 pub fn main() {
     let x = mk_rec();
-    fail_unless!(is_8_byte_aligned(x.t));
+    assert!(is_8_byte_aligned(x.t));
 }
diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs
index d8f469d2ff5..50ab17fdeea 100644
--- a/src/test/run-pass/tag-disr-val-shape.rs
+++ b/src/test/run-pass/tag-disr-val-shape.rs
@@ -19,8 +19,8 @@ enum color {
 pub fn main() {
     let act = fmt!("%?", red);
     io::println(act);
-    fail_unless!(~"red" == act);
-    fail_unless!(~"green" == fmt!("%?", green));
-    fail_unless!(~"white" == fmt!("%?", white));
+    assert!(~"red" == act);
+    assert!(~"green" == fmt!("%?", green));
+    assert!(~"white" == fmt!("%?", white));
 }
 
diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs
index 63300342bd3..34ce56250fc 100644
--- a/src/test/run-pass/tag-variant-disr-val.rs
+++ b/src/test/run-pass/tag-variant-disr-val.rs
@@ -38,11 +38,11 @@ pub fn main() {
 }
 
 fn test_color(color: color, val: int, name: ~str) {
-    //fail_unless!(unsafe::reinterpret_cast(color) == val);
-    fail_unless!(color as int == val);
-    fail_unless!(color as float == val as float);
-    fail_unless!(get_color_alt(color) == name);
-    fail_unless!(get_color_if(color) == name);
+    //assert!(unsafe::reinterpret_cast(color) == val);
+    assert!(color as int == val);
+    assert!(color as float == val as float);
+    assert!(get_color_alt(color) == name);
+    assert!(get_color_if(color) == name);
 }
 
 fn get_color_alt(color: color) -> ~str {
diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs
index 4e126379410..626e0938aed 100644
--- a/src/test/run-pass/tag.rs
+++ b/src/test/run-pass/tag.rs
@@ -34,6 +34,6 @@ impl cmp::Eq for colour {
     fn ne(&self, other: &colour) -> bool { !(*self).eq(other) }
 }
 
-fn f() { let x = red(1, 2); let y = green; fail_unless!((x != y)); }
+fn f() { let x = red(1, 2); let y = green; assert!((x != y)); }
 
 pub fn main() { f(); }
diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs
index 0f3131e3967..b32f1f82aa7 100644
--- a/src/test/run-pass/tail-cps.rs
+++ b/src/test/run-pass/tail-cps.rs
@@ -12,7 +12,7 @@
 
 
 // -*- rust -*-
-fn checktrue(rs: bool) -> bool { fail_unless!((rs)); return true; }
+fn checktrue(rs: bool) -> bool { assert!((rs)); return true; }
 
 pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
 
diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs
index a7af09101f6..847e848f0d8 100644
--- a/src/test/run-pass/tail-direct.rs
+++ b/src/test/run-pass/tail-direct.rs
@@ -12,7 +12,7 @@
 
 
 // -*- rust -*-
-pub fn main() { fail_unless!((even(42))); fail_unless!((odd(45))); }
+pub fn main() { assert!((even(42))); assert!((odd(45))); }
 
 fn even(n: int) -> bool { if n == 0 { return true; } else { return odd(n - 1); } }
 
diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs
index 6a93df01395..ffcba42ff51 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -36,5 +36,5 @@ fn test05() {
     error!(value);
     value = po.recv();
     error!(value);
-    fail_unless!((value == 30));
+    assert!((value == 30));
 }
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 3fd55a7310e..fa3ead8dfe6 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -19,10 +19,10 @@ fn start(c: &comm::Chan<comm::Chan<~str>>) {
     let mut a;
     let mut b;
     a = p.recv();
-    fail_unless!(a == ~"A");
+    assert!(a == ~"A");
     error!(a);
     b = p.recv();
-    fail_unless!(b == ~"B");
+    assert!(b == ~"B");
     error!(b);
 }
 
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 89dad2d462c..237c721129f 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -19,9 +19,9 @@ fn test_rec() {
     ch.send(r0);
     let mut r1: R;
     r1 = po.recv();
-    fail_unless!((r1.val0 == 0));
-    fail_unless!((r1.val1 == 1u8));
-    fail_unless!((r1.val2 == '2'));
+    assert!((r1.val0 == 0));
+    assert!((r1.val1 == 1u8));
+    assert!((r1.val2 == '2'));
 }
 
 fn test_vec() {
@@ -29,9 +29,9 @@ fn test_vec() {
     let v0: ~[int] = ~[0, 1, 2];
     ch.send(v0);
     let v1 = po.recv();
-    fail_unless!((v1[0] == 0));
-    fail_unless!((v1[1] == 1));
-    fail_unless!((v1[2] == 2));
+    assert!((v1[0] == 0));
+    assert!((v1[1] == 1));
+    assert!((v1[2] == 2));
 }
 
 fn test_str() {
@@ -39,10 +39,10 @@ fn test_str() {
     let s0 = ~"test";
     ch.send(s0);
     let s1 = po.recv();
-    fail_unless!((s1[0] == 't' as u8));
-    fail_unless!((s1[1] == 'e' as u8));
-    fail_unless!((s1[2] == 's' as u8));
-    fail_unless!((s1[3] == 't' as u8));
+    assert!((s1[0] == 't' as u8));
+    assert!((s1[1] == 'e' as u8));
+    assert!((s1[2] == 's' as u8));
+    assert!((s1[3] == 't' as u8));
 }
 
 enum t {
@@ -85,11 +85,11 @@ fn test_tag() {
     ch.send(tag3(10, 11u8, 'A'));
     let mut t1: t;
     t1 = po.recv();
-    fail_unless!((t1 == tag1));
+    assert!((t1 == tag1));
     t1 = po.recv();
-    fail_unless!((t1 == tag2(10)));
+    assert!((t1 == tag2(10)));
     t1 = po.recv();
-    fail_unless!((t1 == tag3(10, 11u8, 'A')));
+    assert!((t1 == tag3(10, 11u8, 'A')));
 }
 
 fn test_chan() {
@@ -102,7 +102,7 @@ fn test_chan() {
     ch1.send(10);
     let mut i: int;
     i = po0.recv();
-    fail_unless!((i == 10));
+    assert!((i == 10));
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 8c8f38f5e12..9d5cb758044 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -67,5 +67,5 @@ fn test00() {
     error!(sum);
     // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
     //       number_of_messages));
-    fail_unless!((sum == 480));
+    assert!((sum == 480));
 }
diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs
index 11191ba9658..3b606642571 100644
--- a/src/test/run-pass/task-comm-4.rs
+++ b/src/test/run-pass/task-comm-4.rs
@@ -46,5 +46,5 @@ fn test00() {
     r = p.recv();
     sum += r;
     debug!(r);
-    fail_unless!((sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8));
+    assert!((sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8));
 }
diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs
index 50c032c0754..7522a092872 100644
--- a/src/test/run-pass/task-comm-5.rs
+++ b/src/test/run-pass/task-comm-5.rs
@@ -21,5 +21,5 @@ fn test00() {
     while i < number_of_messages { c.send(i + 0); i += 1; }
     i = 0;
     while i < number_of_messages { sum += p.recv(); i += 1; }
-    fail_unless!((sum == number_of_messages * (number_of_messages - 1) / 2));
+    assert!((sum == number_of_messages * (number_of_messages - 1) / 2));
 }
diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs
index 69c58723289..af004e0f34d 100644
--- a/src/test/run-pass/task-comm-6.rs
+++ b/src/test/run-pass/task-comm-6.rs
@@ -41,7 +41,7 @@ fn test00() {
         sum += r;
         i += 1;
     }
-    fail_unless!((sum == 1998000));
+    assert!((sum == 1998000));
     // assert (sum == 4 * ((number_of_messages *
     //                   (number_of_messages - 1)) / 2));
 
diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs
index 88f41655c52..980ded6aecc 100644
--- a/src/test/run-pass/task-comm-7.rs
+++ b/src/test/run-pass/task-comm-7.rs
@@ -56,5 +56,5 @@ fn test00() {
         i += 1;
     }
 
-    fail_unless!((sum == number_of_messages * 4 * (number_of_messages * 4 - 1) / 2));
+    assert!((sum == number_of_messages * 4 * (number_of_messages * 4 - 1) / 2));
 }
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index 767203a1f63..1661792c6ac 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -41,5 +41,5 @@ fn test00() {
 
     result.unwrap().recv();
 
-    fail_unless!((sum == number_of_messages * (number_of_messages - 1) / 2));
+    assert!((sum == number_of_messages * (number_of_messages - 1) / 2));
 }
diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs
index 4c63e24d5bc..bae3cbbf587 100644
--- a/src/test/run-pass/task-comm-chan-nil.rs
+++ b/src/test/run-pass/task-comm-chan-nil.rs
@@ -19,5 +19,5 @@ pub fn main() {
     let (po, ch) = comm::stream();
     ch.send(());
     let n: () = po.recv();
-    fail_unless!((n == ()));
+    assert!((n == ()));
 }
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index 7456c6efbd4..b3f5bad56ef 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -22,5 +22,5 @@ pub fn main() {
     });
 
     let x_in_child = p.recv();
-    fail_unless!(x_in_parent == x_in_child);
+    assert!(x_in_parent == x_in_child);
 }
diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs
index ae99aee05d7..304c9e5ccb9 100644
--- a/src/test/run-pass/test-ignore-cfg.rs
+++ b/src/test/run-pass/test-ignore-cfg.rs
@@ -28,11 +28,11 @@ fn checktests() {
     // Pull the tests out of the secreturn test module
     let tests = __test::tests;
 
-    fail_unless!(vec::any(
+    assert!(vec::any(
         tests,
         |t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore));
 
-    fail_unless!(vec::any(
+    assert!(vec::any(
         tests,
         |t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore));
 }
diff --git a/src/test/run-pass/trait-bounds.rs b/src/test/run-pass/trait-bounds.rs
index 6dcd2a41e07..3bdd9aa5088 100644
--- a/src/test/run-pass/trait-bounds.rs
+++ b/src/test/run-pass/trait-bounds.rs
@@ -31,5 +31,5 @@ pub fn main() {
     let factory = ();
     let connection = factory.create();
     let result = connection.read();
-    fail_unless!(result == 43);
+    assert!(result == 43);
 }
diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs
index 4cee3c636c5..303eaa13af8 100644
--- a/src/test/run-pass/trait-cast.rs
+++ b/src/test/run-pass/trait-cast.rs
@@ -55,7 +55,7 @@ pub fn main() {
                              right: Some(t1),
                              val: 2 as to_str });
     let expected = ~"[2, some([1, none, none]), some([1, none, none])]";
-    fail_unless!(t2.to_str() == expected);
-    fail_unless!(foo(t2 as to_str) == expected);
+    assert!(t2.to_str() == expected);
+    assert!(foo(t2 as to_str) == expected);
     t1.left = Some(t2); // create cycle
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs
index 5670ae39acc..a489f2b405f 100644
--- a/src/test/run-pass/trait-default-method-bound-subst.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst.rs
@@ -21,5 +21,5 @@ fn f<T, U, V: A<T>>(i: V, j: T, k: U) -> (T, U) {
 }
 
 pub fn main () {
-    fail_unless!(f(0, 1, 2) == (1, 2));
+    assert!(f(0, 1, 2) == (1, 2));
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs
index ce72c7e9a44..4203f73236e 100644
--- a/src/test/run-pass/trait-default-method-bound-subst2.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst2.rs
@@ -21,5 +21,5 @@ fn f<T, V: A<T>>(i: V, j: T) -> T {
 }
 
 pub fn main () {
-    fail_unless!(f(0, 2) == 2);
+    assert!(f(0, 2) == 2);
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs
index 3c1e6a59d03..11830e7e7d2 100644
--- a/src/test/run-pass/trait-default-method-bound-subst3.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst3.rs
@@ -21,6 +21,6 @@ fn f<T, V: A>(i: V, j: T, k: T) -> (T, T) {
 }
 
 pub fn main () {
-    fail_unless!(f(0, 1, 2) == (1, 2));
-    fail_unless!(f(0, 1u8, 2u8) == (1u8, 2u8));
+    assert!(f(0, 1, 2) == (1, 2));
+    assert!(f(0, 1u8, 2u8) == (1u8, 2u8));
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs
index 9ac66bfb737..285d31152e2 100644
--- a/src/test/run-pass/trait-default-method-bound-subst4.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst4.rs
@@ -21,6 +21,6 @@ fn f<T, V: A<T>>(i: V, j: uint) -> uint {
 }
 
 pub fn main () {
-    fail_unless!(f::<float, int>(0, 2u) == 2u);
-    fail_unless!(f::<uint, int>(0, 2u) == 2u);
+    assert!(f::<float, int>(0, 2u) == 2u);
+    assert!(f::<uint, int>(0, 2u) == 2u);
 }
diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs
index 627bc96e6ae..756af0d63fd 100644
--- a/src/test/run-pass/trait-default-method-bound.rs
+++ b/src/test/run-pass/trait-default-method-bound.rs
@@ -17,7 +17,7 @@ trait A {
 impl A for int { }
 
 fn f<T:A>(i: T) {
-    fail_unless!(i.g() == 10);
+    assert!(i.g() == 10);
 }
 
 pub fn main () {
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index c11ece62813..eacd51266ad 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -42,8 +42,8 @@ fn bar<U:to_str,T:map<U>>(x: T) -> ~[~str] {
 }
 
 pub fn main() {
-    fail_unless!(foo(~[1]) == ~[~"hi"]);
-    fail_unless!(bar::<int, ~[int]>(~[4, 5]) == ~[~"4", ~"5"]);
-    fail_unless!(bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]);
-    fail_unless!(bar::<(), ~[()]>(~[()]) == ~[~"()"]);
+    assert!(foo(~[1]) == ~[~"hi"]);
+    assert!(bar::<int, ~[int]>(~[4, 5]) == ~[~"4", ~"5"]);
+    assert!(bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]);
+    assert!(bar::<(), ~[()]>(~[()]) == ~[~"()"]);
 }
diff --git a/src/test/run-pass/trait-inheritance-auto-xc-2.rs b/src/test/run-pass/trait-inheritance-auto-xc-2.rs
index 15611d19979..446dd4b3d8e 100644
--- a/src/test/run-pass/trait-inheritance-auto-xc-2.rs
+++ b/src/test/run-pass/trait-inheritance-auto-xc-2.rs
@@ -21,9 +21,9 @@ pub trait Quux: Foo + Bar + Baz { }
 impl<T:Foo + Bar + Baz> Quux for T { }
 
 fn f<T:Quux>(a: &T) {
-    fail_unless!(a.f() == 10);
-    fail_unless!(a.g() == 20);
-    fail_unless!(a.h() == 30);
+    assert!(a.f() == 10);
+    assert!(a.g() == 20);
+    assert!(a.h() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-auto-xc.rs b/src/test/run-pass/trait-inheritance-auto-xc.rs
index ccb55f1d164..03287809a9b 100644
--- a/src/test/run-pass/trait-inheritance-auto-xc.rs
+++ b/src/test/run-pass/trait-inheritance-auto-xc.rs
@@ -22,9 +22,9 @@ impl Bar for A { fn g(&self) -> int { 20 } }
 impl Baz for A { fn h(&self) -> int { 30 } }
 
 fn f<T:Quux>(a: &T) {
-    fail_unless!(a.f() == 10);
-    fail_unless!(a.g() == 20);
-    fail_unless!(a.h() == 30);
+    assert!(a.f() == 10);
+    assert!(a.g() == 20);
+    assert!(a.h() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-auto.rs b/src/test/run-pass/trait-inheritance-auto.rs
index 51a3168f6e8..b74064591d3 100644
--- a/src/test/run-pass/trait-inheritance-auto.rs
+++ b/src/test/run-pass/trait-inheritance-auto.rs
@@ -25,9 +25,9 @@ impl Bar for A { fn g(&self) -> int { 20 } }
 impl Baz for A { fn h(&self) -> int { 30 } }
 
 fn f<T:Quux>(a: &T) {
-    fail_unless!(a.f() == 10);
-    fail_unless!(a.g() == 20);
-    fail_unless!(a.h() == 30);
+    assert!(a.f() == 10);
+    assert!(a.g() == 20);
+    assert!(a.h() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
index dcc1deed846..26b96f93326 100644
--- a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
+++ b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs
@@ -23,6 +23,6 @@ fn gg<T:Bar>(a: &T) -> int {
 
 pub fn main() {
     let a = &A { x: 3 };
-    fail_unless!(gg(a) == 10);
+    assert!(gg(a) == 10);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
index ad23cab016e..5e612bbca64 100644
--- a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
+++ b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs
@@ -26,6 +26,6 @@ fn gg<T:Baz>(a: &T) -> int {
 
 pub fn main() {
     let a = &A { x: 3 };
-    fail_unless!(gg(a) == 10);
+    assert!(gg(a) == 10);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
index 39565382118..6efd854e01b 100644
--- a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
+++ b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs
@@ -35,7 +35,7 @@ pub fn main() {
     let a = &A { x: 3 };
     let afoo = a as &Foo;
     let abar = a as &Bar;
-    fail_unless!(afoo.f() == 10);
-    fail_unless!(abar.g() == 20);
+    assert!(afoo.f() == 10);
+    assert!(abar.g() == 20);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-cast.rs b/src/test/run-pass/trait-inheritance-cast.rs
index d066f49c732..02382797797 100644
--- a/src/test/run-pass/trait-inheritance-cast.rs
+++ b/src/test/run-pass/trait-inheritance-cast.rs
@@ -36,8 +36,8 @@ pub fn main() {
     let a = &A { x: 3 };
     let afoo = a as &Foo;
     let abar = a as &Bar;
-    fail_unless!(afoo.f() == 10);
-    fail_unless!(abar.g() == 20);
-    fail_unless!(abar.f() == 10);
+    assert!(afoo.f() == 10);
+    assert!(abar.g() == 20);
+    assert!(abar.f() == 10);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
index a5f163a9cfa..3c1bf2035aa 100644
--- a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
+++ b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs
@@ -25,6 +25,6 @@ impl Bar for aux::A {
 
 pub fn main() {
     let a = &aux::A { x: 3 };
-    fail_unless!(a.g() == 10);
+    assert!(a.g() == 10);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call.rs b/src/test/run-pass/trait-inheritance-cross-trait-call.rs
index 2cde60ecf58..997f13d0e5e 100644
--- a/src/test/run-pass/trait-inheritance-cross-trait-call.rs
+++ b/src/test/run-pass/trait-inheritance-cross-trait-call.rs
@@ -22,6 +22,6 @@ impl Bar for A {
 
 pub fn main() {
     let a = &A { x: 3 };
-    fail_unless!(a.g() == 10);
+    assert!(a.g() == 10);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-diamond.rs b/src/test/run-pass/trait-inheritance-diamond.rs
index 2bebf1c9932..abfbec6d358 100644
--- a/src/test/run-pass/trait-inheritance-diamond.rs
+++ b/src/test/run-pass/trait-inheritance-diamond.rs
@@ -23,10 +23,10 @@ impl C for S { fn c(&self) -> int { 30 } }
 impl D for S { fn d(&self) -> int { 40 } }
 
 fn f<T:D>(x: &T) {
-    fail_unless!(x.a() == 10);
-    fail_unless!(x.b() == 20);
-    fail_unless!(x.c() == 30);
-    fail_unless!(x.d() == 40);
+    assert!(x.a() == 10);
+    assert!(x.b() == 20);
+    assert!(x.c() == 30);
+    assert!(x.d() == 40);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
index 5c84e2af4b7..5bd8f7f25ea 100644
--- a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
+++ b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs
@@ -20,9 +20,9 @@ impl C for S { fn c(&self) -> int { 30 } }
 
 // Both B and C inherit from A
 fn f<T:B + C>(x: &T) {
-    fail_unless!(x.a() == 10);
-    fail_unless!(x.b() == 20);
-    fail_unless!(x.c() == 30);
+    assert!(x.a() == 10);
+    assert!(x.b() == 20);
+    assert!(x.c() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-multiple-params.rs b/src/test/run-pass/trait-inheritance-multiple-params.rs
index 57a5f2bc0e1..e01860ba503 100644
--- a/src/test/run-pass/trait-inheritance-multiple-params.rs
+++ b/src/test/run-pass/trait-inheritance-multiple-params.rs
@@ -20,11 +20,11 @@ impl C for S { fn c(&self) -> int { 30 } }
 
 // Multiple type params, multiple levels of inheritance
 fn f<X:A,Y:B,Z:C>(x: &X, y: &Y, z: &Z) {
-    fail_unless!(x.a() == 10);
-    fail_unless!(y.a() == 10);
-    fail_unless!(y.b() == 20);
-    fail_unless!(z.a() == 10);
-    fail_unless!(z.c() == 30);
+    assert!(x.a() == 10);
+    assert!(y.a() == 10);
+    assert!(y.b() == 20);
+    assert!(z.a() == 10);
+    assert!(z.c() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs
index 283ed8ae2c1..711571e8c64 100644
--- a/src/test/run-pass/trait-inheritance-overloading-simple.rs
+++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs
@@ -29,7 +29,7 @@ fn mi(v: int) -> MyInt { MyInt { val: v } }
 
 pub fn main() {
     let (x, y, z) = (mi(3), mi(5), mi(3));
-    fail_unless!(x != y);
-    fail_unless!(x == z);
+    assert!(x != y);
+    assert!(x == z);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
index d4d16f2b43e..9f745db7638 100644
--- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
+++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
@@ -23,8 +23,8 @@ fn mi(v: int) -> MyInt { MyInt { val: v } }
 pub fn main() {
     let (x, y) = (mi(3), mi(5));
     let (a, b, c) = f(x, y);
-    fail_unless!(a == mi(8));
-    fail_unless!(b == mi(-2));
-    fail_unless!(c == mi(15));
+    assert!(a == mi(8));
+    assert!(b == mi(-2));
+    assert!(c == mi(15));
 }
 
diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs
index d4f8d50b92b..5b68aff269e 100644
--- a/src/test/run-pass/trait-inheritance-overloading.rs
+++ b/src/test/run-pass/trait-inheritance-overloading.rs
@@ -42,8 +42,8 @@ fn mi(v: int) -> MyInt { MyInt { val: v } }
 pub fn main() {
     let (x, y) = (mi(3), mi(5));
     let (a, b, c) = f(x, y);
-    fail_unless!(a == mi(8));
-    fail_unless!(b == mi(-2));
-    fail_unless!(c == mi(15));
+    assert!(a == mi(8));
+    assert!(b == mi(-2));
+    assert!(c == mi(15));
 }
 
diff --git a/src/test/run-pass/trait-inheritance-simple.rs b/src/test/run-pass/trait-inheritance-simple.rs
index 9ca3ccaa22c..779dfb65944 100644
--- a/src/test/run-pass/trait-inheritance-simple.rs
+++ b/src/test/run-pass/trait-inheritance-simple.rs
@@ -26,7 +26,7 @@ fn gg<T:Bar>(a: &T) -> int {
 
 pub fn main() {
     let a = &A { x: 3 };
-    fail_unless!(ff(a) == 10);
-    fail_unless!(gg(a) == 20);
+    assert!(ff(a) == 10);
+    assert!(gg(a) == 20);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs
index f3adea18ecd..3b87387d4d6 100644
--- a/src/test/run-pass/trait-inheritance-static.rs
+++ b/src/test/run-pass/trait-inheritance-static.rs
@@ -30,5 +30,5 @@ fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) }
 
 pub fn main() {
     let v: S = greater_than_one();
-    fail_unless!(v.v == 1);
+    assert!(v.v == 1);
 }
diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs
index 45369d4ec19..2718949db07 100644
--- a/src/test/run-pass/trait-inheritance-static2.rs
+++ b/src/test/run-pass/trait-inheritance-static2.rs
@@ -34,5 +34,5 @@ fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) }
 
 pub fn main() {
     let v: S = greater_than_one();
-    fail_unless!(v.v == 1);
+    assert!(v.v == 1);
 }
diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs
index 9d0e5fa1f13..22efdabec83 100644
--- a/src/test/run-pass/trait-inheritance-subst.rs
+++ b/src/test/run-pass/trait-inheritance-subst.rs
@@ -31,6 +31,6 @@ fn mi(v: int) -> MyInt { MyInt { val: v } }
 pub fn main() {
     let (x, y) = (mi(3), mi(5));
     let z = f(x, y);
-    fail_unless!(z.val == 8)
+    assert!(z.val == 8)
 }
 
diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs
index 20b7d529fae..4f3b808f8eb 100644
--- a/src/test/run-pass/trait-inheritance-subst2.rs
+++ b/src/test/run-pass/trait-inheritance-subst2.rs
@@ -41,6 +41,6 @@ fn mi(v: int) -> MyInt { MyInt { val: v } }
 pub fn main() {
     let (x, y) = (mi(3), mi(5));
     let z = f(x, y);
-    fail_unless!(z.val == 13);
+    assert!(z.val == 13);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs
index c70c2ecf976..81f119612d9 100644
--- a/src/test/run-pass/trait-inheritance-visibility.rs
+++ b/src/test/run-pass/trait-inheritance-visibility.rs
@@ -20,7 +20,7 @@ impl<T:traits::Foo> Quux for T { }
 // Foo is not in scope but because Quux is we can still access
 // Foo's methods on a Quux bound typaram
 fn f<T:Quux>(x: &T) {
-    fail_unless!(x.f() == 10);
+    assert!(x.f() == 10);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs
index d18452f11fa..5d6913d4146 100644
--- a/src/test/run-pass/trait-inheritance2.rs
+++ b/src/test/run-pass/trait-inheritance2.rs
@@ -22,9 +22,9 @@ impl Baz for A { fn h(&self) -> int { 30 } }
 impl Quux for A;
 
 fn f<T:Quux + Foo + Bar + Baz>(a: &T) {
-    fail_unless!(a.f() == 10);
-    fail_unless!(a.g() == 20);
-    fail_unless!(a.h() == 30);
+    assert!(a.f() == 10);
+    assert!(a.g() == 20);
+    assert!(a.h() == 30);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-region-pointer-simple.rs b/src/test/run-pass/trait-region-pointer-simple.rs
index 1ce2cddc29b..285b0e65daf 100644
--- a/src/test/run-pass/trait-region-pointer-simple.rs
+++ b/src/test/run-pass/trait-region-pointer-simple.rs
@@ -26,6 +26,6 @@ impl Foo for A {
 pub fn main() {
     let a = A { x: 3 };
     let b = (&a) as &Foo;
-    fail_unless!(b.f() == 3);
+    assert!(b.f() == 3);
 }
 
diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs
index 40850186e28..ca22b5942db 100644
--- a/src/test/run-pass/trait-to-str.rs
+++ b/src/test/run-pass/trait-to-str.rs
@@ -31,16 +31,16 @@ impl<T:to_str> to_str for ~[T] {
 }
 
 pub fn main() {
-    fail_unless!(1.to_str() == ~"1");
-    fail_unless!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]");
+    assert!(1.to_str() == ~"1");
+    assert!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]");
 
     fn indirect<T:to_str>(x: T) -> ~str {
         x.to_str() + ~"!"
     }
-    fail_unless!(indirect(~[10, 20]) == ~"[10, 20]!");
+    assert!(indirect(~[10, 20]) == ~"[10, 20]!");
 
     fn indirect2<T:to_str>(x: T) -> ~str {
         indirect(x)
     }
-    fail_unless!(indirect2(~[1]) == ~"[1]!");
+    assert!(indirect2(~[1]) == ~"[1]!");
 }
diff --git a/src/test/run-pass/traits-default-method-macro.rs b/src/test/run-pass/traits-default-method-macro.rs
index 21e05aba27b..7f106f71f8e 100644
--- a/src/test/run-pass/traits-default-method-macro.rs
+++ b/src/test/run-pass/traits-default-method-macro.rs
@@ -25,5 +25,5 @@ impl Foo for Baz {
 
 pub fn main() {
     let q = Quux;
-    fail_unless!(q.bar() == ~"test");
+    assert!(q.bar() == ~"test");
 }
diff --git a/src/test/run-pass/traits-default-method-self.rs b/src/test/run-pass/traits-default-method-self.rs
index 3531b12d1f9..a377c86068c 100644
--- a/src/test/run-pass/traits-default-method-self.rs
+++ b/src/test/run-pass/traits-default-method-self.rs
@@ -25,5 +25,5 @@ impl Cat for int {
 }
 
 pub fn main() {
-    fail_unless!(5.meow());
+    assert!(5.meow());
 }
diff --git a/src/test/run-pass/traits-default-method-trivial.rs b/src/test/run-pass/traits-default-method-trivial.rs
index 8edb83ce60e..998d8f8946f 100644
--- a/src/test/run-pass/traits-default-method-trivial.rs
+++ b/src/test/run-pass/traits-default-method-trivial.rs
@@ -26,5 +26,5 @@ impl Cat for int {
 }
 
 pub fn main() {
-    fail_unless!(5.meow());
+    assert!(5.meow());
 }
diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs
index 6bcaca9a08c..c1a34a326a6 100644
--- a/src/test/run-pass/tup.rs
+++ b/src/test/run-pass/tup.rs
@@ -13,15 +13,15 @@ type point = (int, int);
 
 fn f(p: point, x: int, y: int) {
     let (a, b) = p;
-    fail_unless!((a == x));
-    fail_unless!((b == y));
+    assert!((a == x));
+    assert!((b == y));
 }
 
 pub fn main() {
     let p: point = (10, 20);
     let (a, b) = p;
-    fail_unless!((a == 10));
-    fail_unless!((b == 20));
+    assert!((a == 10));
+    assert!((b == 20));
     let p2: point = p;
     f(p, 10, 20);
     f(p2, 10, 20);
diff --git a/src/test/run-pass/tuple-struct-destructuring.rs b/src/test/run-pass/tuple-struct-destructuring.rs
index 82fa411b231..7e6b9570def 100644
--- a/src/test/run-pass/tuple-struct-destructuring.rs
+++ b/src/test/run-pass/tuple-struct-destructuring.rs
@@ -14,7 +14,7 @@ pub fn main() {
     let x = Foo(1, 2);
     let Foo(y, z) = x;
     io::println(fmt!("%d %d", y, z));
-    fail_unless!(y == 1);
-    fail_unless!(z == 2);
+    assert!(y == 1);
+    assert!(z == 2);
 }
 
diff --git a/src/test/run-pass/tuple-struct-matching.rs b/src/test/run-pass/tuple-struct-matching.rs
index cd867adebc1..405616f9b1f 100644
--- a/src/test/run-pass/tuple-struct-matching.rs
+++ b/src/test/run-pass/tuple-struct-matching.rs
@@ -14,8 +14,8 @@ pub fn main() {
     let x = Foo(1, 2);
     match x {
         Foo(a, b) => {
-            fail_unless!(a == 1);
-            fail_unless!(b == 2);
+            assert!(a == 1);
+            assert!(b == 2);
             io::println(fmt!("%d %d", a, b));
         }
     }
diff --git a/src/test/run-pass/type-namespace.rs b/src/test/run-pass/type-namespace.rs
index 2fb8f34120c..e9b0324456a 100644
--- a/src/test/run-pass/type-namespace.rs
+++ b/src/test/run-pass/type-namespace.rs
@@ -12,4 +12,4 @@ struct A { a: int }
 
 fn a(a: A) -> int { return a.a; }
 
-pub fn main() { let x: A = A {a: 1}; fail_unless!((a(x) == 1)); }
+pub fn main() { let x: A = A {a: 1}; assert!((a(x) == 1)); }
diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs
index 86c10e0a597..bc2ca20d642 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -13,19 +13,19 @@ use sys::rustrt::size_of;
 extern mod std;
 
 pub fn main() {
-    fail_unless!((size_of::<u8>() == 1 as uint));
-    fail_unless!((size_of::<u32>() == 4 as uint));
-    fail_unless!((size_of::<char>() == 4 as uint));
-    fail_unless!((size_of::<i8>() == 1 as uint));
-    fail_unless!((size_of::<i32>() == 4 as uint));
-    fail_unless!((size_of::<{a: u8, b: i8}>() == 2 as uint));
-    fail_unless!((size_of::<{a: u8, b: i8, c: u8}>() == 3 as uint));
+    assert!((size_of::<u8>() == 1 as uint));
+    assert!((size_of::<u32>() == 4 as uint));
+    assert!((size_of::<char>() == 4 as uint));
+    assert!((size_of::<i8>() == 1 as uint));
+    assert!((size_of::<i32>() == 4 as uint));
+    assert!((size_of::<{a: u8, b: i8}>() == 2 as uint));
+    assert!((size_of::<{a: u8, b: i8, c: u8}>() == 3 as uint));
     // Alignment causes padding before the char and the u32.
 
-    fail_unless!(size_of::<{a: u8, b: i8, c: {u: char, v: u8}, d: u32}>() ==
+    assert!(size_of::<{a: u8, b: i8, c: {u: char, v: u8}, d: u32}>() ==
                 16 as uint);
-    fail_unless!((size_of::<int>() == size_of::<uint>()));
-    fail_unless!((size_of::<{a: int, b: ()}>() == size_of::<int>()));
-    fail_unless!((size_of::<{a: int, b: (), c: ()}>() == size_of::<int>()));
-    fail_unless!((size_of::<int>() == size_of::<{x: int}>()));
+    assert!((size_of::<int>() == size_of::<uint>()));
+    assert!((size_of::<{a: int, b: ()}>() == size_of::<int>()));
+    assert!((size_of::<{a: int, b: (), c: ()}>() == size_of::<int>()));
+    assert!((size_of::<int>() == size_of::<{x: int}>()));
 }
diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs
index 7303f5ecbdf..9c5f8c3218a 100644
--- a/src/test/run-pass/typeclasses-eq-example-static.rs
+++ b/src/test/run-pass/typeclasses-eq-example-static.rs
@@ -47,18 +47,18 @@ impl Equal for ColorTree {
 }
 
 pub fn main() {
-    fail_unless!(Equal::isEq(cyan, cyan));
-    fail_unless!(Equal::isEq(magenta, magenta));
-    fail_unless!(!Equal::isEq(cyan, yellow));
-    fail_unless!(!Equal::isEq(magenta, cyan));
+    assert!(Equal::isEq(cyan, cyan));
+    assert!(Equal::isEq(magenta, magenta));
+    assert!(!Equal::isEq(cyan, yellow));
+    assert!(!Equal::isEq(magenta, cyan));
 
-    fail_unless!(Equal::isEq(leaf(cyan), leaf(cyan)));
-    fail_unless!(!Equal::isEq(leaf(cyan), leaf(yellow)));
+    assert!(Equal::isEq(leaf(cyan), leaf(cyan)));
+    assert!(!Equal::isEq(leaf(cyan), leaf(yellow)));
 
-    fail_unless!(Equal::isEq(branch(@leaf(magenta), @leaf(cyan)),
+    assert!(Equal::isEq(branch(@leaf(magenta), @leaf(cyan)),
                 branch(@leaf(magenta), @leaf(cyan))));
 
-    fail_unless!(!Equal::isEq(branch(@leaf(magenta), @leaf(cyan)),
+    assert!(!Equal::isEq(branch(@leaf(magenta), @leaf(cyan)),
                  branch(@leaf(magenta), @leaf(magenta))));
 
     error!("Assertions all succeeded!");
diff --git a/src/test/run-pass/typeclasses-eq-example.rs b/src/test/run-pass/typeclasses-eq-example.rs
index a18965e9abc..51c19cef50a 100644
--- a/src/test/run-pass/typeclasses-eq-example.rs
+++ b/src/test/run-pass/typeclasses-eq-example.rs
@@ -46,18 +46,18 @@ impl Equal for ColorTree {
 }
 
 pub fn main() {
-    fail_unless!(cyan.isEq(cyan));
-    fail_unless!(magenta.isEq(magenta));
-    fail_unless!(!cyan.isEq(yellow));
-    fail_unless!(!magenta.isEq(cyan));
+    assert!(cyan.isEq(cyan));
+    assert!(magenta.isEq(magenta));
+    assert!(!cyan.isEq(yellow));
+    assert!(!magenta.isEq(cyan));
 
-    fail_unless!(leaf(cyan).isEq(leaf(cyan)));
-    fail_unless!(!leaf(cyan).isEq(leaf(yellow)));
+    assert!(leaf(cyan).isEq(leaf(cyan)));
+    assert!(!leaf(cyan).isEq(leaf(yellow)));
 
-    fail_unless!(branch(@leaf(magenta), @leaf(cyan))
+    assert!(branch(@leaf(magenta), @leaf(cyan))
         .isEq(branch(@leaf(magenta), @leaf(cyan))));
 
-    fail_unless!(!branch(@leaf(magenta), @leaf(cyan))
+    assert!(!branch(@leaf(magenta), @leaf(cyan))
         .isEq(branch(@leaf(magenta), @leaf(magenta))));
 
     error!("Assertions all succeeded!");
diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs
index 9b8e84da6e0..b4ca326fb57 100644
--- a/src/test/run-pass/typestate-multi-decl.rs
+++ b/src/test/run-pass/typestate-multi-decl.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let x = 10, y = 20; let z = x + y; fail_unless!((z == 30)); }
+pub fn main() { let x = 10, y = 20; let z = x + y; assert!((z == 30)); }
diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs
index 6f05ee5669d..2b68e89ed26 100644
--- a/src/test/run-pass/u32-decr.rs
+++ b/src/test/run-pass/u32-decr.rs
@@ -15,5 +15,5 @@
 pub fn main() {
     let mut word: u32 = 200000u32;
     word = word - 1u32;
-    fail_unless!((word == 199999u32));
+    assert!((word == 199999u32));
 }
diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs
index 83e8fb1ffa2..e864cd0ad4a 100644
--- a/src/test/run-pass/u8-incr-decr.rs
+++ b/src/test/run-pass/u8-incr-decr.rs
@@ -24,5 +24,5 @@ pub fn main() {
 
     y = y - 9u8; // 0x9
 
-    fail_unless!((x == y));
+    assert!((x == y));
 }
diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs
index 2617437d17c..c9d31fb72b7 100644
--- a/src/test/run-pass/u8-incr.rs
+++ b/src/test/run-pass/u8-incr.rs
@@ -17,7 +17,7 @@ pub fn main() {
     let y: u8 = 12u8;
     x = x + 1u8;
     x = x - 1u8;
-    fail_unless!((x == y));
+    assert!((x == y));
     // x = 14u8;
     // x = x + 1u8;
 
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index 8ecff0719a2..d05cb76e113 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -15,6 +15,6 @@ pub fn main() {
     j = i.clone();
     *i = 2;
     *j = 3;
-    fail_unless!(*i == 2);
-    fail_unless!(*j == 3);
+    assert!(*i == 2);
+    assert!(*j == 3);
 }
diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs
index fec3f7b626a..0faa6b1b555 100644
--- a/src/test/run-pass/unique-assign-drop.rs
+++ b/src/test/run-pass/unique-assign-drop.rs
@@ -13,5 +13,5 @@ pub fn main() {
     let mut j = ~2;
     // Should drop the previous value of j
     j = i;
-    fail_unless!(*j == 1);
+    assert!(*j == 1);
 }
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index 4254c12bac3..75753b31ed7 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -15,7 +15,7 @@ fn f<T:Copy>(t: T) -> T {
 
 pub fn main() {
     let t = f(~100);
-    fail_unless!(t == ~100);
+    assert!(t == ~100);
     let t = f(~@~[100]);
-    fail_unless!(t == ~@~[100]);
+    assert!(t == ~@~[100]);
 }
diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs
index 4f283d11eea..6fc16cae76f 100644
--- a/src/test/run-pass/unique-assign.rs
+++ b/src/test/run-pass/unique-assign.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let mut i;
     i = ~1;
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs
index 7326c642cf0..07105a53caf 100644
--- a/src/test/run-pass/unique-autoderef-field.rs
+++ b/src/test/run-pass/unique-autoderef-field.rs
@@ -14,5 +14,5 @@ pub fn main() {
     let i = ~J {
         j: 100
     };
-    fail_unless!(i.j == 100);
+    assert!(i.j == 100);
 }
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index a96f7d5c167..324efe5abe5 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let i = ~~[100];
-    fail_unless!(i[0] == 100);
+    assert!(i[0] == 100);
 }
diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs
index 237ade196f0..b50d3154835 100644
--- a/src/test/run-pass/unique-cmp.rs
+++ b/src/test/run-pass/unique-cmp.rs
@@ -10,9 +10,9 @@
 
 pub fn main() {
     let i = ~100;
-    fail_unless!(i == ~100);
-    fail_unless!(i < ~101);
-    fail_unless!(i <= ~100);
-    fail_unless!(i > ~99);
-    fail_unless!(i >= ~99);
+    assert!(i == ~100);
+    assert!(i < ~101);
+    assert!(i <= ~100);
+    assert!(i > ~99);
+    assert!(i >= ~99);
 }
diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs
index 42921f24c75..c8ed7b10a1f 100644
--- a/src/test/run-pass/unique-containing-tag.rs
+++ b/src/test/run-pass/unique-containing-tag.rs
@@ -15,14 +15,14 @@ pub fn main() {
 
     /*alt *x {
       t1(a) {
-        fail_unless!(a == 10);
+        assert!(a == 10);
       }
       _ { fail!(); }
     }*/
 
     /*alt x {
       ~t1(a) {
-        fail_unless!(a == 10);
+        assert!(a == 10);
       }
       _ { fail!(); }
     }*/
diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs
index 22e05213e5d..b483881f1a6 100644
--- a/src/test/run-pass/unique-copy-box.rs
+++ b/src/test/run-pass/unique-copy-box.rs
@@ -16,6 +16,6 @@ pub fn main() {
         let j = copy i;
         let rc2 = sys::refcount(*i);
         error!("rc1: %u rc2: %u", rc1, rc2);
-        fail_unless!(rc1 + 1u == rc2);
+        assert!(rc1 + 1u == rc2);
     }
 }
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index 177b3ed5c24..670bc35d857 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -14,6 +14,6 @@ pub fn main() {
     let mut j = i.clone();
     *i = 2;
     *j = 3;
-    fail_unless!(*i == 2);
-    fail_unless!(*j == 3);
+    assert!(*i == 2);
+    assert!(*j == 3);
 }
diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs
index 809ca5bae0d..f5f1829cae0 100644
--- a/src/test/run-pass/unique-decl-init.rs
+++ b/src/test/run-pass/unique-decl-init.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let i = ~1;
     let j = i;
-    fail_unless!(*j == 1);
+    assert!(*j == 1);
 }
diff --git a/src/test/run-pass/unique-decl-move-temp.rs b/src/test/run-pass/unique-decl-move-temp.rs
index 1632a537174..b9f122acbcd 100644
--- a/src/test/run-pass/unique-decl-move-temp.rs
+++ b/src/test/run-pass/unique-decl-move-temp.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let i = ~100;
-    fail_unless!(*i == 100);
+    assert!(*i == 100);
 }
diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs
index 402d05fbcef..81c59bae357 100644
--- a/src/test/run-pass/unique-decl-move.rs
+++ b/src/test/run-pass/unique-decl-move.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let i = ~100;
     let j = i;
-    fail_unless!(*j == 100);
+    assert!(*j == 100);
 }
diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs
index 1632a537174..b9f122acbcd 100644
--- a/src/test/run-pass/unique-deref.rs
+++ b/src/test/run-pass/unique-deref.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let i = ~100;
-    fail_unless!(*i == 100);
+    assert!(*i == 100);
 }
diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs
index c3047d5da05..64e01f86474 100644
--- a/src/test/run-pass/unique-destructure.rs
+++ b/src/test/run-pass/unique-destructure.rs
@@ -12,5 +12,5 @@ struct Foo { a: int, b: int }
 
 pub fn main() {
     let ~Foo{a, b} = ~Foo{a: 100, b: 200};
-    fail_unless!(a + b == 300);
+    assert!(a + b == 300);
 }
diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs
index 5a318d04e55..bbb33560e32 100644
--- a/src/test/run-pass/unique-fn-arg-move.rs
+++ b/src/test/run-pass/unique-fn-arg-move.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn f(+i: ~int) {
-    fail_unless!(*i == 100);
+    assert!(*i == 100);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs
index 09be9e178ce..56ec9663ec6 100644
--- a/src/test/run-pass/unique-fn-arg-mut.rs
+++ b/src/test/run-pass/unique-fn-arg-mut.rs
@@ -15,5 +15,5 @@ fn f(i: &mut ~int) {
 pub fn main() {
     let mut i = ~100;
     f(&mut i);
-    fail_unless!(*i == 200);
+    assert!(*i == 200);
 }
diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs
index 030e11e46f6..931c5acbe1d 100644
--- a/src/test/run-pass/unique-fn-arg.rs
+++ b/src/test/run-pass/unique-fn-arg.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn f(i: ~int) {
-    fail_unless!(*i == 100);
+    assert!(*i == 100);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs
index d645c3c21a6..0ef9d12f75b 100644
--- a/src/test/run-pass/unique-fn-ret.rs
+++ b/src/test/run-pass/unique-fn-ret.rs
@@ -13,5 +13,5 @@ fn f() -> ~int {
 }
 
 pub fn main() {
-    fail_unless!(f() == ~100);
+    assert!(f() == ~100);
 }
diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs
index e46a79d364f..0e7d3849461 100644
--- a/src/test/run-pass/unique-in-tag.rs
+++ b/src/test/run-pass/unique-in-tag.rs
@@ -12,7 +12,7 @@ fn test1() {
     enum bar { u(~int), w(int), }
 
     let x = u(~10);
-    fail_unless!(match x {
+    assert!(match x {
       u(a) => {
         error!(a);
         *a
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 1033fa1c22c..e7226279579 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -12,12 +12,12 @@ pub fn main() {
     let mut a = ~[~10];
     let b = a.clone();
 
-    fail_unless!(*a[0] == 10);
-    fail_unless!(*b[0] == 10);
+    assert!(*a[0] == 10);
+    assert!(*b[0] == 10);
 
     // This should only modify the value in a, not b
     *a[0] = 20;
 
-    fail_unless!(*a[0] == 20);
-    fail_unless!(*b[0] == 10);
+    assert!(*a[0] == 20);
+    assert!(*b[0] == 10);
 }
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 62e9e03d3a1..51fceae39b4 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!((~[~100])[0] == ~100);
+    assert!((~[~100])[0] == ~100);
 }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 9844a55c960..da48f2ff51b 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -13,11 +13,11 @@ use core::cmp::Eq;
 fn sendable() {
 
     fn f<T:Owned + Eq>(i: T, j: T) {
-        fail_unless!(i == j);
+        assert!(i == j);
     }
 
     fn g<T:Owned + Eq>(i: T, j: T) {
-        fail_unless!(i != j);
+        assert!(i != j);
     }
 
     let i = ~100;
@@ -31,11 +31,11 @@ fn sendable() {
 fn copyable() {
 
     fn f<T:Copy + Eq>(i: T, j: T) {
-        fail_unless!(i == j);
+        assert!(i == j);
     }
 
     fn g<T:Copy + Eq>(i: T, j: T) {
-        fail_unless!(i != j);
+        assert!(i != j);
     }
 
     let i = ~100;
@@ -49,11 +49,11 @@ fn copyable() {
 fn noncopyable() {
 
     fn f<T:Eq>(i: T, j: T) {
-        fail_unless!(i == j);
+        assert!(i == j);
     }
 
     fn g<T:Eq>(i: T, j: T) {
-        fail_unless!(i != j);
+        assert!(i != j);
     }
 
     let i = ~100;
diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs
index ac64b388a05..5ddc85ea5fa 100644
--- a/src/test/run-pass/unique-move-drop.rs
+++ b/src/test/run-pass/unique-move-drop.rs
@@ -12,5 +12,5 @@ pub fn main() {
     let i = ~100;
     let j = ~200;
     let j = i;
-    fail_unless!(*j == 100);
+    assert!(*j == 100);
 }
diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs
index 2f8b0a84b04..343b0d43142 100644
--- a/src/test/run-pass/unique-move-temp.rs
+++ b/src/test/run-pass/unique-move-temp.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let mut i;
     i = ~100;
-    fail_unless!(*i == 100);
+    assert!(*i == 100);
 }
diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs
index 3dc80e26b1c..3331350facd 100644
--- a/src/test/run-pass/unique-move.rs
+++ b/src/test/run-pass/unique-move.rs
@@ -12,5 +12,5 @@ pub fn main() {
     let i = ~100;
     let mut j;
     j = i;
-    fail_unless!(*j == 100);
+    assert!(*j == 100);
 }
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index 4e7c751b883..e4a1b4a548b 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -11,5 +11,5 @@
 pub fn main() {
     let mut i = ~0;
     *i = 1;
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
diff --git a/src/test/run-pass/unique-object.rs b/src/test/run-pass/unique-object.rs
index f2aab3bbb51..1cf4cf09b81 100644
--- a/src/test/run-pass/unique-object.rs
+++ b/src/test/run-pass/unique-object.rs
@@ -25,6 +25,6 @@ impl Foo for Bar {
 pub fn main() {
     let x = ~Bar { x: 10 };
     let y = x as ~Foo;
-    fail_unless!(y.f() == 10);
+    assert!(y.f() == 10);
 }
 
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index ef9ed082c00..49a873e793a 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -14,7 +14,7 @@ struct Foo {a: int, b: uint}
 enum bar { u(~Foo), w(int), }
 
 pub fn main() {
-    fail_unless!(match u(~Foo{a: 10, b: 40u}) {
+    assert!(match u(~Foo{a: 10, b: 40u}) {
               u(~Foo{a: a, b: b}) => { a + (b as int) }
               _ => { 66 }
             } == 50);
diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs
index 14fc1cca4e5..78551b701f2 100644
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -12,7 +12,7 @@
 enum bar { u(~int), w(int), }
 
 pub fn main() {
-    fail_unless!(match u(~10) {
+    assert!(match u(~10) {
       u(a) => {
         error!(a);
         *a
diff --git a/src/test/run-pass/unique-pinned-nocopy-2.rs b/src/test/run-pass/unique-pinned-nocopy-2.rs
index ff22c18b02c..d3cdc9a8788 100644
--- a/src/test/run-pass/unique-pinned-nocopy-2.rs
+++ b/src/test/run-pass/unique-pinned-nocopy-2.rs
@@ -32,5 +32,5 @@ pub fn main() {
     {
         let j = ~r(i);
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs
index b1b833f9163..0564c2ebddd 100644
--- a/src/test/run-pass/unique-rec.rs
+++ b/src/test/run-pass/unique-rec.rs
@@ -13,5 +13,5 @@ struct X { x: int }
 pub fn main() {
     let x = ~X {x: 1};
     let bar = x;
-    fail_unless!(bar.x == 1);
+    assert!(bar.x == 1);
 }
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index d7c70b55080..b655f86bdbb 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -31,5 +31,5 @@ pub fn main() {
         actual += *j;
     }
 
-    fail_unless!(expected == actual);
+    assert!(expected == actual);
 }
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index 3b2569c2712..c9d3a951920 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -14,5 +14,5 @@ pub fn main() {
     let (p, c) = stream();
     c.send(~100);
     let v = p.recv();
-    fail_unless!(v == ~100);
+    assert!(v == ~100);
 }
diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs
index fd869d2e043..6cd7b358c55 100644
--- a/src/test/run-pass/unique-swap.rs
+++ b/src/test/run-pass/unique-swap.rs
@@ -12,6 +12,6 @@ pub fn main() {
     let mut i = ~100;
     let mut j = ~200;
     i <-> j;
-    fail_unless!(i == ~200);
-    fail_unless!(j == ~100);
+    assert!(i == ~200);
+    assert!(j == ~100);
 }
diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs
index 1468b47706d..05c9cd8a574 100644
--- a/src/test/run-pass/unsafe-pointer-assignability.rs
+++ b/src/test/run-pass/unsafe-pointer-assignability.rs
@@ -10,7 +10,7 @@
 
 fn f(x: *int) {
     unsafe {
-        fail_unless!(*x == 3);
+        assert!(*x == 3);
     }
 }
 
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index 80672f78514..f76868b28be 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -42,5 +42,5 @@ pub fn main() {
     let c = SharedChan(c);
     task::spawn_unlinked(|| f(c.clone()) );
     error!("hiiiiiiiii");
-    fail_unless!(p.recv());
+    assert!(p.recv());
 }
diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
index a78461ff4ee..51fc42491e0 100644
--- a/src/test/run-pass/utf8.rs
+++ b/src/test/run-pass/utf8.rs
@@ -15,14 +15,14 @@ pub fn main() {
     let y_diaeresis: char = 'ÿ'; // 0xff
     let pi: char = 'Π'; // 0x3a0
 
-    fail_unless!((yen as int == 0xa5));
-    fail_unless!((c_cedilla as int == 0xe7));
-    fail_unless!((thorn as int == 0xfe));
-    fail_unless!((y_diaeresis as int == 0xff));
-    fail_unless!((pi as int == 0x3a0));
+    assert!((yen as int == 0xa5));
+    assert!((c_cedilla as int == 0xe7));
+    assert!((thorn as int == 0xfe));
+    assert!((y_diaeresis as int == 0xff));
+    assert!((pi as int == 0x3a0));
 
-    fail_unless!((pi as int == '\u03a0' as int));
-    fail_unless!(('\x0a' as int == '\n' as int));
+    assert!((pi as int == '\u03a0' as int));
+    assert!(('\x0a' as int == '\n' as int));
 
     let bhutan: ~str = ~"འབྲུག་ཡུལ།";
     let japan: ~str = ~"日本";
@@ -37,7 +37,7 @@ pub fn main() {
     let austria_e: ~str = ~"\u00d6sterreich";
 
     let oo: char = 'Ö';
-    fail_unless!((oo as int == 0xd6));
+    assert!((oo as int == 0xd6));
 
     fn check_str_eq(a: ~str, b: ~str) {
         let mut i: int = 0;
@@ -46,7 +46,7 @@ pub fn main() {
             debug!(ab);
             let bb: u8 = b[i];
             debug!(bb);
-            fail_unless!((ab == bb));
+            assert!((ab == bb));
             i += 1;
         }
     }
diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs
index 247fd2d712a..714fd6e3ac5 100644
--- a/src/test/run-pass/utf8_chars.rs
+++ b/src/test/run-pass/utf8_chars.rs
@@ -15,25 +15,25 @@ pub fn main() {
     let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char];
     let s: ~str = str::from_chars(chs);
 
-    fail_unless!((str::len(s) == 10u));
-    fail_unless!((str::char_len(s) == 4u));
-    fail_unless!((vec::len(str::to_chars(s)) == 4u));
-    fail_unless!((str::from_chars(str::to_chars(s)) == s));
-    fail_unless!((str::char_at(s, 0u) == 'e'));
-    fail_unless!((str::char_at(s, 1u) == 'é'));
+    assert!((str::len(s) == 10u));
+    assert!((str::char_len(s) == 4u));
+    assert!((vec::len(str::to_chars(s)) == 4u));
+    assert!((str::from_chars(str::to_chars(s)) == s));
+    assert!((str::char_at(s, 0u) == 'e'));
+    assert!((str::char_at(s, 1u) == 'é'));
 
-    fail_unless!((str::is_utf8(str::to_bytes(s))));
-    fail_unless!((!str::is_utf8(~[0x80_u8])));
-    fail_unless!((!str::is_utf8(~[0xc0_u8])));
-    fail_unless!((!str::is_utf8(~[0xc0_u8, 0x10_u8])));
+    assert!((str::is_utf8(str::to_bytes(s))));
+    assert!((!str::is_utf8(~[0x80_u8])));
+    assert!((!str::is_utf8(~[0xc0_u8])));
+    assert!((!str::is_utf8(~[0xc0_u8, 0x10_u8])));
 
     let mut stack = ~"a×c€";
-    fail_unless!((str::pop_char(&mut stack) == '€'));
-    fail_unless!((str::pop_char(&mut stack) == 'c'));
+    assert!((str::pop_char(&mut stack) == '€'));
+    assert!((str::pop_char(&mut stack) == 'c'));
     str::push_char(&mut stack, 'u');
-    fail_unless!((stack == ~"a×u"));
-    fail_unless!((str::shift_char(&mut stack) == 'a'));
-    fail_unless!((str::shift_char(&mut stack) == '×'));
+    assert!((stack == ~"a×u"));
+    assert!((str::shift_char(&mut stack) == 'a'));
+    assert!((str::shift_char(&mut stack) == '×'));
     str::unshift_char(&mut stack, 'ß');
-    fail_unless!((stack == ~"ßu"));
+    assert!((stack == ~"ßu"));
 }
diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs
index 58fd9216b15..25d2d91d565 100644
--- a/src/test/run-pass/utf8_idents.rs
+++ b/src/test/run-pass/utf8_idents.rs
@@ -12,8 +12,8 @@ pub fn main() {
     let ε = 0.00001;
     let Π = 3.14;
     let लंच = Π * Π + 1.54;
-    fail_unless!(float::abs((लंच - 1.54) - (Π * Π)) < ε);
-    fail_unless!(საჭმელად_გემრიელი_სადილი() == 0);
+    assert!(float::abs((लंच - 1.54) - (Π * Π)) < ε);
+    assert!(საჭმელად_გემრიელი_სადილი() == 0);
 }
 
 fn საჭმელად_გემრიელი_სადილი() -> int {
@@ -37,9 +37,9 @@ fn საჭმელად_გემრიელი_სადილი() -> int
 
     // Lunchy arithmetic, mm.
 
-    fail_unless!(hádegismatur * ручек * обед == 1000);
-    fail_unless!(10 ==  ארוחת_צהריי);
-    fail_unless!(ランチ + 午餐 + μεσημεριανό == 30);
-    fail_unless!(ăn_trưa + อาหารกลางวัน == 20);
+    assert!(hádegismatur * ручек * обед == 1000);
+    assert!(10 ==  ארוחת_צהריי);
+    assert!(ランチ + 午餐 + μεσημεριανό == 30);
+    assert!(ăn_trưa + อาหารกลางวัน == 20);
     return (абед + լանչ) >> غداء;
 }
diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs
index 7023c50d0bd..0045b356d65 100644
--- a/src/test/run-pass/vec-concat.rs
+++ b/src/test/run-pass/vec-concat.rs
@@ -14,7 +14,7 @@ pub fn main() {
     let b: ~[int] = ~[6, 7, 8, 9, 0];
     let v: ~[int] = a + b;
     debug!(v[9]);
-    fail_unless!((v[0] == 1));
-    fail_unless!((v[7] == 8));
-    fail_unless!((v[9] == 0));
+    assert!((v[0] == 1));
+    assert!((v[7] == 8));
+    assert!((v[9] == 0));
 }
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index 84049c9a756..e1e268e63de 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -16,9 +16,9 @@ pub fn main() {
     v += ~[3];
     v += ~[4];
     v += ~[5];
-    fail_unless!((v[0] == 1));
-    fail_unless!((v[1] == 2));
-    fail_unless!((v[2] == 3));
-    fail_unless!((v[3] == 4));
-    fail_unless!((v[4] == 5));
+    assert!((v[0] == 1));
+    assert!((v[1] == 2));
+    assert!((v[2] == 3));
+    assert!((v[3] == 4));
+    assert!((v[4] == 5));
 }
diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs
index 615d77f18e9..012b8b83637 100644
--- a/src/test/run-pass/vec-matching-autoslice.rs
+++ b/src/test/run-pass/vec-matching-autoslice.rs
@@ -3,7 +3,7 @@ pub fn main() {
     match x {
         [2, .._] => ::core::util::unreachable(),
         [1, ..tail] => {
-            fail_unless!(tail == [2, 3]);
+            assert!(tail == [2, 3]);
         }
         [_] => ::core::util::unreachable(),
         [] => ::core::util::unreachable()
@@ -13,9 +13,9 @@ pub fn main() {
     match y {
         ([_, _, _], 0.5) => ::core::util::unreachable(),
         ([(1, a), (b, false), ..tail], _) => {
-            fail_unless!(a == true);
-            fail_unless!(b == 2);
-            fail_unless!(tail.is_empty());
+            assert!(a == true);
+            assert!(b == 2);
+            assert!(tail.is_empty());
         }
         ([..tail], _) => ::core::util::unreachable()
     }
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index dfd4f025c13..e6b7bffc158 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -26,8 +26,8 @@ pub fn main() {
     let x = [1, 2, 3, 4, 5];
 
     let product = foldl(x, 1, |a, b| a * *b);
-    fail_unless!(product == 120);
+    assert!(product == 120);
 
     let sum = foldr(x, 0, |a, b| *a + b);
-    fail_unless!(sum == 15);
+    assert!(sum == 15);
 }
diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs
index 1402dd18fc7..e9cf400334c 100644
--- a/src/test/run-pass/vec-matching.rs
+++ b/src/test/run-pass/vec-matching.rs
@@ -6,7 +6,7 @@ fn a() {
         [_, .._, _, _] => ::core::util::unreachable(),
         [_, _] => ::core::util::unreachable(),
         [a] => {
-            fail_unless!(a == 1);
+            assert!(a == 1);
         }
         [] => ::core::util::unreachable()
     }
@@ -16,33 +16,33 @@ fn b() {
     let x = [1, 2, 3];
     match x {
         [a, b, ..c] => {
-            fail_unless!(a == 1);
-            fail_unless!(b == 2);
-            fail_unless!(c == &[3]);
+            assert!(a == 1);
+            assert!(b == 2);
+            assert!(c == &[3]);
         }
         _ => fail!()
     }
     match x {
         [..a, b, c] => {
-            fail_unless!(a == &[1]);
-            fail_unless!(b == 2);
-            fail_unless!(c == 3);
+            assert!(a == &[1]);
+            assert!(b == 2);
+            assert!(c == 3);
         }
         _ => fail!()
     }
     match x {
         [a, ..b, c] => {
-            fail_unless!(a == 1);
-            fail_unless!(b == &[2]);
-            fail_unless!(c == 3);
+            assert!(a == 1);
+            assert!(b == &[2]);
+            assert!(c == 3);
         }
         _ => fail!()
     }
     match x {
         [a, b, c] => {
-            fail_unless!(a == 1);
-            fail_unless!(b == 2);
-            fail_unless!(c == 3);
+            assert!(a == 1);
+            assert!(b == 2);
+            assert!(c == 3);
         }
         _ => fail!()
     }
diff --git a/src/test/run-pass/vec-position.rs b/src/test/run-pass/vec-position.rs
index a1dddf33025..aaf232f2046 100644
--- a/src/test/run-pass/vec-position.rs
+++ b/src/test/run-pass/vec-position.rs
@@ -10,7 +10,7 @@
 
 pub fn main() {
     let mut v = ~[1, 2, 3];
-    fail_unless!(v.position(|x| *x == 1) == Some(0));
-    fail_unless!(v.position(|x| *x == 3) == Some(2));
-    fail_unless!(v.position(|x| *x == 17) == None);
+    assert!(v.position(|x| *x == 1) == Some(0));
+    assert!(v.position(|x| *x == 3) == Some(2));
+    assert!(v.position(|x| *x == 17) == None);
 }
diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs
index 00b55aa9a01..acd9cf6f01b 100644
--- a/src/test/run-pass/vec-self-append.rs
+++ b/src/test/run-pass/vec-self-append.rs
@@ -14,17 +14,17 @@ fn test_heap_to_heap() {
     // a spills onto the heap
     let mut a = ~[0, 1, 2, 3, 4];
     a = a + a; // FIXME(#3387)---can't write a += a
-    fail_unless!((vec::len(a) == 10u));
-    fail_unless!((a[0] == 0));
-    fail_unless!((a[1] == 1));
-    fail_unless!((a[2] == 2));
-    fail_unless!((a[3] == 3));
-    fail_unless!((a[4] == 4));
-    fail_unless!((a[5] == 0));
-    fail_unless!((a[6] == 1));
-    fail_unless!((a[7] == 2));
-    fail_unless!((a[8] == 3));
-    fail_unless!((a[9] == 4));
+    assert!((vec::len(a) == 10u));
+    assert!((a[0] == 0));
+    assert!((a[1] == 1));
+    assert!((a[2] == 2));
+    assert!((a[3] == 3));
+    assert!((a[4] == 4));
+    assert!((a[5] == 0));
+    assert!((a[6] == 1));
+    assert!((a[7] == 2));
+    assert!((a[8] == 3));
+    assert!((a[9] == 4));
 }
 
 fn test_stack_to_heap() {
@@ -32,13 +32,13 @@ fn test_stack_to_heap() {
     let mut a = ~[0, 1, 2];
     // a spills to the heap
     a = a + a; // FIXME(#3387)---can't write a += a
-    fail_unless!((vec::len(a) == 6u));
-    fail_unless!((a[0] == 0));
-    fail_unless!((a[1] == 1));
-    fail_unless!((a[2] == 2));
-    fail_unless!((a[3] == 0));
-    fail_unless!((a[4] == 1));
-    fail_unless!((a[5] == 2));
+    assert!((vec::len(a) == 6u));
+    assert!((a[0] == 0));
+    assert!((a[1] == 1));
+    assert!((a[2] == 2));
+    assert!((a[3] == 0));
+    assert!((a[4] == 1));
+    assert!((a[5] == 2));
 }
 
 fn test_loop() {
@@ -48,7 +48,7 @@ fn test_loop() {
     let mut expected_len = 1u;
     while i > 0 {
         error!(vec::len(a));
-        fail_unless!((vec::len(a) == expected_len));
+        assert!((vec::len(a) == expected_len));
         a = a + a; // FIXME(#3387)---can't write a += a
         i -= 1;
         expected_len *= 2u;
diff --git a/src/test/run-pass/vec-slice-drop.rs b/src/test/run-pass/vec-slice-drop.rs
index 2a7c9610ad4..cc0649790fd 100644
--- a/src/test/run-pass/vec-slice-drop.rs
+++ b/src/test/run-pass/vec-slice-drop.rs
@@ -32,7 +32,7 @@ pub fn main() {
     let x = @mut 0;
     {
         let l = &[foo(x)];
-        fail_unless!(*l[0].x == 0);
+        assert!(*l[0].x == 0);
     }
-    fail_unless!(*x == 1);
+    assert!(*x == 1);
 }
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index cbf5edd1718..8e653d21ec6 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -11,6 +11,6 @@
 pub fn main() {
     let  v = ~[1,2,3,4,5];
     let v2 = vec::slice(v, 1, 3);
-    fail_unless!((v2[0] == 2));
-    fail_unless!((v2[1] == 3));
+    assert!((v2[0] == 2));
+    assert!((v2[1] == 3));
 }
diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs
index 6fbae42435e..fd65f150e4c 100644
--- a/src/test/run-pass/vec-tail-matching.rs
+++ b/src/test/run-pass/vec-tail-matching.rs
@@ -10,18 +10,18 @@ pub fn main() {
     ];
     match x {
         [first, ..tail] => {
-            fail_unless!(first.string == ~"foo");
-            fail_unless!(tail.len() == 2);
-            fail_unless!(tail[0].string == ~"bar");
-            fail_unless!(tail[1].string == ~"baz");
+            assert!(first.string == ~"foo");
+            assert!(tail.len() == 2);
+            assert!(tail[0].string == ~"bar");
+            assert!(tail[1].string == ~"baz");
 
             match tail {
                 [Foo { _ }, _, Foo { _ }, ..tail] => {
                     ::core::util::unreachable();
                 }
                 [Foo { string: a }, Foo { string: b }] => {
-                    fail_unless!(a == ~"bar");
-                    fail_unless!(b == ~"baz");
+                    assert!(a == ~"bar");
+                    assert!(b == ~"baz");
                 }
                 _ => {
                     ::core::util::unreachable();
diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs
index b7130bfc719..1767dd3ee5b 100644
--- a/src/test/run-pass/vec-to_str.rs
+++ b/src/test/run-pass/vec-to_str.rs
@@ -9,16 +9,16 @@
 // except according to those terms.
 
 pub fn main() {
-    fail_unless!((~[0, 1]).to_str() == ~"[0, 1]");
-    fail_unless!((&[1, 2]).to_str() == ~"[1, 2]");
-    fail_unless!((@[2, 3]).to_str() == ~"[2, 3]");
+    assert!((~[0, 1]).to_str() == ~"[0, 1]");
+    assert!((&[1, 2]).to_str() == ~"[1, 2]");
+    assert!((@[2, 3]).to_str() == ~"[2, 3]");
 
     let foo = ~[3, 4];
     let bar = &[4, 5];
     let baz = @[5, 6];
 
-    fail_unless!(foo.to_str() == ~"[3, 4]");
-    fail_unless!(bar.to_str() == ~"[4, 5]");
-    fail_unless!(baz.to_str() == ~"[5, 6]");
+    assert!(foo.to_str() == ~"[3, 4]");
+    assert!(bar.to_str() == ~"[4, 5]");
+    assert!(baz.to_str() == ~"[5, 6]");
 
 }
diff --git a/src/test/run-pass/vec-trailing-comma.rs b/src/test/run-pass/vec-trailing-comma.rs
index 28914792720..686fc655bdb 100644
--- a/src/test/run-pass/vec-trailing-comma.rs
+++ b/src/test/run-pass/vec-trailing-comma.rs
@@ -13,8 +13,8 @@
 pub fn main() {
     let v1: ~[int] = ~[10, 20, 30,];
     let v2: ~[int] = ~[10, 20, 30];
-    fail_unless!((v1[2] == v2[2]));
+    assert!((v1[2] == v2[2]));
     let v3: ~[int] = ~[10,];
     let v4: ~[int] = ~[10];
-    fail_unless!((v3[0] == v4[0]));
+    assert!((v3[0] == v4[0]));
 }
diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs
index 07365f346a7..d0215888147 100644
--- a/src/test/run-pass/vec.rs
+++ b/src/test/run-pass/vec.rs
@@ -14,12 +14,12 @@
 // -*- rust -*-
 pub fn main() {
     let v: ~[int] = ~[10, 20];
-    fail_unless!((v[0] == 10));
-    fail_unless!((v[1] == 20));
+    assert!((v[0] == 10));
+    assert!((v[1] == 20));
     let mut x: int = 0;
-    fail_unless!((v[x] == 10));
-    fail_unless!((v[x + 1] == 20));
+    assert!((v[x] == 10));
+    assert!((v[x + 1] == 20));
     x = x + 1;
-    fail_unless!((v[x] == 20));
-    fail_unless!((v[x - 1] == 10));
+    assert!((v[x] == 20));
+    assert!((v[x - 1] == 10));
 }
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 0af35a6c619..ed0032b93ea 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -22,7 +22,7 @@ fn what() {
     let i = @mut false;
     let dont = {||the(i)};
     dont();
-    fail_unless!((*i));
+    assert!((*i));
 }
 
 fn zombiejesus() {
@@ -57,8 +57,8 @@ fn notsure() {
 
 fn canttouchthis() -> uint {
     fn p() -> bool { true }
-    let _a = (fail_unless!((true)) == (fail_unless!(p())));
-    let _c = (fail_unless!((p())) == ());
+    let _a = (assert!((true)) == (assert!(p())));
+    let _c = (assert!((p())) == ());
     let _b: bool = (debug!("%d", 0) == (return 0u));
 }
 
diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs
index 5a67f98423d..37528a7cfae 100644
--- a/src/test/run-pass/while-cont.rs
+++ b/src/test/run-pass/while-cont.rs
@@ -12,7 +12,7 @@
 pub fn main() {
     let mut i = 1;
     while i > 0 {
-        fail_unless!((i > 0));
+        assert!((i > 0));
         debug!(i);
         i -= 1;
         loop;
diff --git a/src/test/run-pass/while-loop-constraints-2.rs b/src/test/run-pass/while-loop-constraints-2.rs
index 13376eddc41..7b5cd095849 100644
--- a/src/test/run-pass/while-loop-constraints-2.rs
+++ b/src/test/run-pass/while-loop-constraints-2.rs
@@ -18,5 +18,5 @@ pub fn main() {
         while false { x = y; y = z; }
         debug!(y);
     }
-    fail_unless!((y == 42 && z == 50));
+    assert!((y == 42 && z == 50));
 }
diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs
index 0644c55f8c8..417c0cdd915 100644
--- a/src/test/run-pass/while-with-break.rs
+++ b/src/test/run-pass/while-with-break.rs
@@ -15,5 +15,5 @@ pub fn main() {
             break;
         }
     }
-    fail_unless!((i == 95));
+    assert!((i == 95));
 }
diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs
index cfc94b67b57..f22f90380c6 100644
--- a/src/test/run-pass/writealias.rs
+++ b/src/test/run-pass/writealias.rs
@@ -19,5 +19,5 @@ fn f(p: &mut Point) { p.z = 13; }
 pub fn main() {
     let mut x: Point = Point {x: 10, y: 11, z: 12};
     f(&mut x);
-    fail_unless!((x.z == 13));
+    assert!((x.z == 13));
 }
diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs
index b1421dce0ae..c7c47753b8a 100644
--- a/src/test/run-pass/x86stdcall.rs
+++ b/src/test/run-pass/x86stdcall.rs
@@ -25,7 +25,7 @@ pub fn main() {
         kernel32::SetLastError(expected);
         let actual = kernel32::GetLastError();
         log(error, actual);
-        fail_unless!((expected == actual));
+        assert!((expected == actual));
     }
 }
 
diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs
index 672505f6315..9145abbf5cb 100644
--- a/src/test/run-pass/x86stdcall2.rs
+++ b/src/test/run-pass/x86stdcall2.rs
@@ -32,9 +32,9 @@ mod kernel32 {
 pub fn main() {
     let heap = unsafe { kernel32::GetProcessHeap() };
     let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
-    fail_unless!(mem != 0u);
+    assert!(mem != 0u);
     let res = unsafe { kernel32::HeapFree(heap, 0u32, mem) };
-    fail_unless!(res != 0u8);
+    assert!(res != 0u8);
 }
 
 #[cfg(target_os = "macos")]
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index 1876e976c50..50c3e780061 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -12,7 +12,7 @@
 // succeed at runtime
 
 fn enum_chars(start: u8, end: u8) -> ~[char] {
-    fail_unless!(start < end);
+    assert!(start < end);
     let mut i = start;
     let mut r = ~[];
     while i <= end { r.push(i as char); i += 1u as u8; }
@@ -20,7 +20,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] {
 }
 
 fn enum_uints(start: uint, end: uint) -> ~[uint] {
-    fail_unless!(start < end);
+    assert!(start < end);
     let mut i = start;
     let mut r = ~[];
     while i <= end { r.push(i); i += 1u; }
@@ -34,6 +34,6 @@ pub fn main() {
 
     let ps = vec::zip(chars, ints);
 
-    fail_unless!((ps.head() == &('a', 1u)));
-    fail_unless!((ps.last() == &(j as char, 10u)));
+    assert!((ps.head() == &('a', 1u)));
+    assert!((ps.last() == &(j as char, 10u)));
 }