librustc: Remove `fail_unless!`

858 files changed, 5908 insertions, 5921 deletions

diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc
index e213f4fc6da..585fd1271a8 100644
--- a/src/compiletest/compiletest.rc
+++ b/src/compiletest/compiletest.rc
@@ -65,7 +65,7 @@ pub fn parse_config(args: ~[~str]) -> config {
           getopts::optflag(~"jit"),
           getopts::optflag(~"newrt")];
 
-    fail_unless!(!args.is_empty());
+    assert!(!args.is_empty());
     let args_ = vec::tail(args);
     let matches =
         &match getopts::getopts(args_, opts) {
diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs
index 3302b353d69..a96f36f5e70 100644
--- a/src/compiletest/procsrv.rs
+++ b/src/compiletest/procsrv.rs
@@ -25,7 +25,7 @@ fn target_env(lib_path: ~str, prog: ~str) -> ~[(~str,~str)] {
     let mut env = os::env();
 
     // Make sure we include the aux directory in the path
-    fail_unless!(prog.ends_with(~".exe"));
+    assert!(prog.ends_with(~".exe"));
     let aux_path = prog.slice(0u, prog.len() - 4u) + ~".libaux";
 
     env = do vec::map(env) |pair| {
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index c96a6502eec..3e3d70530dd 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -292,30 +292,30 @@ pub fn test() {
     }
 
     assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]);
-    fail_unless!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]);
-    fail_unless!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]);
+    assert!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]);
+    assert!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]);
 }
 
 #[test]
 pub fn append_test() {
-    fail_unless!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]);
+    assert!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]);
 }
 
 #[test]
 pub fn test_from_owned() {
-    fail_unless!(from_owned::<int>(~[]) == @[]);
-    fail_unless!(from_owned(~[true]) == @[true]);
-    fail_unless!(from_owned(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-    fail_unless!(from_owned(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
-    fail_unless!(from_owned(~[~[42]]) == @[~[42]]);
+    assert!(from_owned::<int>(~[]) == @[]);
+    assert!(from_owned(~[true]) == @[true]);
+    assert!(from_owned(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
+    assert!(from_owned(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
+    assert!(from_owned(~[~[42]]) == @[~[42]]);
 }
 
 #[test]
 pub fn test_from_slice() {
-    fail_unless!(from_slice::<int>([]) == @[]);
-    fail_unless!(from_slice([true]) == @[true]);
-    fail_unless!(from_slice([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-    fail_unless!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]);
-    fail_unless!(from_slice([@[42]]) == @[@[42]]);
+    assert!(from_slice::<int>([]) == @[]);
+    assert!(from_slice([true]) == @[true]);
+    assert!(from_slice([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
+    assert!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]);
+    assert!(from_slice([@[42]]) == @[@[42]]);
 }
 
diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs
index 2b669a285b3..a30cb926937 100644
--- a/src/libcore/bool.rs
+++ b/src/libcore/bool.rs
@@ -86,20 +86,20 @@ pub fn test_bool_from_str() {
     use from_str::FromStr;
 
     do all_values |v| {
-        fail_unless!(Some(v) == FromStr::from_str(to_str(v)))
+        assert!(Some(v) == FromStr::from_str(to_str(v)))
     }
 }
 
 #[test]
 pub fn test_bool_to_str() {
-    fail_unless!(to_str(false) == ~"false");
-    fail_unless!(to_str(true) == ~"true");
+    assert!(to_str(false) == ~"false");
+    assert!(to_str(true) == ~"true");
 }
 
 #[test]
 pub fn test_bool_to_bit() {
     do all_values |v| {
-        fail_unless!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
+        assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
     }
 }
 
diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs
index 6d8674caf87..4369d4be217 100644
--- a/src/libcore/cast.rs
+++ b/src/libcore/cast.rs
@@ -50,7 +50,7 @@ pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
  *
  * # Example
  *
- *     fail_unless!(transmute("L") == ~[76u8, 0u8]);
+ *     assert!(transmute("L") == ~[76u8, 0u8]);
  */
 #[inline(always)]
 pub unsafe fn transmute<L, G>(thing: L) -> G {
@@ -116,7 +116,7 @@ pub mod tests {
 
     #[test]
     pub fn test_reinterpret_cast() {
-        fail_unless!(1u == unsafe { reinterpret_cast(&1) });
+        assert!(1u == unsafe { reinterpret_cast(&1) });
     }
 
     #[test]
@@ -127,8 +127,8 @@ pub mod tests {
             let ptr: *int = transmute(box); // refcount 2
             let _box1: @~str = reinterpret_cast(&ptr);
             let _box2: @~str = reinterpret_cast(&ptr);
-            fail_unless!(*_box1 == ~"box box box");
-            fail_unless!(*_box2 == ~"box box box");
+            assert!(*_box1 == ~"box box box");
+            assert!(*_box2 == ~"box box box");
             // Will destroy _box1 and _box2. Without the bump, this would
             // use-after-free. With too many bumps, it would leak.
         }
@@ -140,7 +140,7 @@ pub mod tests {
         unsafe {
             let x = @100u8;
             let x: *BoxRepr = transmute(x);
-            fail_unless!((*x).data == 100);
+            assert!((*x).data == 100);
             let _x: @int = transmute(x);
         }
     }
@@ -148,7 +148,7 @@ pub mod tests {
     #[test]
     pub fn test_transmute2() {
         unsafe {
-            fail_unless!(~[76u8, 0u8] == transmute(~"L"));
+            assert!(~[76u8, 0u8] == transmute(~"L"));
         }
     }
 }
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 72beb4e017d..28b3ebe4484 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -80,12 +80,12 @@ pub impl<T> Cell<T> {
 #[test]
 fn test_basic() {
     let value_cell = Cell(~10);
-    fail_unless!(!value_cell.is_empty());
+    assert!(!value_cell.is_empty());
     let value = value_cell.take();
-    fail_unless!(value == ~10);
-    fail_unless!(value_cell.is_empty());
+    assert!(value == ~10);
+    assert!(value_cell.is_empty());
     value_cell.put_back(value);
-    fail_unless!(!value_cell.is_empty());
+    assert!(!value_cell.is_empty());
 }
 
 #[test]
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 027329a2355..4f1dbe6ab7f 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -200,7 +200,7 @@ pub fn escape_unicode(c: char) -> ~str {
     let (c, pad) = (if c <= '\xff' { ('x', 2u) }
                     else if c <= '\uffff' { ('u', 4u) }
                     else { ('U', 8u) });
-    fail_unless!(str::len(s) <= pad);
+    assert!(str::len(s) <= pad);
     let mut out = ~"\\";
     unsafe {
         str::push_str(&mut out, str::from_char(c));
@@ -258,32 +258,32 @@ impl Eq for char {
 
 #[test]
 fn test_is_lowercase() {
-    fail_unless!(is_lowercase('a'));
-    fail_unless!(is_lowercase('ö'));
-    fail_unless!(is_lowercase('ß'));
-    fail_unless!(!is_lowercase('Ü'));
-    fail_unless!(!is_lowercase('P'));
+    assert!(is_lowercase('a'));
+    assert!(is_lowercase('ö'));
+    assert!(is_lowercase('ß'));
+    assert!(!is_lowercase('Ü'));
+    assert!(!is_lowercase('P'));
 }
 
 #[test]
 fn test_is_uppercase() {
-    fail_unless!(!is_uppercase('h'));
-    fail_unless!(!is_uppercase('ä'));
-    fail_unless!(!is_uppercase('ß'));
-    fail_unless!(is_uppercase('Ö'));
-    fail_unless!(is_uppercase('T'));
+    assert!(!is_uppercase('h'));
+    assert!(!is_uppercase('ä'));
+    assert!(!is_uppercase('ß'));
+    assert!(is_uppercase('Ö'));
+    assert!(is_uppercase('T'));
 }
 
 #[test]
 fn test_is_whitespace() {
-    fail_unless!(is_whitespace(' '));
-    fail_unless!(is_whitespace('\u2007'));
-    fail_unless!(is_whitespace('\t'));
-    fail_unless!(is_whitespace('\n'));
+    assert!(is_whitespace(' '));
+    assert!(is_whitespace('\u2007'));
+    assert!(is_whitespace('\t'));
+    assert!(is_whitespace('\n'));
 
-    fail_unless!(!is_whitespace('a'));
-    fail_unless!(!is_whitespace('_'));
-    fail_unless!(!is_whitespace('\u0000'));
+    assert!(!is_whitespace('a'));
+    assert!(!is_whitespace('_'));
+    assert!(!is_whitespace('\u0000'));
 }
 
 #[test]
@@ -299,24 +299,24 @@ fn test_to_digit() {
     assert_eq!(to_digit('z', 36u), Some(35u));
     assert_eq!(to_digit('Z', 36u), Some(35u));
 
-    fail_unless!(to_digit(' ', 10u).is_none());
-    fail_unless!(to_digit('$', 36u).is_none());
+    assert!(to_digit(' ', 10u).is_none());
+    assert!(to_digit('$', 36u).is_none());
 }
 
 #[test]
 fn test_is_ascii() {
-   fail_unless!(str::all(~"banana", is_ascii));
-   fail_unless!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii));
+   assert!(str::all(~"banana", is_ascii));
+   assert!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii));
 }
 
 #[test]
 fn test_is_digit() {
-   fail_unless!(is_digit('2'));
-   fail_unless!(is_digit('7'));
-   fail_unless!(! is_digit('c'));
-   fail_unless!(! is_digit('i'));
-   fail_unless!(! is_digit('z'));
-   fail_unless!(! is_digit('Q'));
+   assert!(is_digit('2'));
+   assert!(is_digit('7'));
+   assert!(! is_digit('c'));
+   assert!(! is_digit('i'));
+   assert!(! is_digit('z'));
+   assert!(! is_digit('Q'));
 }
 
 #[test]
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 95f6f9bc1b5..a928d3bb2af 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -177,7 +177,7 @@ mod test {
 
     #[test]
     fn test_int_totaleq() {
-        fail_unless!(5.equals(&5));
-        fail_unless!(!2.equals(&17));
+        assert!(5.equals(&5));
+        assert!(!2.equals(&17));
     }
 }
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index 731ef425995..9fd6f1db793 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -465,6 +465,6 @@ pub mod test {
             let _chan = chan;
         }
 
-        fail_unless!(!port.peek());
+        assert!(!port.peek());
     }
 }
diff --git a/src/libcore/condition.rs b/src/libcore/condition.rs
index 41504f1a0e1..ed94f2ef2c4 100644
--- a/src/libcore/condition.rs
+++ b/src/libcore/condition.rs
@@ -127,7 +127,7 @@ mod test {
             trouble(1);
         }
 
-        fail_unless!(inner_trapped);
+        assert!(inner_trapped);
     }
 
     #[test]
@@ -143,7 +143,7 @@ mod test {
             trouble(1);
         }
 
-        fail_unless!(outer_trapped);
+        assert!(outer_trapped);
     }
 
     fn nested_reraise_trap_test_inner() {
@@ -160,7 +160,7 @@ mod test {
             trouble(1);
         }
 
-        fail_unless!(inner_trapped);
+        assert!(inner_trapped);
     }
 
     #[test]
@@ -175,7 +175,7 @@ mod test {
             nested_reraise_trap_test_inner();
         }
 
-        fail_unless!(outer_trapped);
+        assert!(outer_trapped);
     }
 
     #[test]
@@ -190,6 +190,6 @@ mod test {
             trouble(1);
         }
 
-        fail_unless!(trapped);
+        assert!(trapped);
     }
 }
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index 159a79129ee..ee7c1651514 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -171,7 +171,7 @@ priv impl<T> DList<T> {
     // Remove a node from the list.
     fn unlink(@mut self, nobe: @mut DListNode<T>) {
         self.assert_mine(nobe);
-        fail_unless!(self.size > 0);
+        assert!(self.size > 0);
         self.link(nobe.prev, nobe.next);
         nobe.prev = None; // Release extraneous references.
         nobe.next = None;
@@ -193,7 +193,7 @@ priv impl<T> DList<T> {
                    nobe: DListLink<T>,
                    neighbour: @mut DListNode<T>) {
         self.assert_mine(neighbour);
-        fail_unless!(self.size > 0);
+        assert!(self.size > 0);
         self.link(neighbour.prev, nobe);
         self.link(nobe, Some(neighbour));
         self.size += 1;
@@ -202,7 +202,7 @@ priv impl<T> DList<T> {
                     neighbour: @mut DListNode<T>,
                     nobe: DListLink<T>) {
         self.assert_mine(neighbour);
-        fail_unless!(self.size > 0);
+        assert!(self.size > 0);
         self.link(nobe, neighbour.next);
         self.link(Some(neighbour), nobe);
         self.size += 1;
@@ -410,7 +410,7 @@ pub impl<T> DList<T> {
     /// Check data structure integrity. O(n).
     fn assert_consistent(@mut self) {
         if self.hd.is_none() || self.tl.is_none() {
-            fail_unless!(self.hd.is_none() && self.tl.is_none());
+            assert!(self.hd.is_none() && self.tl.is_none());
         }
         // iterate forwards
         let mut count = 0;
@@ -418,7 +418,7 @@ pub impl<T> DList<T> {
         let mut rabbit = link;
         while link.is_some() {
             let nobe = link.get();
-            fail_unless!(nobe.linked);
+            assert!(nobe.linked);
             // check cycle
             if rabbit.is_some() {
                 rabbit = rabbit.get().next;
@@ -427,19 +427,19 @@ pub impl<T> DList<T> {
                 rabbit = rabbit.get().next;
             }
             if rabbit.is_some() {
-                fail_unless!(!managed::mut_ptr_eq(rabbit.get(), nobe));
+                assert!(!managed::mut_ptr_eq(rabbit.get(), nobe));
             }
             // advance
             link = nobe.next_link();
             count += 1;
         }
-        fail_unless!(count == self.len());
+        assert!(count == self.len());
         // iterate backwards - some of this is probably redundant.
         link = self.peek_tail_n();
         rabbit = link;
         while link.is_some() {
             let nobe = link.get();
-            fail_unless!(nobe.linked);
+            assert!(nobe.linked);
             // check cycle
             if rabbit.is_some() {
                 rabbit = rabbit.get().prev;
@@ -448,13 +448,13 @@ pub impl<T> DList<T> {
                 rabbit = rabbit.get().prev;
             }
             if rabbit.is_some() {
-                fail_unless!(!managed::mut_ptr_eq(rabbit.get(), nobe));
+                assert!(!managed::mut_ptr_eq(rabbit.get(), nobe));
             }
             // advance
             link = nobe.prev_link();
             count -= 1;
         }
-        fail_unless!(count == 0);
+        assert!(count == 0);
     }
 }
 
@@ -510,7 +510,7 @@ impl<T> BaseIter<T> for @mut DList<T> {
         let mut link = self.peek_n();
         while link.is_some() {
             let nobe = link.get();
-            fail_unless!(nobe.linked);
+            assert!(nobe.linked);
 
             {
                 let frozen_nobe = &*nobe;
@@ -563,7 +563,7 @@ mod tests {
         abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 6);
         abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 7);
         abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 8);
-        abcd.assert_consistent(); fail_unless!(abcd.is_empty());
+        abcd.assert_consistent(); assert!(abcd.is_empty());
     }
     #[test]
     pub fn test_dlist_append() {
@@ -579,7 +579,7 @@ mod tests {
         a.assert_consistent(); assert_eq!(a.pop().get(), 4);
         a.assert_consistent(); assert_eq!(a.pop().get(), 5);
         a.assert_consistent(); assert_eq!(a.pop().get(), 6);
-        a.assert_consistent(); fail_unless!(a.is_empty());
+        a.assert_consistent(); assert!(a.is_empty());
     }
     #[test]
     pub fn test_dlist_append_empty() {
@@ -592,7 +592,7 @@ mod tests {
         a.assert_consistent(); assert_eq!(a.pop().get(), 1);
         a.assert_consistent(); assert_eq!(a.pop().get(), 2);
         a.assert_consistent(); assert_eq!(a.pop().get(), 3);
-        a.assert_consistent(); fail_unless!(a.is_empty());
+        a.assert_consistent(); assert!(a.is_empty());
     }
     #[test]
     pub fn test_dlist_append_to_empty() {
@@ -605,7 +605,7 @@ mod tests {
         a.assert_consistent(); assert_eq!(a.pop().get(), 4);
         a.assert_consistent(); assert_eq!(a.pop().get(), 5);
         a.assert_consistent(); assert_eq!(a.pop().get(), 6);
-        a.assert_consistent(); fail_unless!(a.is_empty());
+        a.assert_consistent(); assert!(a.is_empty());
     }
     #[test]
     pub fn test_dlist_append_two_empty() {
@@ -645,7 +645,7 @@ mod tests {
         b.assert_consistent(); assert_eq!(b.pop().get(), 4);
         b.assert_consistent(); assert_eq!(b.pop().get(), 5);
         b.assert_consistent(); assert_eq!(b.pop().get(), 6);
-        b.assert_consistent(); fail_unless!(b.is_empty());
+        b.assert_consistent(); assert!(b.is_empty());
     }
     #[test]
     pub fn test_dlist_reverse() {
@@ -657,7 +657,7 @@ mod tests {
         a.assert_consistent(); assert_eq!(a.pop().get(), 3);
         a.assert_consistent(); assert_eq!(a.pop().get(), 4);
         a.assert_consistent(); assert_eq!(a.pop().get(), 5);
-        a.assert_consistent(); fail_unless!(a.is_empty());
+        a.assert_consistent(); assert!(a.is_empty());
     }
     #[test]
     pub fn test_dlist_reverse_empty() {
@@ -681,7 +681,7 @@ mod tests {
         a.assert_consistent(); assert_eq!(a.pop().get(), 4);
         a.assert_consistent(); assert_eq!(a.pop().get(), 3);
         a.assert_consistent(); assert_eq!(a.pop().get(), 5);
-        a.assert_consistent(); fail_unless!(a.is_empty());
+        a.assert_consistent(); assert!(a.is_empty());
     }
     #[test]
     pub fn test_dlist_clear() {
@@ -694,8 +694,8 @@ mod tests {
     pub fn test_dlist_is_empty() {
         let empty = DList::<int>();
         let full1 = from_vec(~[1,2,3]);
-        fail_unless!(empty.is_empty());
-        fail_unless!(!full1.is_empty());
+        assert!(empty.is_empty());
+        assert!(!full1.is_empty());
     }
     #[test]
     pub fn test_dlist_head_tail() {
@@ -714,8 +714,8 @@ mod tests {
         assert_eq!(l.tail(), 3);
         assert_eq!(l.head(), 3);
         assert_eq!(l.pop().get(), 3);
-        fail_unless!(l.is_empty());
-        fail_unless!(l.pop().is_none());
+        assert!(l.is_empty());
+        assert!(l.pop().is_none());
     }
     #[test]
     pub fn test_dlist_pop_tail() {
@@ -727,8 +727,8 @@ mod tests {
         assert_eq!(l.tail(), 1);
         assert_eq!(l.head(), 1);
         assert_eq!(l.pop_tail().get(), 1);
-        fail_unless!(l.is_empty());
-        fail_unless!(l.pop_tail().is_none());
+        assert!(l.is_empty());
+        assert!(l.pop_tail().is_none());
     }
     #[test]
     pub fn test_dlist_push() {
@@ -786,7 +786,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.tail(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_mid() {
@@ -801,7 +801,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.tail(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_tail() {
@@ -816,7 +816,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.tail(), 2);
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_one_two() {
@@ -832,7 +832,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.head(), 3);
         l.assert_consistent(); assert_eq!(l.tail(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_one_three() {
@@ -847,7 +847,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.head(), 2);
         l.assert_consistent(); assert_eq!(l.tail(), 2);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_two_three() {
@@ -862,7 +862,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.head(), 1);
         l.assert_consistent(); assert_eq!(l.tail(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_remove_all() {
@@ -874,8 +874,8 @@ mod tests {
         l.assert_consistent(); l.remove(two);
         l.assert_consistent(); l.remove(three);
         l.assert_consistent(); l.remove(one); // Twenty-three is number one!
-        l.assert_consistent(); fail_unless!(l.peek().is_none());
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.peek().is_none());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_insert_n_before() {
@@ -891,7 +891,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_insert_n_after() {
@@ -907,7 +907,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_insert_before_head() {
@@ -922,7 +922,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test]
     pub fn test_dlist_insert_after_tail() {
@@ -937,7 +937,7 @@ mod tests {
         l.assert_consistent(); assert_eq!(l.pop().get(), 1);
         l.assert_consistent(); assert_eq!(l.pop().get(), 2);
         l.assert_consistent(); assert_eq!(l.pop().get(), 3);
-        l.assert_consistent(); fail_unless!(l.is_empty());
+        l.assert_consistent(); assert!(l.is_empty());
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
     pub fn test_dlist_asymmetric_link() {
diff --git a/src/libcore/either.rs b/src/libcore/either.rs
index 2af9e91a30f..92f850cddd6 100644
--- a/src/libcore/either.rs
+++ b/src/libcore/either.rs
@@ -176,7 +176,7 @@ fn test_either_left() {
     let val = Left(10);
     fn f_left(x: &int) -> bool { *x == 10 }
     fn f_right(_x: &uint) -> bool { false }
-    fail_unless!((either(f_left, f_right, &val)));
+    assert!((either(f_left, f_right, &val)));
 }
 
 #[test]
@@ -184,7 +184,7 @@ fn test_either_right() {
     let val = Right(10u);
     fn f_left(_x: &int) -> bool { false }
     fn f_right(x: &uint) -> bool { *x == 10u }
-    fail_unless!((either(f_left, f_right, &val)));
+    assert!((either(f_left, f_right, &val)));
 }
 
 #[test]
diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs
index d1647ea36fd..a4f12f7da7e 100644
--- a/src/libcore/flate.rs
+++ b/src/libcore/flate.rs
@@ -55,7 +55,7 @@ pub fn deflate_bytes(bytes: &const [u8]) -> ~[u8] {
                                                    len as size_t,
                                                    ptr::addr_of(&outsz),
                                                    lz_norm);
-            fail_unless!(res as int != 0);
+            assert!(res as int != 0);
             let out = vec::raw::from_buf_raw(res as *u8,
                                             outsz as uint);
             libc::free(res);
@@ -73,7 +73,7 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
                                                      len as size_t,
                                                      ptr::addr_of(&outsz),
                                                      0);
-            fail_unless!(res as int != 0);
+            assert!(res as int != 0);
             let out = vec::raw::from_buf_raw(res as *u8,
                                             outsz as uint);
             libc::free(res);
@@ -102,6 +102,6 @@ fn test_flate_round_trip() {
         debug!("%u bytes deflated to %u (%.1f%% size)",
                in.len(), cmp.len(),
                100.0 * ((cmp.len() as float) / (in.len() as float)));
-        fail_unless!((in == out));
+        assert!((in == out));
     }
 }
diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs
index 10abaf04912..d31f35b0115 100644
--- a/src/libcore/hash.rs
+++ b/src/libcore/hash.rs
@@ -456,7 +456,7 @@ pub fn test_siphash() {
         let vec = u8to64_le!(vecs[t], 0);
         let out = buf.hash_keyed(k0, k1);
         debug!("got %?, expected %?", out, vec);
-        fail_unless!(vec == out);
+        assert!(vec == out);
 
         stream_full.reset();
         stream_full.input(buf);
@@ -465,7 +465,7 @@ pub fn test_siphash() {
         let v = to_hex_str(&vecs[t]);
         debug!("%d: (%s) => inc=%s full=%s", t, v, i, f);
 
-        fail_unless!(f == i && f == v);
+        assert!(f == i && f == v);
 
         buf += ~[t as u8];
         stream_inc.input(~[t as u8]);
@@ -477,20 +477,20 @@ pub fn test_siphash() {
 #[test] #[cfg(target_arch = "arm")]
 pub fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    fail_unless!((val as u64).hash() != (val as uint).hash());
-    fail_unless!((val as u32).hash() == (val as uint).hash());
+    assert!((val as u64).hash() != (val as uint).hash());
+    assert!((val as u32).hash() == (val as uint).hash());
 }
 #[test] #[cfg(target_arch = "x86_64")]
 pub fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    fail_unless!((val as u64).hash() == (val as uint).hash());
-    fail_unless!((val as u32).hash() != (val as uint).hash());
+    assert!((val as u64).hash() == (val as uint).hash());
+    assert!((val as u32).hash() != (val as uint).hash());
 }
 #[test] #[cfg(target_arch = "x86")]
 pub fn test_hash_uint() {
     let val = 0xdeadbeef_deadbeef_u64;
-    fail_unless!((val as u64).hash() != (val as uint).hash());
-    fail_unless!((val as u32).hash() == (val as uint).hash());
+    assert!((val as u64).hash() != (val as uint).hash());
+    assert!((val as u32).hash() == (val as uint).hash());
 }
 
 #[test]
@@ -505,17 +505,17 @@ pub fn test_hash_idempotent() {
 pub fn test_hash_no_bytes_dropped_64() {
     let val = 0xdeadbeef_deadbeef_u64;
 
-    fail_unless!(val.hash() != zero_byte(val, 0).hash());
-    fail_unless!(val.hash() != zero_byte(val, 1).hash());
-    fail_unless!(val.hash() != zero_byte(val, 2).hash());
-    fail_unless!(val.hash() != zero_byte(val, 3).hash());
-    fail_unless!(val.hash() != zero_byte(val, 4).hash());
-    fail_unless!(val.hash() != zero_byte(val, 5).hash());
-    fail_unless!(val.hash() != zero_byte(val, 6).hash());
-    fail_unless!(val.hash() != zero_byte(val, 7).hash());
+    assert!(val.hash() != zero_byte(val, 0).hash());
+    assert!(val.hash() != zero_byte(val, 1).hash());
+    assert!(val.hash() != zero_byte(val, 2).hash());
+    assert!(val.hash() != zero_byte(val, 3).hash());
+    assert!(val.hash() != zero_byte(val, 4).hash());
+    assert!(val.hash() != zero_byte(val, 5).hash());
+    assert!(val.hash() != zero_byte(val, 6).hash());
+    assert!(val.hash() != zero_byte(val, 7).hash());
 
     fn zero_byte(val: u64, byte: uint) -> u64 {
-        fail_unless!(byte < 8);
+        assert!(byte < 8);
         val & !(0xff << (byte * 8))
     }
 }
@@ -524,13 +524,13 @@ pub fn test_hash_no_bytes_dropped_64() {
 pub fn test_hash_no_bytes_dropped_32() {
     let val = 0xdeadbeef_u32;
 
-    fail_unless!(val.hash() != zero_byte(val, 0).hash());
-    fail_unless!(val.hash() != zero_byte(val, 1).hash());
-    fail_unless!(val.hash() != zero_byte(val, 2).hash());
-    fail_unless!(val.hash() != zero_byte(val, 3).hash());
+    assert!(val.hash() != zero_byte(val, 0).hash());
+    assert!(val.hash() != zero_byte(val, 1).hash());
+    assert!(val.hash() != zero_byte(val, 2).hash());
+    assert!(val.hash() != zero_byte(val, 3).hash());
 
     fn zero_byte(val: u32, byte: uint) -> u32 {
-        fail_unless!(byte < 4);
+        assert!(byte < 4);
         val & !(0xff << (byte * 8))
     }
 }
diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs
index 93679e094d9..3df48ac70a2 100644
--- a/src/libcore/hashmap.rs
+++ b/src/libcore/hashmap.rs
@@ -676,18 +676,18 @@ pub mod linear {
         #[test]
         pub fn test_insert() {
             let mut m = LinearMap::new();
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(m.insert(2, 4));
-            fail_unless!(*m.get(&1) == 2);
-            fail_unless!(*m.get(&2) == 4);
+            assert!(m.insert(1, 2));
+            assert!(m.insert(2, 4));
+            assert!(*m.get(&1) == 2);
+            assert!(*m.get(&2) == 4);
         }
 
         #[test]
         fn test_find_mut() {
             let mut m = LinearMap::new();
-            fail_unless!(m.insert(1, 12));
-            fail_unless!(m.insert(2, 8));
-            fail_unless!(m.insert(5, 14));
+            assert!(m.insert(1, 12));
+            assert!(m.insert(2, 8));
+            assert!(m.insert(5, 14));
             let new = 100;
             match m.find_mut(&5) {
                 None => fail!(), Some(x) => *x = new
@@ -698,110 +698,110 @@ pub mod linear {
         #[test]
         pub fn test_insert_overwrite() {
             let mut m = LinearMap::new();
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(*m.get(&1) == 2);
-            fail_unless!(!m.insert(1, 3));
-            fail_unless!(*m.get(&1) == 3);
+            assert!(m.insert(1, 2));
+            assert!(*m.get(&1) == 2);
+            assert!(!m.insert(1, 3));
+            assert!(*m.get(&1) == 3);
         }
 
         #[test]
         pub fn test_insert_conflicts() {
             let mut m = linear::linear_map_with_capacity(4);
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(m.insert(5, 3));
-            fail_unless!(m.insert(9, 4));
-            fail_unless!(*m.get(&9) == 4);
-            fail_unless!(*m.get(&5) == 3);
-            fail_unless!(*m.get(&1) == 2);
+            assert!(m.insert(1, 2));
+            assert!(m.insert(5, 3));
+            assert!(m.insert(9, 4));
+            assert!(*m.get(&9) == 4);
+            assert!(*m.get(&5) == 3);
+            assert!(*m.get(&1) == 2);
         }
 
         #[test]
         pub fn test_conflict_remove() {
             let mut m = linear::linear_map_with_capacity(4);
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(m.insert(5, 3));
-            fail_unless!(m.insert(9, 4));
-            fail_unless!(m.remove(&1));
-            fail_unless!(*m.get(&9) == 4);
-            fail_unless!(*m.get(&5) == 3);
+            assert!(m.insert(1, 2));
+            assert!(m.insert(5, 3));
+            assert!(m.insert(9, 4));
+            assert!(m.remove(&1));
+            assert!(*m.get(&9) == 4);
+            assert!(*m.get(&5) == 3);
         }
 
         #[test]
         pub fn test_is_empty() {
             let mut m = linear::linear_map_with_capacity(4);
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(!m.is_empty());
-            fail_unless!(m.remove(&1));
-            fail_unless!(m.is_empty());
+            assert!(m.insert(1, 2));
+            assert!(!m.is_empty());
+            assert!(m.remove(&1));
+            assert!(m.is_empty());
         }
 
         #[test]
         pub fn test_pop() {
             let mut m = LinearMap::new();
             m.insert(1, 2);
-            fail_unless!(m.pop(&1) == Some(2));
-            fail_unless!(m.pop(&1) == None);
+            assert!(m.pop(&1) == Some(2));
+            assert!(m.pop(&1) == None);
         }
 
         #[test]
         pub fn test_swap() {
             let mut m = LinearMap::new();
-            fail_unless!(m.swap(1, 2) == None);
-            fail_unless!(m.swap(1, 3) == Some(2));
-            fail_unless!(m.swap(1, 4) == Some(3));
+            assert!(m.swap(1, 2) == None);
+            assert!(m.swap(1, 3) == Some(2));
+            assert!(m.swap(1, 4) == Some(3));
         }
 
         #[test]
         pub fn test_find_or_insert() {
             let mut m = LinearMap::new::<int, int>();
-            fail_unless!(m.find_or_insert(1, 2) == &2);
-            fail_unless!(m.find_or_insert(1, 3) == &2);
+            assert!(m.find_or_insert(1, 2) == &2);
+            assert!(m.find_or_insert(1, 3) == &2);
         }
 
         #[test]
         pub fn test_find_or_insert_with() {
             let mut m = LinearMap::new::<int, int>();
-            fail_unless!(m.find_or_insert_with(1, |_| 2) == &2);
-            fail_unless!(m.find_or_insert_with(1, |_| 3) == &2);
+            assert!(m.find_or_insert_with(1, |_| 2) == &2);
+            assert!(m.find_or_insert_with(1, |_| 3) == &2);
         }
 
         #[test]
         pub fn test_consume() {
             let mut m = LinearMap::new();
-            fail_unless!(m.insert(1, 2));
-            fail_unless!(m.insert(2, 3));
+            assert!(m.insert(1, 2));
+            assert!(m.insert(2, 3));
             let mut m2 = LinearMap::new();
             do m.consume |k, v| {
                 m2.insert(k, v);
             }
-            fail_unless!(m.len() == 0);
-            fail_unless!(m2.len() == 2);
-            fail_unless!(m2.get(&1) == &2);
-            fail_unless!(m2.get(&2) == &3);
+            assert!(m.len() == 0);
+            assert!(m2.len() == 2);
+            assert!(m2.get(&1) == &2);
+            assert!(m2.get(&2) == &3);
         }
 
         #[test]
         pub fn test_iterate() {
             let mut m = linear::linear_map_with_capacity(4);
             for uint::range(0, 32) |i| {
-                fail_unless!(m.insert(i, i*2));
+                assert!(m.insert(i, i*2));
             }
             let mut observed = 0;
             for m.each |&(k, v)| {
-                fail_unless!(*v == *k * 2);
+                assert!(*v == *k * 2);
                 observed |= (1 << *k);
             }
-            fail_unless!(observed == 0xFFFF_FFFF);
+            assert!(observed == 0xFFFF_FFFF);
         }
 
         #[test]
         pub fn test_find() {
             let mut m = LinearMap::new();
-            fail_unless!(m.find(&1).is_none());
+            assert!(m.find(&1).is_none());
             m.insert(1, 2);
             match m.find(&1) {
                 None => fail!(),
-                Some(v) => fail_unless!(*v == 2)
+                Some(v) => assert!(*v == 2)
             }
         }
 
@@ -816,19 +816,19 @@ pub mod linear {
             m2.insert(1, 2);
             m2.insert(2, 3);
 
-            fail_unless!(m1 != m2);
+            assert!(m1 != m2);
 
             m2.insert(3, 4);
 
-            fail_unless!(m1 == m2);
+            assert!(m1 == m2);
         }
 
         #[test]
         pub fn test_expand() {
             let mut m = LinearMap::new();
 
-            fail_unless!(m.len() == 0);
-            fail_unless!(m.is_empty());
+            assert!(m.len() == 0);
+            assert!(m.is_empty());
 
             let mut i = 0u;
             let old_resize_at = m.resize_at;
@@ -837,8 +837,8 @@ pub mod linear {
                 i += 1;
             }
 
-            fail_unless!(m.len() == i);
-            fail_unless!(!m.is_empty());
+            assert!(m.len() == i);
+            assert!(!m.is_empty());
         }
     }
 
@@ -852,51 +852,51 @@ pub mod linear {
         fn test_disjoint() {
             let mut xs = linear::LinearSet::new();
             let mut ys = linear::LinearSet::new();
-            fail_unless!(xs.is_disjoint(&ys));
-            fail_unless!(ys.is_disjoint(&xs));
-            fail_unless!(xs.insert(5));
-            fail_unless!(ys.insert(11));
-            fail_unless!(xs.is_disjoint(&ys));
-            fail_unless!(ys.is_disjoint(&xs));
-            fail_unless!(xs.insert(7));
-            fail_unless!(xs.insert(19));
-            fail_unless!(xs.insert(4));
-            fail_unless!(ys.insert(2));
-            fail_unless!(ys.insert(-11));
-            fail_unless!(xs.is_disjoint(&ys));
-            fail_unless!(ys.is_disjoint(&xs));
-            fail_unless!(ys.insert(7));
-            fail_unless!(!xs.is_disjoint(&ys));
-            fail_unless!(!ys.is_disjoint(&xs));
+            assert!(xs.is_disjoint(&ys));
+            assert!(ys.is_disjoint(&xs));
+            assert!(xs.insert(5));
+            assert!(ys.insert(11));
+            assert!(xs.is_disjoint(&ys));
+            assert!(ys.is_disjoint(&xs));
+            assert!(xs.insert(7));
+            assert!(xs.insert(19));
+            assert!(xs.insert(4));
+            assert!(ys.insert(2));
+            assert!(ys.insert(-11));
+            assert!(xs.is_disjoint(&ys));
+            assert!(ys.is_disjoint(&xs));
+            assert!(ys.insert(7));
+            assert!(!xs.is_disjoint(&ys));
+            assert!(!ys.is_disjoint(&xs));
         }
 
         #[test]
         fn test_subset_and_superset() {
             let mut a = linear::LinearSet::new();
-            fail_unless!(a.insert(0));
-            fail_unless!(a.insert(5));
-            fail_unless!(a.insert(11));
-            fail_unless!(a.insert(7));
+            assert!(a.insert(0));
+            assert!(a.insert(5));
+            assert!(a.insert(11));
+            assert!(a.insert(7));
 
             let mut b = linear::LinearSet::new();
-            fail_unless!(b.insert(0));
-            fail_unless!(b.insert(7));
-            fail_unless!(b.insert(19));
-            fail_unless!(b.insert(250));
-            fail_unless!(b.insert(11));
-            fail_unless!(b.insert(200));
+            assert!(b.insert(0));
+            assert!(b.insert(7));
+            assert!(b.insert(19));
+            assert!(b.insert(250));
+            assert!(b.insert(11));
+            assert!(b.insert(200));
 
-            fail_unless!(!a.is_subset(&b));
-            fail_unless!(!a.is_superset(&b));
-            fail_unless!(!b.is_subset(&a));
-            fail_unless!(!b.is_superset(&a));
+            assert!(!a.is_subset(&b));
+            assert!(!a.is_superset(&b));
+            assert!(!b.is_subset(&a));
+            assert!(!b.is_superset(&a));
 
-            fail_unless!(b.insert(5));
+            assert!(b.insert(5));
 
-            fail_unless!(a.is_subset(&b));
-            fail_unless!(!a.is_superset(&b));
-            fail_unless!(!b.is_subset(&a));
-            fail_unless!(b.is_superset(&a));
+            assert!(a.is_subset(&b));
+            assert!(!a.is_superset(&b));
+            assert!(!b.is_subset(&a));
+            assert!(b.is_superset(&a));
         }
 
         #[test]
@@ -904,29 +904,29 @@ pub mod linear {
             let mut a = linear::LinearSet::new();
             let mut b = linear::LinearSet::new();
 
-            fail_unless!(a.insert(11));
-            fail_unless!(a.insert(1));
-            fail_unless!(a.insert(3));
-            fail_unless!(a.insert(77));
-            fail_unless!(a.insert(103));
-            fail_unless!(a.insert(5));
-            fail_unless!(a.insert(-5));
-
-            fail_unless!(b.insert(2));
-            fail_unless!(b.insert(11));
-            fail_unless!(b.insert(77));
-            fail_unless!(b.insert(-9));
-            fail_unless!(b.insert(-42));
-            fail_unless!(b.insert(5));
-            fail_unless!(b.insert(3));
+            assert!(a.insert(11));
+            assert!(a.insert(1));
+            assert!(a.insert(3));
+            assert!(a.insert(77));
+            assert!(a.insert(103));
+            assert!(a.insert(5));
+            assert!(a.insert(-5));
+
+            assert!(b.insert(2));
+            assert!(b.insert(11));
+            assert!(b.insert(77));
+            assert!(b.insert(-9));
+            assert!(b.insert(-42));
+            assert!(b.insert(5));
+            assert!(b.insert(3));
 
             let mut i = 0;
             let expected = [3, 5, 11, 77];
             for a.intersection(&b) |x| {
-                fail_unless!(vec::contains(expected, x));
+                assert!(vec::contains(expected, x));
                 i += 1
             }
-            fail_unless!(i == expected.len());
+            assert!(i == expected.len());
         }
 
         #[test]
@@ -934,22 +934,22 @@ pub mod linear {
             let mut a = linear::LinearSet::new();
             let mut b = linear::LinearSet::new();
 
-            fail_unless!(a.insert(1));
-            fail_unless!(a.insert(3));
-            fail_unless!(a.insert(5));
-            fail_unless!(a.insert(9));
-            fail_unless!(a.insert(11));
+            assert!(a.insert(1));
+            assert!(a.insert(3));
+            assert!(a.insert(5));
+            assert!(a.insert(9));
+            assert!(a.insert(11));
 
-            fail_unless!(b.insert(3));
-            fail_unless!(b.insert(9));
+            assert!(b.insert(3));
+            assert!(b.insert(9));
 
             let mut i = 0;
             let expected = [1, 5, 11];
             for a.difference(&b) |x| {
-                fail_unless!(vec::contains(expected, x));
+                assert!(vec::contains(expected, x));
                 i += 1
             }
-            fail_unless!(i == expected.len());
+            assert!(i == expected.len());
         }
 
         #[test]
@@ -957,25 +957,25 @@ pub mod linear {
             let mut a = linear::LinearSet::new();
             let mut b = linear::LinearSet::new();
 
-            fail_unless!(a.insert(1));
-            fail_unless!(a.insert(3));
-            fail_unless!(a.insert(5));
-            fail_unless!(a.insert(9));
-            fail_unless!(a.insert(11));
+            assert!(a.insert(1));
+            assert!(a.insert(3));
+            assert!(a.insert(5));
+            assert!(a.insert(9));
+            assert!(a.insert(11));
 
-            fail_unless!(b.insert(-2));
-            fail_unless!(b.insert(3));
-            fail_unless!(b.insert(9));
-            fail_unless!(b.insert(14));
-            fail_unless!(b.insert(22));
+            assert!(b.insert(-2));
+            assert!(b.insert(3));
+            assert!(b.insert(9));
+            assert!(b.insert(14));
+            assert!(b.insert(22));
 
             let mut i = 0;
             let expected = [-2, 1, 5, 11, 14, 22];
             for a.symmetric_difference(&b) |x| {
-                fail_unless!(vec::contains(expected, x));
+                assert!(vec::contains(expected, x));
                 i += 1
             }
-            fail_unless!(i == expected.len());
+            assert!(i == expected.len());
         }
 
         #[test]
@@ -983,29 +983,29 @@ pub mod linear {
             let mut a = linear::LinearSet::new();
             let mut b = linear::LinearSet::new();
 
-            fail_unless!(a.insert(1));
-            fail_unless!(a.insert(3));
-            fail_unless!(a.insert(5));
-            fail_unless!(a.insert(9));
-            fail_unless!(a.insert(11));
-            fail_unless!(a.insert(16));
-            fail_unless!(a.insert(19));
-            fail_unless!(a.insert(24));
-
-            fail_unless!(b.insert(-2));
-            fail_unless!(b.insert(1));
-            fail_unless!(b.insert(5));
-            fail_unless!(b.insert(9));
-            fail_unless!(b.insert(13));
-            fail_unless!(b.insert(19));
+            assert!(a.insert(1));
+            assert!(a.insert(3));
+            assert!(a.insert(5));
+            assert!(a.insert(9));
+            assert!(a.insert(11));
+            assert!(a.insert(16));
+            assert!(a.insert(19));
+            assert!(a.insert(24));
+
+            assert!(b.insert(-2));
+            assert!(b.insert(1));
+            assert!(b.insert(5));
+            assert!(b.insert(9));
+            assert!(b.insert(13));
+            assert!(b.insert(19));
 
             let mut i = 0;
             let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24];
             for a.union(&b) |x| {
-                fail_unless!(vec::contains(expected, x));
+                assert!(vec::contains(expected, x));
                 i += 1
             }
-            fail_unless!(i == expected.len());
+            assert!(i == expected.len());
         }
     }
 }
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index aedbbd6e298..60a0ee4fa97 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -252,7 +252,7 @@ impl<T:Reader> ReaderUtil for T {
                 let w = str::utf8_char_width(b0);
                 let end = i + w;
                 i += 1;
-                fail_unless!((w > 0));
+                assert!((w > 0));
                 if w == 1 {
                     chars.push(b0 as char);
                     loop;
@@ -265,8 +265,8 @@ impl<T:Reader> ReaderUtil for T {
                 while i < end {
                     let next = bytes[i] as int;
                     i += 1;
-                    fail_unless!((next > -1));
-                    fail_unless!((next & 192 == 128));
+                    assert!((next > -1));
+                    assert!((next & 192 == 128));
                     val <<= 6;
                     val += (next & 63) as uint;
                 }
@@ -307,7 +307,7 @@ impl<T:Reader> ReaderUtil for T {
         if vec::len(c) == 0 {
             return -1 as char; // FIXME will this stay valid? // #2004
         }
-        fail_unless!((vec::len(c) == 1));
+        assert!((vec::len(c) == 1));
         return c[0];
     }
 
@@ -364,7 +364,7 @@ impl<T:Reader> ReaderUtil for T {
     // FIXME int reading methods need to deal with eof - issue #2004
 
     fn read_le_uint_n(&self, nbytes: uint) -> u64 {
-        fail_unless!(nbytes > 0 && nbytes <= 8);
+        assert!(nbytes > 0 && nbytes <= 8);
 
         let mut val = 0u64, pos = 0, i = nbytes;
         while i > 0 {
@@ -380,7 +380,7 @@ impl<T:Reader> ReaderUtil for T {
     }
 
     fn read_be_uint_n(&self, nbytes: uint) -> u64 {
-        fail_unless!(nbytes > 0 && nbytes <= 8);
+        assert!(nbytes > 0 && nbytes <= 8);
 
         let mut val = 0u64, i = nbytes;
         while i > 0 {
@@ -510,7 +510,7 @@ impl Reader for *libc::FILE {
     fn read(&self, bytes: &mut [u8], len: uint) -> uint {
         unsafe {
             do vec::as_mut_buf(bytes) |buf_p, buf_len| {
-                fail_unless!(buf_len >= len);
+                assert!(buf_len >= len);
 
                 let count = libc::fread(buf_p as *mut c_void, 1u as size_t,
                                         len as size_t, *self);
@@ -531,7 +531,7 @@ impl Reader for *libc::FILE {
     }
     fn seek(&self, offset: int, whence: SeekStyle) {
         unsafe {
-            fail_unless!(libc::fseek(*self,
+            assert!(libc::fseek(*self,
                                      offset as c_long,
                                      convert_whence(whence)) == 0 as c_int);
         }
@@ -717,7 +717,7 @@ impl Writer for *libc::FILE {
     }
     fn seek(&self, offset: int, whence: SeekStyle) {
         unsafe {
-            fail_unless!(libc::fseek(*self,
+            assert!(libc::fseek(*self,
                                      offset as c_long,
                                      convert_whence(whence)) == 0 as c_int);
         }
@@ -845,7 +845,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
 
 pub fn u64_to_le_bytes<T>(n: u64, size: uint,
                           f: &fn(v: &[u8]) -> T) -> T {
-    fail_unless!(size <= 8u);
+    assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
       2u => f(&[n as u8,
@@ -877,7 +877,7 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint,
 
 pub fn u64_to_be_bytes<T>(n: u64, size: uint,
                            f: &fn(v: &[u8]) -> T) -> T {
-    fail_unless!(size <= 8u);
+    assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
       2u => f(&[(n >> 8) as u8,
@@ -912,7 +912,7 @@ pub fn u64_from_be_bytes(data: &const [u8],
                          size: uint)
                       -> u64 {
     let mut sz = size;
-    fail_unless!((sz <= 8u));
+    assert!((sz <= 8u));
     let mut val = 0_u64;
     let mut pos = start;
     while sz > 0u {
@@ -1186,7 +1186,7 @@ pub fn with_str_writer(f: &fn(@Writer)) -> ~str {
         // Make sure the vector has a trailing null and is proper utf8.
         v.push(0);
     }
-    fail_unless!(str::is_utf8(v));
+    assert!(str::is_utf8(v));
 
     unsafe { ::cast::transmute(v) }
 }
@@ -1261,7 +1261,7 @@ pub mod fsync {
                 None => (),
                 Some(level) => {
                   // fail hard if not succesful
-                  fail_unless!(((self.arg.fsync_fn)(self.arg.val, level)
+                  assert!(((self.arg.fsync_fn)(self.arg.val, level)
                     != -1));
                 }
             }
@@ -1346,14 +1346,14 @@ mod tests {
         let inp: @io::Reader = result::get(&io::file_reader(tmpfile));
         let frood2: ~str = inp.read_c_str();
         debug!(copy frood2);
-        fail_unless!(frood == frood2);
+        assert!(frood == frood2);
     }
 
     #[test]
     fn test_readchars_empty() {
         do io::with_str_reader(~"") |inp| {
             let res : ~[char] = inp.read_chars(128);
-            fail_unless!((vec::len(res) == 0));
+            assert!((vec::len(res) == 0));
         }
     }
 
@@ -1361,22 +1361,22 @@ mod tests {
     fn test_read_line_utf8() {
         do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
             let line = inp.read_line();
-            fail_unless!(line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
+            assert!(line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
         }
     }
 
     #[test]
     fn test_read_lines() {
         do io::with_str_reader(~"a\nb\nc\n") |inp| {
-            fail_unless!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
+            assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
         }
 
         do io::with_str_reader(~"a\nb\nc") |inp| {
-            fail_unless!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
+            assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
         }
 
         do io::with_str_reader(~"") |inp| {
-            fail_unless!(inp.read_lines().is_empty());
+            assert!(inp.read_lines().is_empty());
         }
     }
 
@@ -1393,9 +1393,9 @@ mod tests {
             do io::with_str_reader(s) |inp| {
                 let res : ~[char] = inp.read_chars(len);
                 if (len <= vec::len(ivals)) {
-                    fail_unless!((vec::len(res) == len));
+                    assert!((vec::len(res) == len));
                 }
-                fail_unless!(vec::slice(ivals, 0u, vec::len(res)) ==
+                assert!(vec::slice(ivals, 0u, vec::len(res)) ==
                              vec::map(res, |x| *x as int));
             }
         }
@@ -1412,7 +1412,7 @@ mod tests {
     fn test_readchar() {
         do io::with_str_reader(~"生") |inp| {
             let res : char = inp.read_char();
-            fail_unless!((res as int == 29983));
+            assert!((res as int == 29983));
         }
     }
 
@@ -1420,7 +1420,7 @@ mod tests {
     fn test_readchar_empty() {
         do io::with_str_reader(~"") |inp| {
             let res : char = inp.read_char();
-            fail_unless!((res as int == -1));
+            assert!((res as int == -1));
         }
     }
 
@@ -1428,7 +1428,7 @@ mod tests {
     fn file_reader_not_exist() {
         match io::file_reader(&Path("not a file")) {
           result::Err(copy e) => {
-            fail_unless!(e == ~"error opening not a file");
+            assert!(e == ~"error opening not a file");
           }
           result::Ok(_) => fail!()
         }
@@ -1469,7 +1469,7 @@ mod tests {
     fn file_writer_bad_name() {
         match io::file_writer(&Path("?/?"), ~[]) {
           result::Err(copy e) => {
-            fail_unless!(str::starts_with(e, "error opening"));
+            assert!(str::starts_with(e, "error opening"));
           }
           result::Ok(_) => fail!()
         }
@@ -1479,7 +1479,7 @@ mod tests {
     fn buffered_file_writer_bad_name() {
         match io::buffered_file_writer(&Path("?/?")) {
           result::Err(copy e) => {
-            fail_unless!(str::starts_with(e, "error opening"));
+            assert!(str::starts_with(e, "error opening"));
           }
           result::Ok(_) => fail!()
         }
@@ -1489,15 +1489,15 @@ mod tests {
     fn bytes_buffer_overwrite() {
         let wr = BytesWriter();
         wr.write(~[0u8, 1u8, 2u8, 3u8]);
-        fail_unless!(wr.bytes == ~[0u8, 1u8, 2u8, 3u8]);
+        assert!(wr.bytes == ~[0u8, 1u8, 2u8, 3u8]);
         wr.seek(-2, SeekCur);
         wr.write(~[4u8, 5u8, 6u8, 7u8]);
-        fail_unless!(wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
+        assert!(wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
         wr.seek(-2, SeekEnd);
         wr.write(~[8u8]);
         wr.seek(1, SeekSet);
         wr.write(~[9u8]);
-        fail_unless!(wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
+        assert!(wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
     }
 
     #[test]
@@ -1517,7 +1517,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             for uints.each |i| {
-                fail_unless!(file.read_le_u64() == *i);
+                assert!(file.read_le_u64() == *i);
             }
         }
     }
@@ -1539,7 +1539,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             for uints.each |i| {
-                fail_unless!(file.read_be_u64() == *i);
+                assert!(file.read_be_u64() == *i);
             }
         }
     }
@@ -1563,7 +1563,7 @@ mod tests {
             for ints.each |i| {
                 // this tests that the sign extension is working
                 // (comparing the values as i32 would not test this)
-                fail_unless!(file.read_be_int_n(4) == *i as i64);
+                assert!(file.read_be_int_n(4) == *i as i64);
             }
         }
     }
@@ -1582,7 +1582,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             let f = file.read_be_f32();
-            fail_unless!(f == 8.1250);
+            assert!(f == 8.1250);
         }
     }
 
@@ -1599,8 +1599,8 @@ mod tests {
 
         {
             let file = io::file_reader(&path).get();
-            fail_unless!(file.read_be_f32() == 8.1250);
-            fail_unless!(file.read_le_f32() == 8.1250);
+            assert!(file.read_be_f32() == 8.1250);
+            assert!(file.read_le_f32() == 8.1250);
         }
     }
 }
diff --git a/src/libcore/managed.rs b/src/libcore/managed.rs
index 4de9f32e732..234b710d238 100644
--- a/src/libcore/managed.rs
+++ b/src/libcore/managed.rs
@@ -91,8 +91,8 @@ impl<T:Ord> Ord for @mut T {
 fn test() {
     let x = @3;
     let y = @3;
-    fail_unless!((ptr_eq::<int>(x, x)));
-    fail_unless!((ptr_eq::<int>(y, y)));
-    fail_unless!((!ptr_eq::<int>(x, y)));
-    fail_unless!((!ptr_eq::<int>(y, x)));
+    assert!((ptr_eq::<int>(x, x)));
+    assert!((ptr_eq::<int>(y, y)));
+    assert!((!ptr_eq::<int>(x, y)));
+    assert!((!ptr_eq::<int>(y, x)));
 }
diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs
index fc4e52891dd..e9639820e83 100644
--- a/src/libcore/mutable.rs
+++ b/src/libcore/mutable.rs
@@ -38,7 +38,7 @@ pub fn Mut<T>(t: T) -> Mut<T> {
 pub fn unwrap<T>(m: Mut<T>) -> T {
     // Borrowck should prevent us from calling unwrap while the value
     // is in use, as that would be a move from a borrowed value.
-    fail_unless!((m.mode as uint) == (ReadOnly as uint));
+    assert!((m.mode as uint) == (ReadOnly as uint));
     let Data {value: value, mode: _} = m;
     value
 }
@@ -103,9 +103,9 @@ pub fn test_const_in_mut() {
     let m = @Mut(1);
     do m.borrow_mut |p| {
         do m.borrow_const |q| {
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
             *p += 1;
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
         }
     }
 }
@@ -115,9 +115,9 @@ pub fn test_mut_in_const() {
     let m = @Mut(1);
     do m.borrow_const |p| {
         do m.borrow_mut |q| {
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
             *q += 1;
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
         }
     }
 }
@@ -127,7 +127,7 @@ pub fn test_imm_in_const() {
     let m = @Mut(1);
     do m.borrow_const |p| {
         do m.borrow_imm |q| {
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
         }
     }
 }
@@ -137,7 +137,7 @@ pub fn test_const_in_imm() {
     let m = @Mut(1);
     do m.borrow_imm |p| {
         do m.borrow_const |q| {
-            fail_unless!(*p == *q);
+            assert!(*p == *q);
         }
     }
 }
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 4a8649fb66e..6361a6a5cb7 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -585,56 +585,56 @@ pub fn test_num() {
     let ten: f32 = num::cast(10);
     let two: f32 = num::cast(2);
 
-    fail_unless!((ten.add(&two)    == num::cast(12)));
-    fail_unless!((ten.sub(&two)    == num::cast(8)));
-    fail_unless!((ten.mul(&two)    == num::cast(20)));
-    fail_unless!((ten.div(&two)    == num::cast(5)));
-    fail_unless!((ten.modulo(&two) == num::cast(0)));
+    assert!((ten.add(&two)    == num::cast(12)));
+    assert!((ten.sub(&two)    == num::cast(8)));
+    assert!((ten.mul(&two)    == num::cast(20)));
+    assert!((ten.div(&two)    == num::cast(5)));
+    assert!((ten.modulo(&two) == num::cast(0)));
 }
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u     == 20f32.to_uint()));
-    fail_unless!((20u8    == 20f32.to_u8()));
-    fail_unless!((20u16   == 20f32.to_u16()));
-    fail_unless!((20u32   == 20f32.to_u32()));
-    fail_unless!((20u64   == 20f32.to_u64()));
-    fail_unless!((20i     == 20f32.to_int()));
-    fail_unless!((20i8    == 20f32.to_i8()));
-    fail_unless!((20i16   == 20f32.to_i16()));
-    fail_unless!((20i32   == 20f32.to_i32()));
-    fail_unless!((20i64   == 20f32.to_i64()));
-    fail_unless!((20f     == 20f32.to_float()));
-    fail_unless!((20f32   == 20f32.to_f32()));
-    fail_unless!((20f64   == 20f32.to_f64()));
-
-    fail_unless!((20f32 == NumCast::from(20u)));
-    fail_unless!((20f32 == NumCast::from(20u8)));
-    fail_unless!((20f32 == NumCast::from(20u16)));
-    fail_unless!((20f32 == NumCast::from(20u32)));
-    fail_unless!((20f32 == NumCast::from(20u64)));
-    fail_unless!((20f32 == NumCast::from(20i)));
-    fail_unless!((20f32 == NumCast::from(20i8)));
-    fail_unless!((20f32 == NumCast::from(20i16)));
-    fail_unless!((20f32 == NumCast::from(20i32)));
-    fail_unless!((20f32 == NumCast::from(20i64)));
-    fail_unless!((20f32 == NumCast::from(20f)));
-    fail_unless!((20f32 == NumCast::from(20f32)));
-    fail_unless!((20f32 == NumCast::from(20f64)));
-
-    fail_unless!((20f32 == num::cast(20u)));
-    fail_unless!((20f32 == num::cast(20u8)));
-    fail_unless!((20f32 == num::cast(20u16)));
-    fail_unless!((20f32 == num::cast(20u32)));
-    fail_unless!((20f32 == num::cast(20u64)));
-    fail_unless!((20f32 == num::cast(20i)));
-    fail_unless!((20f32 == num::cast(20i8)));
-    fail_unless!((20f32 == num::cast(20i16)));
-    fail_unless!((20f32 == num::cast(20i32)));
-    fail_unless!((20f32 == num::cast(20i64)));
-    fail_unless!((20f32 == num::cast(20f)));
-    fail_unless!((20f32 == num::cast(20f32)));
-    fail_unless!((20f32 == num::cast(20f64)));
+    assert!((20u     == 20f32.to_uint()));
+    assert!((20u8    == 20f32.to_u8()));
+    assert!((20u16   == 20f32.to_u16()));
+    assert!((20u32   == 20f32.to_u32()));
+    assert!((20u64   == 20f32.to_u64()));
+    assert!((20i     == 20f32.to_int()));
+    assert!((20i8    == 20f32.to_i8()));
+    assert!((20i16   == 20f32.to_i16()));
+    assert!((20i32   == 20f32.to_i32()));
+    assert!((20i64   == 20f32.to_i64()));
+    assert!((20f     == 20f32.to_float()));
+    assert!((20f32   == 20f32.to_f32()));
+    assert!((20f64   == 20f32.to_f64()));
+
+    assert!((20f32 == NumCast::from(20u)));
+    assert!((20f32 == NumCast::from(20u8)));
+    assert!((20f32 == NumCast::from(20u16)));
+    assert!((20f32 == NumCast::from(20u32)));
+    assert!((20f32 == NumCast::from(20u64)));
+    assert!((20f32 == NumCast::from(20i)));
+    assert!((20f32 == NumCast::from(20i8)));
+    assert!((20f32 == NumCast::from(20i16)));
+    assert!((20f32 == NumCast::from(20i32)));
+    assert!((20f32 == NumCast::from(20i64)));
+    assert!((20f32 == NumCast::from(20f)));
+    assert!((20f32 == NumCast::from(20f32)));
+    assert!((20f32 == NumCast::from(20f64)));
+
+    assert!((20f32 == num::cast(20u)));
+    assert!((20f32 == num::cast(20u8)));
+    assert!((20f32 == num::cast(20u16)));
+    assert!((20f32 == num::cast(20u32)));
+    assert!((20f32 == num::cast(20u64)));
+    assert!((20f32 == num::cast(20i)));
+    assert!((20f32 == num::cast(20i8)));
+    assert!((20f32 == num::cast(20i16)));
+    assert!((20f32 == num::cast(20i32)));
+    assert!((20f32 == num::cast(20i64)));
+    assert!((20f32 == num::cast(20f)));
+    assert!((20f32 == num::cast(20f32)));
+    assert!((20f32 == num::cast(20f64)));
 }
 
 //
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index 8107110e977..9e731e61ec4 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -607,56 +607,56 @@ pub fn test_num() {
     let ten: f64 = num::cast(10);
     let two: f64 = num::cast(2);
 
-    fail_unless!((ten.add(&two)    == num::cast(12)));
-    fail_unless!((ten.sub(&two)    == num::cast(8)));
-    fail_unless!((ten.mul(&two)    == num::cast(20)));
-    fail_unless!((ten.div(&two)    == num::cast(5)));
-    fail_unless!((ten.modulo(&two) == num::cast(0)));
+    assert!((ten.add(&two)    == num::cast(12)));
+    assert!((ten.sub(&two)    == num::cast(8)));
+    assert!((ten.mul(&two)    == num::cast(20)));
+    assert!((ten.div(&two)    == num::cast(5)));
+    assert!((ten.modulo(&two) == num::cast(0)));
 }
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20f64.to_uint()));
-    fail_unless!((20u8  == 20f64.to_u8()));
-    fail_unless!((20u16 == 20f64.to_u16()));
-    fail_unless!((20u32 == 20f64.to_u32()));
-    fail_unless!((20u64 == 20f64.to_u64()));
-    fail_unless!((20i   == 20f64.to_int()));
-    fail_unless!((20i8  == 20f64.to_i8()));
-    fail_unless!((20i16 == 20f64.to_i16()));
-    fail_unless!((20i32 == 20f64.to_i32()));
-    fail_unless!((20i64 == 20f64.to_i64()));
-    fail_unless!((20f   == 20f64.to_float()));
-    fail_unless!((20f32 == 20f64.to_f32()));
-    fail_unless!((20f64 == 20f64.to_f64()));
-
-    fail_unless!((20f64 == NumCast::from(20u)));
-    fail_unless!((20f64 == NumCast::from(20u8)));
-    fail_unless!((20f64 == NumCast::from(20u16)));
-    fail_unless!((20f64 == NumCast::from(20u32)));
-    fail_unless!((20f64 == NumCast::from(20u64)));
-    fail_unless!((20f64 == NumCast::from(20i)));
-    fail_unless!((20f64 == NumCast::from(20i8)));
-    fail_unless!((20f64 == NumCast::from(20i16)));
-    fail_unless!((20f64 == NumCast::from(20i32)));
-    fail_unless!((20f64 == NumCast::from(20i64)));
-    fail_unless!((20f64 == NumCast::from(20f)));
-    fail_unless!((20f64 == NumCast::from(20f32)));
-    fail_unless!((20f64 == NumCast::from(20f64)));
-
-    fail_unless!((20f64 == num::cast(20u)));
-    fail_unless!((20f64 == num::cast(20u8)));
-    fail_unless!((20f64 == num::cast(20u16)));
-    fail_unless!((20f64 == num::cast(20u32)));
-    fail_unless!((20f64 == num::cast(20u64)));
-    fail_unless!((20f64 == num::cast(20i)));
-    fail_unless!((20f64 == num::cast(20i8)));
-    fail_unless!((20f64 == num::cast(20i16)));
-    fail_unless!((20f64 == num::cast(20i32)));
-    fail_unless!((20f64 == num::cast(20i64)));
-    fail_unless!((20f64 == num::cast(20f)));
-    fail_unless!((20f64 == num::cast(20f32)));
-    fail_unless!((20f64 == num::cast(20f64)));
+    assert!((20u   == 20f64.to_uint()));
+    assert!((20u8  == 20f64.to_u8()));
+    assert!((20u16 == 20f64.to_u16()));
+    assert!((20u32 == 20f64.to_u32()));
+    assert!((20u64 == 20f64.to_u64()));
+    assert!((20i   == 20f64.to_int()));
+    assert!((20i8  == 20f64.to_i8()));
+    assert!((20i16 == 20f64.to_i16()));
+    assert!((20i32 == 20f64.to_i32()));
+    assert!((20i64 == 20f64.to_i64()));
+    assert!((20f   == 20f64.to_float()));
+    assert!((20f32 == 20f64.to_f32()));
+    assert!((20f64 == 20f64.to_f64()));
+
+    assert!((20f64 == NumCast::from(20u)));
+    assert!((20f64 == NumCast::from(20u8)));
+    assert!((20f64 == NumCast::from(20u16)));
+    assert!((20f64 == NumCast::from(20u32)));
+    assert!((20f64 == NumCast::from(20u64)));
+    assert!((20f64 == NumCast::from(20i)));
+    assert!((20f64 == NumCast::from(20i8)));
+    assert!((20f64 == NumCast::from(20i16)));
+    assert!((20f64 == NumCast::from(20i32)));
+    assert!((20f64 == NumCast::from(20i64)));
+    assert!((20f64 == NumCast::from(20f)));
+    assert!((20f64 == NumCast::from(20f32)));
+    assert!((20f64 == NumCast::from(20f64)));
+
+    assert!((20f64 == num::cast(20u)));
+    assert!((20f64 == num::cast(20u8)));
+    assert!((20f64 == num::cast(20u16)));
+    assert!((20f64 == num::cast(20u32)));
+    assert!((20f64 == num::cast(20u64)));
+    assert!((20f64 == num::cast(20i)));
+    assert!((20f64 == num::cast(20i8)));
+    assert!((20f64 == num::cast(20i16)));
+    assert!((20f64 == num::cast(20i32)));
+    assert!((20f64 == num::cast(20i64)));
+    assert!((20f64 == num::cast(20f)));
+    assert!((20f64 == num::cast(20f32)));
+    assert!((20f64 == num::cast(20f64)));
 }
 
 //
diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs
index 0aec9f08cb4..c80d52f496b 100644
--- a/src/libcore/num/float.rs
+++ b/src/libcore/num/float.rs
@@ -181,7 +181,7 @@ pub fn to_str_exact(num: float, digits: uint) -> ~str {
 #[test]
 pub fn test_to_str_exact_do_decimal() {
     let s = to_str_exact(5.0, 4u);
-    fail_unless!(s == ~"5.0000");
+    assert!(s == ~"5.0000");
 }
 
 /**
@@ -501,191 +501,191 @@ impl ops::Neg<float> for float {
 
 #[test]
 pub fn test_from_str() {
-   fail_unless!(from_str(~"3") == Some(3.));
-   fail_unless!(from_str(~"3.14") == Some(3.14));
-   fail_unless!(from_str(~"+3.14") == Some(3.14));
-   fail_unless!(from_str(~"-3.14") == Some(-3.14));
-   fail_unless!(from_str(~"2.5E10") == Some(25000000000.));
-   fail_unless!(from_str(~"2.5e10") == Some(25000000000.));
-   fail_unless!(from_str(~"25000000000.E-10") == Some(2.5));
-   fail_unless!(from_str(~".") == Some(0.));
-   fail_unless!(from_str(~".e1") == Some(0.));
-   fail_unless!(from_str(~".e-1") == Some(0.));
-   fail_unless!(from_str(~"5.") == Some(5.));
-   fail_unless!(from_str(~".5") == Some(0.5));
-   fail_unless!(from_str(~"0.5") == Some(0.5));
-   fail_unless!(from_str(~"-.5") == Some(-0.5));
-   fail_unless!(from_str(~"-5") == Some(-5.));
-   fail_unless!(from_str(~"inf") == Some(infinity));
-   fail_unless!(from_str(~"+inf") == Some(infinity));
-   fail_unless!(from_str(~"-inf") == Some(neg_infinity));
+   assert!(from_str(~"3") == Some(3.));
+   assert!(from_str(~"3.14") == Some(3.14));
+   assert!(from_str(~"+3.14") == Some(3.14));
+   assert!(from_str(~"-3.14") == Some(-3.14));
+   assert!(from_str(~"2.5E10") == Some(25000000000.));
+   assert!(from_str(~"2.5e10") == Some(25000000000.));
+   assert!(from_str(~"25000000000.E-10") == Some(2.5));
+   assert!(from_str(~".") == Some(0.));
+   assert!(from_str(~".e1") == Some(0.));
+   assert!(from_str(~".e-1") == Some(0.));
+   assert!(from_str(~"5.") == Some(5.));
+   assert!(from_str(~".5") == Some(0.5));
+   assert!(from_str(~"0.5") == Some(0.5));
+   assert!(from_str(~"-.5") == Some(-0.5));
+   assert!(from_str(~"-5") == Some(-5.));
+   assert!(from_str(~"inf") == Some(infinity));
+   assert!(from_str(~"+inf") == Some(infinity));
+   assert!(from_str(~"-inf") == Some(neg_infinity));
    // note: NaN != NaN, hence this slightly complex test
    match from_str(~"NaN") {
-       Some(f) => fail_unless!(is_NaN(f)),
+       Some(f) => assert!(is_NaN(f)),
        None => fail!()
    }
    // note: -0 == 0, hence these slightly more complex tests
    match from_str(~"-0") {
-       Some(v) if is_zero(v) => fail_unless!(is_negative(v)),
+       Some(v) if is_zero(v) => assert!(is_negative(v)),
        _ => fail!()
    }
    match from_str(~"0") {
-       Some(v) if is_zero(v) => fail_unless!(is_positive(v)),
+       Some(v) if is_zero(v) => assert!(is_positive(v)),
        _ => fail!()
    }
 
-   fail_unless!(from_str(~"").is_none());
-   fail_unless!(from_str(~"x").is_none());
-   fail_unless!(from_str(~" ").is_none());
-   fail_unless!(from_str(~"   ").is_none());
-   fail_unless!(from_str(~"e").is_none());
-   fail_unless!(from_str(~"E").is_none());
-   fail_unless!(from_str(~"E1").is_none());
-   fail_unless!(from_str(~"1e1e1").is_none());
-   fail_unless!(from_str(~"1e1.1").is_none());
-   fail_unless!(from_str(~"1e1-1").is_none());
+   assert!(from_str(~"").is_none());
+   assert!(from_str(~"x").is_none());
+   assert!(from_str(~" ").is_none());
+   assert!(from_str(~"   ").is_none());
+   assert!(from_str(~"e").is_none());
+   assert!(from_str(~"E").is_none());
+   assert!(from_str(~"E1").is_none());
+   assert!(from_str(~"1e1e1").is_none());
+   assert!(from_str(~"1e1.1").is_none());
+   assert!(from_str(~"1e1-1").is_none());
 }
 
 #[test]
 pub fn test_from_str_hex() {
-   fail_unless!(from_str_hex(~"a4") == Some(164.));
-   fail_unless!(from_str_hex(~"a4.fe") == Some(164.9921875));
-   fail_unless!(from_str_hex(~"-a4.fe") == Some(-164.9921875));
-   fail_unless!(from_str_hex(~"+a4.fe") == Some(164.9921875));
-   fail_unless!(from_str_hex(~"ff0P4") == Some(0xff00 as float));
-   fail_unless!(from_str_hex(~"ff0p4") == Some(0xff00 as float));
-   fail_unless!(from_str_hex(~"ff0p-4") == Some(0xff as float));
-   fail_unless!(from_str_hex(~".") == Some(0.));
-   fail_unless!(from_str_hex(~".p1") == Some(0.));
-   fail_unless!(from_str_hex(~".p-1") == Some(0.));
-   fail_unless!(from_str_hex(~"f.") == Some(15.));
-   fail_unless!(from_str_hex(~".f") == Some(0.9375));
-   fail_unless!(from_str_hex(~"0.f") == Some(0.9375));
-   fail_unless!(from_str_hex(~"-.f") == Some(-0.9375));
-   fail_unless!(from_str_hex(~"-f") == Some(-15.));
-   fail_unless!(from_str_hex(~"inf") == Some(infinity));
-   fail_unless!(from_str_hex(~"+inf") == Some(infinity));
-   fail_unless!(from_str_hex(~"-inf") == Some(neg_infinity));
+   assert!(from_str_hex(~"a4") == Some(164.));
+   assert!(from_str_hex(~"a4.fe") == Some(164.9921875));
+   assert!(from_str_hex(~"-a4.fe") == Some(-164.9921875));
+   assert!(from_str_hex(~"+a4.fe") == Some(164.9921875));
+   assert!(from_str_hex(~"ff0P4") == Some(0xff00 as float));
+   assert!(from_str_hex(~"ff0p4") == Some(0xff00 as float));
+   assert!(from_str_hex(~"ff0p-4") == Some(0xff as float));
+   assert!(from_str_hex(~".") == Some(0.));
+   assert!(from_str_hex(~".p1") == Some(0.));
+   assert!(from_str_hex(~".p-1") == Some(0.));
+   assert!(from_str_hex(~"f.") == Some(15.));
+   assert!(from_str_hex(~".f") == Some(0.9375));
+   assert!(from_str_hex(~"0.f") == Some(0.9375));
+   assert!(from_str_hex(~"-.f") == Some(-0.9375));
+   assert!(from_str_hex(~"-f") == Some(-15.));
+   assert!(from_str_hex(~"inf") == Some(infinity));
+   assert!(from_str_hex(~"+inf") == Some(infinity));
+   assert!(from_str_hex(~"-inf") == Some(neg_infinity));
    // note: NaN != NaN, hence this slightly complex test
    match from_str_hex(~"NaN") {
-       Some(f) => fail_unless!(is_NaN(f)),
+       Some(f) => assert!(is_NaN(f)),
        None => fail!()
    }
    // note: -0 == 0, hence these slightly more complex tests
    match from_str_hex(~"-0") {
-       Some(v) if is_zero(v) => fail_unless!(is_negative(v)),
+       Some(v) if is_zero(v) => assert!(is_negative(v)),
        _ => fail!()
    }
    match from_str_hex(~"0") {
-       Some(v) if is_zero(v) => fail_unless!(is_positive(v)),
+       Some(v) if is_zero(v) => assert!(is_positive(v)),
        _ => fail!()
    }
-   fail_unless!(from_str_hex(~"e") == Some(14.));
-   fail_unless!(from_str_hex(~"E") == Some(14.));
-   fail_unless!(from_str_hex(~"E1") == Some(225.));
-   fail_unless!(from_str_hex(~"1e1e1") == Some(123361.));
-   fail_unless!(from_str_hex(~"1e1.1") == Some(481.0625));
-
-   fail_unless!(from_str_hex(~"").is_none());
-   fail_unless!(from_str_hex(~"x").is_none());
-   fail_unless!(from_str_hex(~" ").is_none());
-   fail_unless!(from_str_hex(~"   ").is_none());
-   fail_unless!(from_str_hex(~"p").is_none());
-   fail_unless!(from_str_hex(~"P").is_none());
-   fail_unless!(from_str_hex(~"P1").is_none());
-   fail_unless!(from_str_hex(~"1p1p1").is_none());
-   fail_unless!(from_str_hex(~"1p1.1").is_none());
-   fail_unless!(from_str_hex(~"1p1-1").is_none());
+   assert!(from_str_hex(~"e") == Some(14.));
+   assert!(from_str_hex(~"E") == Some(14.));
+   assert!(from_str_hex(~"E1") == Some(225.));
+   assert!(from_str_hex(~"1e1e1") == Some(123361.));
+   assert!(from_str_hex(~"1e1.1") == Some(481.0625));
+
+   assert!(from_str_hex(~"").is_none());
+   assert!(from_str_hex(~"x").is_none());
+   assert!(from_str_hex(~" ").is_none());
+   assert!(from_str_hex(~"   ").is_none());
+   assert!(from_str_hex(~"p").is_none());
+   assert!(from_str_hex(~"P").is_none());
+   assert!(from_str_hex(~"P1").is_none());
+   assert!(from_str_hex(~"1p1p1").is_none());
+   assert!(from_str_hex(~"1p1.1").is_none());
+   assert!(from_str_hex(~"1p1-1").is_none());
 }
 
 #[test]
 pub fn test_to_str_hex() {
-   fail_unless!(to_str_hex(164.) == ~"a4");
-   fail_unless!(to_str_hex(164.9921875) == ~"a4.fe");
-   fail_unless!(to_str_hex(-164.9921875) == ~"-a4.fe");
-   fail_unless!(to_str_hex(0xff00 as float) == ~"ff00");
-   fail_unless!(to_str_hex(-(0xff00 as float)) == ~"-ff00");
-   fail_unless!(to_str_hex(0.) == ~"0");
-   fail_unless!(to_str_hex(15.) == ~"f");
-   fail_unless!(to_str_hex(-15.) == ~"-f");
-   fail_unless!(to_str_hex(0.9375) == ~"0.f");
-   fail_unless!(to_str_hex(-0.9375) == ~"-0.f");
-   fail_unless!(to_str_hex(infinity) == ~"inf");
-   fail_unless!(to_str_hex(neg_infinity) == ~"-inf");
-   fail_unless!(to_str_hex(NaN) == ~"NaN");
-   fail_unless!(to_str_hex(0.) == ~"0");
-   fail_unless!(to_str_hex(-0.) == ~"-0");
+   assert!(to_str_hex(164.) == ~"a4");
+   assert!(to_str_hex(164.9921875) == ~"a4.fe");
+   assert!(to_str_hex(-164.9921875) == ~"-a4.fe");
+   assert!(to_str_hex(0xff00 as float) == ~"ff00");
+   assert!(to_str_hex(-(0xff00 as float)) == ~"-ff00");
+   assert!(to_str_hex(0.) == ~"0");
+   assert!(to_str_hex(15.) == ~"f");
+   assert!(to_str_hex(-15.) == ~"-f");
+   assert!(to_str_hex(0.9375) == ~"0.f");
+   assert!(to_str_hex(-0.9375) == ~"-0.f");
+   assert!(to_str_hex(infinity) == ~"inf");
+   assert!(to_str_hex(neg_infinity) == ~"-inf");
+   assert!(to_str_hex(NaN) == ~"NaN");
+   assert!(to_str_hex(0.) == ~"0");
+   assert!(to_str_hex(-0.) == ~"-0");
 }
 
 #[test]
 pub fn test_to_str_radix() {
-   fail_unless!(to_str_radix(36., 36u) == ~"10");
-   fail_unless!(to_str_radix(8.125, 2u) == ~"1000.001");
+   assert!(to_str_radix(36., 36u) == ~"10");
+   assert!(to_str_radix(8.125, 2u) == ~"1000.001");
 }
 
 #[test]
 pub fn test_from_str_radix() {
-   fail_unless!(from_str_radix(~"10", 36u) == Some(36.));
-   fail_unless!(from_str_radix(~"1000.001", 2u) == Some(8.125));
+   assert!(from_str_radix(~"10", 36u) == Some(36.));
+   assert!(from_str_radix(~"1000.001", 2u) == Some(8.125));
 }
 
 #[test]
 pub fn test_positive() {
-  fail_unless!((is_positive(infinity)));
-  fail_unless!((is_positive(1.)));
-  fail_unless!((is_positive(0.)));
-  fail_unless!((!is_positive(-1.)));
-  fail_unless!((!is_positive(neg_infinity)));
-  fail_unless!((!is_positive(1./neg_infinity)));
-  fail_unless!((!is_positive(NaN)));
+  assert!((is_positive(infinity)));
+  assert!((is_positive(1.)));
+  assert!((is_positive(0.)));
+  assert!((!is_positive(-1.)));
+  assert!((!is_positive(neg_infinity)));
+  assert!((!is_positive(1./neg_infinity)));
+  assert!((!is_positive(NaN)));
 }
 
 #[test]
 pub fn test_negative() {
-  fail_unless!((!is_negative(infinity)));
-  fail_unless!((!is_negative(1.)));
-  fail_unless!((!is_negative(0.)));
-  fail_unless!((is_negative(-1.)));
-  fail_unless!((is_negative(neg_infinity)));
-  fail_unless!((is_negative(1./neg_infinity)));
-  fail_unless!((!is_negative(NaN)));
+  assert!((!is_negative(infinity)));
+  assert!((!is_negative(1.)));
+  assert!((!is_negative(0.)));
+  assert!((is_negative(-1.)));
+  assert!((is_negative(neg_infinity)));
+  assert!((is_negative(1./neg_infinity)));
+  assert!((!is_negative(NaN)));
 }
 
 #[test]
 pub fn test_nonpositive() {
-  fail_unless!((!is_nonpositive(infinity)));
-  fail_unless!((!is_nonpositive(1.)));
-  fail_unless!((!is_nonpositive(0.)));
-  fail_unless!((is_nonpositive(-1.)));
-  fail_unless!((is_nonpositive(neg_infinity)));
-  fail_unless!((is_nonpositive(1./neg_infinity)));
-  fail_unless!((!is_nonpositive(NaN)));
+  assert!((!is_nonpositive(infinity)));
+  assert!((!is_nonpositive(1.)));
+  assert!((!is_nonpositive(0.)));
+  assert!((is_nonpositive(-1.)));
+  assert!((is_nonpositive(neg_infinity)));
+  assert!((is_nonpositive(1./neg_infinity)));
+  assert!((!is_nonpositive(NaN)));
 }
 
 #[test]
 pub fn test_nonnegative() {
-  fail_unless!((is_nonnegative(infinity)));
-  fail_unless!((is_nonnegative(1.)));
-  fail_unless!((is_nonnegative(0.)));
-  fail_unless!((!is_nonnegative(-1.)));
-  fail_unless!((!is_nonnegative(neg_infinity)));
-  fail_unless!((!is_nonnegative(1./neg_infinity)));
-  fail_unless!((!is_nonnegative(NaN)));
+  assert!((is_nonnegative(infinity)));
+  assert!((is_nonnegative(1.)));
+  assert!((is_nonnegative(0.)));
+  assert!((!is_nonnegative(-1.)));
+  assert!((!is_nonnegative(neg_infinity)));
+  assert!((!is_nonnegative(1./neg_infinity)));
+  assert!((!is_nonnegative(NaN)));
 }
 
 #[test]
 pub fn test_to_str_inf() {
-    fail_unless!(to_str_digits(infinity, 10u) == ~"inf");
-    fail_unless!(to_str_digits(-infinity, 10u) == ~"-inf");
+    assert!(to_str_digits(infinity, 10u) == ~"inf");
+    assert!(to_str_digits(-infinity, 10u) == ~"-inf");
 }
 
 #[test]
 pub fn test_round() {
-    fail_unless!(round(5.8) == 6.0);
-    fail_unless!(round(5.2) == 5.0);
-    fail_unless!(round(3.0) == 3.0);
-    fail_unless!(round(2.5) == 3.0);
-    fail_unless!(round(-3.5) == -4.0);
+    assert!(round(5.8) == 6.0);
+    assert!(round(5.2) == 5.0);
+    assert!(round(3.0) == 3.0);
+    assert!(round(2.5) == 3.0);
+    assert!(round(-3.5) == -4.0);
 }
 
 #[test]
@@ -693,56 +693,56 @@ pub fn test_num() {
     let ten: float = num::cast(10);
     let two: float = num::cast(2);
 
-    fail_unless!((ten.add(&two)    == num::cast(12)));
-    fail_unless!((ten.sub(&two)    == num::cast(8)));
-    fail_unless!((ten.mul(&two)    == num::cast(20)));
-    fail_unless!((ten.div(&two)    == num::cast(5)));
-    fail_unless!((ten.modulo(&two) == num::cast(0)));
+    assert!((ten.add(&two)    == num::cast(12)));
+    assert!((ten.sub(&two)    == num::cast(8)));
+    assert!((ten.mul(&two)    == num::cast(20)));
+    assert!((ten.div(&two)    == num::cast(5)));
+    assert!((ten.modulo(&two) == num::cast(0)));
 }
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20f.to_uint()));
-    fail_unless!((20u8  == 20f.to_u8()));
-    fail_unless!((20u16 == 20f.to_u16()));
-    fail_unless!((20u32 == 20f.to_u32()));
-    fail_unless!((20u64 == 20f.to_u64()));
-    fail_unless!((20i   == 20f.to_int()));
-    fail_unless!((20i8  == 20f.to_i8()));
-    fail_unless!((20i16 == 20f.to_i16()));
-    fail_unless!((20i32 == 20f.to_i32()));
-    fail_unless!((20i64 == 20f.to_i64()));
-    fail_unless!((20f   == 20f.to_float()));
-    fail_unless!((20f32 == 20f.to_f32()));
-    fail_unless!((20f64 == 20f.to_f64()));
-
-    fail_unless!((20f == NumCast::from(20u)));
-    fail_unless!((20f == NumCast::from(20u8)));
-    fail_unless!((20f == NumCast::from(20u16)));
-    fail_unless!((20f == NumCast::from(20u32)));
-    fail_unless!((20f == NumCast::from(20u64)));
-    fail_unless!((20f == NumCast::from(20i)));
-    fail_unless!((20f == NumCast::from(20i8)));
-    fail_unless!((20f == NumCast::from(20i16)));
-    fail_unless!((20f == NumCast::from(20i32)));
-    fail_unless!((20f == NumCast::from(20i64)));
-    fail_unless!((20f == NumCast::from(20f)));
-    fail_unless!((20f == NumCast::from(20f32)));
-    fail_unless!((20f == NumCast::from(20f64)));
-
-    fail_unless!((20f == num::cast(20u)));
-    fail_unless!((20f == num::cast(20u8)));
-    fail_unless!((20f == num::cast(20u16)));
-    fail_unless!((20f == num::cast(20u32)));
-    fail_unless!((20f == num::cast(20u64)));
-    fail_unless!((20f == num::cast(20i)));
-    fail_unless!((20f == num::cast(20i8)));
-    fail_unless!((20f == num::cast(20i16)));
-    fail_unless!((20f == num::cast(20i32)));
-    fail_unless!((20f == num::cast(20i64)));
-    fail_unless!((20f == num::cast(20f)));
-    fail_unless!((20f == num::cast(20f32)));
-    fail_unless!((20f == num::cast(20f64)));
+    assert!((20u   == 20f.to_uint()));
+    assert!((20u8  == 20f.to_u8()));
+    assert!((20u16 == 20f.to_u16()));
+    assert!((20u32 == 20f.to_u32()));
+    assert!((20u64 == 20f.to_u64()));
+    assert!((20i   == 20f.to_int()));
+    assert!((20i8  == 20f.to_i8()));
+    assert!((20i16 == 20f.to_i16()));
+    assert!((20i32 == 20f.to_i32()));
+    assert!((20i64 == 20f.to_i64()));
+    assert!((20f   == 20f.to_float()));
+    assert!((20f32 == 20f.to_f32()));
+    assert!((20f64 == 20f.to_f64()));
+
+    assert!((20f == NumCast::from(20u)));
+    assert!((20f == NumCast::from(20u8)));
+    assert!((20f == NumCast::from(20u16)));
+    assert!((20f == NumCast::from(20u32)));
+    assert!((20f == NumCast::from(20u64)));
+    assert!((20f == NumCast::from(20i)));
+    assert!((20f == NumCast::from(20i8)));
+    assert!((20f == NumCast::from(20i16)));
+    assert!((20f == NumCast::from(20i32)));
+    assert!((20f == NumCast::from(20i64)));
+    assert!((20f == NumCast::from(20f)));
+    assert!((20f == NumCast::from(20f32)));
+    assert!((20f == NumCast::from(20f64)));
+
+    assert!((20f == num::cast(20u)));
+    assert!((20f == num::cast(20u8)));
+    assert!((20f == num::cast(20u16)));
+    assert!((20f == num::cast(20u32)));
+    assert!((20f == num::cast(20u64)));
+    assert!((20f == num::cast(20i)));
+    assert!((20f == num::cast(20i8)));
+    assert!((20f == num::cast(20i16)));
+    assert!((20f == num::cast(20i32)));
+    assert!((20f == num::cast(20i64)));
+    assert!((20f == num::cast(20f)));
+    assert!((20f == num::cast(20f32)));
+    assert!((20f == num::cast(20f64)));
 }
 
 
diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs
index af56d3e6305..a3cbd9fe7e3 100644
--- a/src/libcore/num/int-template.rs
+++ b/src/libcore/num/int-template.rs
@@ -41,18 +41,18 @@ pub fn div(x: T, y: T) -> T { x / y }
  *
  * # Examples
  * ~~~
- * fail_unless!(int::rem(5 / 2) == 1);
+ * assert!(int::rem(5 / 2) == 1);
  * ~~~
  *
  * When faced with negative numbers, the result copies the sign of the
  * dividend.
  *
  * ~~~
- * fail_unless!(int::rem(2 / -3) ==  2);
+ * assert!(int::rem(2 / -3) ==  2);
  * ~~~
  *
  * ~~~
- * fail_unless!(int::rem(-2 / 3) ==  -2);
+ * assert!(int::rem(-2 / 3) ==  -2);
  * ~~~
  *
  */
@@ -95,7 +95,7 @@ pub fn is_nonnegative(x: T) -> bool { x >= 0 as T }
  * for int::range(1, 5) |i| {
  *     sum += i;
  * }
- * fail_unless!(sum == 10);
+ * assert!(sum == 10);
  * ~~~
  */
 #[inline(always)]
@@ -275,122 +275,122 @@ impl ToStrRadix for T {
 
 #[test]
 fn test_from_str() {
-    fail_unless!(from_str(~"0") == Some(0 as T));
-    fail_unless!(from_str(~"3") == Some(3 as T));
-    fail_unless!(from_str(~"10") == Some(10 as T));
-    fail_unless!(i32::from_str(~"123456789") == Some(123456789 as i32));
-    fail_unless!(from_str(~"00100") == Some(100 as T));
+    assert!(from_str(~"0") == Some(0 as T));
+    assert!(from_str(~"3") == Some(3 as T));
+    assert!(from_str(~"10") == Some(10 as T));
+    assert!(i32::from_str(~"123456789") == Some(123456789 as i32));
+    assert!(from_str(~"00100") == Some(100 as T));
 
-    fail_unless!(from_str(~"-1") == Some(-1 as T));
-    fail_unless!(from_str(~"-3") == Some(-3 as T));
-    fail_unless!(from_str(~"-10") == Some(-10 as T));
-    fail_unless!(i32::from_str(~"-123456789") == Some(-123456789 as i32));
-    fail_unless!(from_str(~"-00100") == Some(-100 as T));
+    assert!(from_str(~"-1") == Some(-1 as T));
+    assert!(from_str(~"-3") == Some(-3 as T));
+    assert!(from_str(~"-10") == Some(-10 as T));
+    assert!(i32::from_str(~"-123456789") == Some(-123456789 as i32));
+    assert!(from_str(~"-00100") == Some(-100 as T));
 
-    fail_unless!(from_str(~" ").is_none());
-    fail_unless!(from_str(~"x").is_none());
+    assert!(from_str(~" ").is_none());
+    assert!(from_str(~"x").is_none());
 }
 
 #[test]
 fn test_parse_bytes() {
     use str::to_bytes;
-    fail_unless!(parse_bytes(to_bytes(~"123"), 10u) == Some(123 as T));
-    fail_unless!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9 as T));
-    fail_unless!(parse_bytes(to_bytes(~"123"), 8u) == Some(83 as T));
-    fail_unless!(i32::parse_bytes(to_bytes(~"123"), 16u) == Some(291 as i32));
-    fail_unless!(i32::parse_bytes(to_bytes(~"ffff"), 16u) ==
+    assert!(parse_bytes(to_bytes(~"123"), 10u) == Some(123 as T));
+    assert!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9 as T));
+    assert!(parse_bytes(to_bytes(~"123"), 8u) == Some(83 as T));
+    assert!(i32::parse_bytes(to_bytes(~"123"), 16u) == Some(291 as i32));
+    assert!(i32::parse_bytes(to_bytes(~"ffff"), 16u) ==
                  Some(65535 as i32));
-    fail_unless!(i32::parse_bytes(to_bytes(~"FFFF"), 16u) ==
+    assert!(i32::parse_bytes(to_bytes(~"FFFF"), 16u) ==
                  Some(65535 as i32));
-    fail_unless!(parse_bytes(to_bytes(~"z"), 36u) == Some(35 as T));
-    fail_unless!(parse_bytes(to_bytes(~"Z"), 36u) == Some(35 as T));
+    assert!(parse_bytes(to_bytes(~"z"), 36u) == Some(35 as T));
+    assert!(parse_bytes(to_bytes(~"Z"), 36u) == Some(35 as T));
 
-    fail_unless!(parse_bytes(to_bytes(~"-123"), 10u) == Some(-123 as T));
-    fail_unless!(parse_bytes(to_bytes(~"-1001"), 2u) == Some(-9 as T));
-    fail_unless!(parse_bytes(to_bytes(~"-123"), 8u) == Some(-83 as T));
-    fail_unless!(i32::parse_bytes(to_bytes(~"-123"), 16u) ==
+    assert!(parse_bytes(to_bytes(~"-123"), 10u) == Some(-123 as T));
+    assert!(parse_bytes(to_bytes(~"-1001"), 2u) == Some(-9 as T));
+    assert!(parse_bytes(to_bytes(~"-123"), 8u) == Some(-83 as T));
+    assert!(i32::parse_bytes(to_bytes(~"-123"), 16u) ==
                  Some(-291 as i32));
-    fail_unless!(i32::parse_bytes(to_bytes(~"-ffff"), 16u) ==
+    assert!(i32::parse_bytes(to_bytes(~"-ffff"), 16u) ==
                  Some(-65535 as i32));
-    fail_unless!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u) ==
+    assert!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u) ==
                  Some(-65535 as i32));
-    fail_unless!(parse_bytes(to_bytes(~"-z"), 36u) == Some(-35 as T));
-    fail_unless!(parse_bytes(to_bytes(~"-Z"), 36u) == Some(-35 as T));
+    assert!(parse_bytes(to_bytes(~"-z"), 36u) == Some(-35 as T));
+    assert!(parse_bytes(to_bytes(~"-Z"), 36u) == Some(-35 as T));
 
-    fail_unless!(parse_bytes(to_bytes(~"Z"), 35u).is_none());
-    fail_unless!(parse_bytes(to_bytes(~"-9"), 2u).is_none());
+    assert!(parse_bytes(to_bytes(~"Z"), 35u).is_none());
+    assert!(parse_bytes(to_bytes(~"-9"), 2u).is_none());
 }
 
 #[test]
 fn test_to_str() {
-    fail_unless!((to_str_radix(0 as T, 10u) == ~"0"));
-    fail_unless!((to_str_radix(1 as T, 10u) == ~"1"));
-    fail_unless!((to_str_radix(-1 as T, 10u) == ~"-1"));
-    fail_unless!((to_str_radix(127 as T, 16u) == ~"7f"));
-    fail_unless!((to_str_radix(100 as T, 10u) == ~"100"));
+    assert!((to_str_radix(0 as T, 10u) == ~"0"));
+    assert!((to_str_radix(1 as T, 10u) == ~"1"));
+    assert!((to_str_radix(-1 as T, 10u) == ~"-1"));
+    assert!((to_str_radix(127 as T, 16u) == ~"7f"));
+    assert!((to_str_radix(100 as T, 10u) == ~"100"));
 
 }
 
 #[test]
 fn test_int_to_str_overflow() {
     let mut i8_val: i8 = 127_i8;
-    fail_unless!((i8::to_str(i8_val) == ~"127"));
+    assert!((i8::to_str(i8_val) == ~"127"));
 
     i8_val += 1 as i8;
-    fail_unless!((i8::to_str(i8_val) == ~"-128"));
+    assert!((i8::to_str(i8_val) == ~"-128"));
 
     let mut i16_val: i16 = 32_767_i16;
-    fail_unless!((i16::to_str(i16_val) == ~"32767"));
+    assert!((i16::to_str(i16_val) == ~"32767"));
 
     i16_val += 1 as i16;
-    fail_unless!((i16::to_str(i16_val) == ~"-32768"));
+    assert!((i16::to_str(i16_val) == ~"-32768"));
 
     let mut i32_val: i32 = 2_147_483_647_i32;
-    fail_unless!((i32::to_str(i32_val) == ~"2147483647"));
+    assert!((i32::to_str(i32_val) == ~"2147483647"));
 
     i32_val += 1 as i32;
-    fail_unless!((i32::to_str(i32_val) == ~"-2147483648"));
+    assert!((i32::to_str(i32_val) == ~"-2147483648"));
 
     let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-    fail_unless!((i64::to_str(i64_val) == ~"9223372036854775807"));
+    assert!((i64::to_str(i64_val) == ~"9223372036854775807"));
 
     i64_val += 1 as i64;
-    fail_unless!((i64::to_str(i64_val) == ~"-9223372036854775808"));
+    assert!((i64::to_str(i64_val) == ~"-9223372036854775808"));
 }
 
 #[test]
 fn test_int_from_str_overflow() {
     let mut i8_val: i8 = 127_i8;
-    fail_unless!((i8::from_str(~"127") == Some(i8_val)));
-    fail_unless!((i8::from_str(~"128").is_none()));
+    assert!((i8::from_str(~"127") == Some(i8_val)));
+    assert!((i8::from_str(~"128").is_none()));
 
     i8_val += 1 as i8;
-    fail_unless!((i8::from_str(~"-128") == Some(i8_val)));
-    fail_unless!((i8::from_str(~"-129").is_none()));
+    assert!((i8::from_str(~"-128") == Some(i8_val)));
+    assert!((i8::from_str(~"-129").is_none()));
 
     let mut i16_val: i16 = 32_767_i16;
-    fail_unless!((i16::from_str(~"32767") == Some(i16_val)));
-    fail_unless!((i16::from_str(~"32768").is_none()));
+    assert!((i16::from_str(~"32767") == Some(i16_val)));
+    assert!((i16::from_str(~"32768").is_none()));
 
     i16_val += 1 as i16;
-    fail_unless!((i16::from_str(~"-32768") == Some(i16_val)));
-    fail_unless!((i16::from_str(~"-32769").is_none()));
+    assert!((i16::from_str(~"-32768") == Some(i16_val)));
+    assert!((i16::from_str(~"-32769").is_none()));
 
     let mut i32_val: i32 = 2_147_483_647_i32;
-    fail_unless!((i32::from_str(~"2147483647") == Some(i32_val)));
-    fail_unless!((i32::from_str(~"2147483648").is_none()));
+    assert!((i32::from_str(~"2147483647") == Some(i32_val)));
+    assert!((i32::from_str(~"2147483648").is_none()));
 
     i32_val += 1 as i32;
-    fail_unless!((i32::from_str(~"-2147483648") == Some(i32_val)));
-    fail_unless!((i32::from_str(~"-2147483649").is_none()));
+    assert!((i32::from_str(~"-2147483648") == Some(i32_val)));
+    assert!((i32::from_str(~"-2147483649").is_none()));
 
     let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-    fail_unless!((i64::from_str(~"9223372036854775807") == Some(i64_val)));
-    fail_unless!((i64::from_str(~"9223372036854775808").is_none()));
+    assert!((i64::from_str(~"9223372036854775807") == Some(i64_val)));
+    assert!((i64::from_str(~"9223372036854775808").is_none()));
 
     i64_val += 1 as i64;
-    fail_unless!((i64::from_str(~"-9223372036854775808") == Some(i64_val)));
-    fail_unless!((i64::from_str(~"-9223372036854775809").is_none()));
+    assert!((i64::from_str(~"-9223372036854775808") == Some(i64_val)));
+    assert!((i64::from_str(~"-9223372036854775809").is_none()));
 }
 
 #[test]
@@ -398,11 +398,11 @@ pub fn test_num() {
     let ten: T = num::cast(10);
     let two: T = num::cast(2);
 
-    fail_unless!((ten.add(&two)    == num::cast(12)));
-    fail_unless!((ten.sub(&two)    == num::cast(8)));
-    fail_unless!((ten.mul(&two)    == num::cast(20)));
-    fail_unless!((ten.div(&two)    == num::cast(5)));
-    fail_unless!((ten.modulo(&two) == num::cast(0)));
+    assert!((ten.add(&two)    == num::cast(12)));
+    assert!((ten.sub(&two)    == num::cast(8)));
+    assert!((ten.mul(&two)    == num::cast(20)));
+    assert!((ten.div(&two)    == num::cast(5)));
+    assert!((ten.modulo(&two) == num::cast(0)));
 }
 
 #[test]
@@ -421,7 +421,7 @@ pub fn test_ranges() {
     for range_step(36,30,-2) |i| {
         l.push(i);
     }
-    fail_unless!(l == ~[0,1,2,
+    assert!(l == ~[0,1,2,
                         13,12,11,
                         20,22,24,
                         36,34,32]);
diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs
index 965b6f86a53..76be224af15 100644
--- a/src/libcore/num/int-template/i16.rs
+++ b/src/libcore/num/int-template/i16.rs
@@ -43,45 +43,45 @@ impl NumCast for i16 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20i16.to_uint()));
-    fail_unless!((20u8  == 20i16.to_u8()));
-    fail_unless!((20u16 == 20i16.to_u16()));
-    fail_unless!((20u32 == 20i16.to_u32()));
-    fail_unless!((20u64 == 20i16.to_u64()));
-    fail_unless!((20i   == 20i16.to_int()));
-    fail_unless!((20i8  == 20i16.to_i8()));
-    fail_unless!((20i16 == 20i16.to_i16()));
-    fail_unless!((20i32 == 20i16.to_i32()));
-    fail_unless!((20i64 == 20i16.to_i64()));
-    fail_unless!((20f   == 20i16.to_float()));
-    fail_unless!((20f32 == 20i16.to_f32()));
-    fail_unless!((20f64 == 20i16.to_f64()));
+    assert!((20u   == 20i16.to_uint()));
+    assert!((20u8  == 20i16.to_u8()));
+    assert!((20u16 == 20i16.to_u16()));
+    assert!((20u32 == 20i16.to_u32()));
+    assert!((20u64 == 20i16.to_u64()));
+    assert!((20i   == 20i16.to_int()));
+    assert!((20i8  == 20i16.to_i8()));
+    assert!((20i16 == 20i16.to_i16()));
+    assert!((20i32 == 20i16.to_i32()));
+    assert!((20i64 == 20i16.to_i64()));
+    assert!((20f   == 20i16.to_float()));
+    assert!((20f32 == 20i16.to_f32()));
+    assert!((20f64 == 20i16.to_f64()));
 
-    fail_unless!((20i16 == NumCast::from(20u)));
-    fail_unless!((20i16 == NumCast::from(20u8)));
-    fail_unless!((20i16 == NumCast::from(20u16)));
-    fail_unless!((20i16 == NumCast::from(20u32)));
-    fail_unless!((20i16 == NumCast::from(20u64)));
-    fail_unless!((20i16 == NumCast::from(20i)));
-    fail_unless!((20i16 == NumCast::from(20i8)));
-    fail_unless!((20i16 == NumCast::from(20i16)));
-    fail_unless!((20i16 == NumCast::from(20i32)));
-    fail_unless!((20i16 == NumCast::from(20i64)));
-    fail_unless!((20i16 == NumCast::from(20f)));
-    fail_unless!((20i16 == NumCast::from(20f32)));
-    fail_unless!((20i16 == NumCast::from(20f64)));
+    assert!((20i16 == NumCast::from(20u)));
+    assert!((20i16 == NumCast::from(20u8)));
+    assert!((20i16 == NumCast::from(20u16)));
+    assert!((20i16 == NumCast::from(20u32)));
+    assert!((20i16 == NumCast::from(20u64)));
+    assert!((20i16 == NumCast::from(20i)));
+    assert!((20i16 == NumCast::from(20i8)));
+    assert!((20i16 == NumCast::from(20i16)));
+    assert!((20i16 == NumCast::from(20i32)));
+    assert!((20i16 == NumCast::from(20i64)));
+    assert!((20i16 == NumCast::from(20f)));
+    assert!((20i16 == NumCast::from(20f32)));
+    assert!((20i16 == NumCast::from(20f64)));
 
-    fail_unless!((20i16 == num::cast(20u)));
-    fail_unless!((20i16 == num::cast(20u8)));
-    fail_unless!((20i16 == num::cast(20u16)));
-    fail_unless!((20i16 == num::cast(20u32)));
-    fail_unless!((20i16 == num::cast(20u64)));
-    fail_unless!((20i16 == num::cast(20i)));
-    fail_unless!((20i16 == num::cast(20i8)));
-    fail_unless!((20i16 == num::cast(20i16)));
-    fail_unless!((20i16 == num::cast(20i32)));
-    fail_unless!((20i16 == num::cast(20i64)));
-    fail_unless!((20i16 == num::cast(20f)));
-    fail_unless!((20i16 == num::cast(20f32)));
-    fail_unless!((20i16 == num::cast(20f64)));
+    assert!((20i16 == num::cast(20u)));
+    assert!((20i16 == num::cast(20u8)));
+    assert!((20i16 == num::cast(20u16)));
+    assert!((20i16 == num::cast(20u32)));
+    assert!((20i16 == num::cast(20u64)));
+    assert!((20i16 == num::cast(20i)));
+    assert!((20i16 == num::cast(20i8)));
+    assert!((20i16 == num::cast(20i16)));
+    assert!((20i16 == num::cast(20i32)));
+    assert!((20i16 == num::cast(20i64)));
+    assert!((20i16 == num::cast(20f)));
+    assert!((20i16 == num::cast(20f32)));
+    assert!((20i16 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs
index 030bc9c3fde..596d29aa291 100644
--- a/src/libcore/num/int-template/i32.rs
+++ b/src/libcore/num/int-template/i32.rs
@@ -43,45 +43,45 @@ impl NumCast for i32 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20i32.to_uint()));
-    fail_unless!((20u8  == 20i32.to_u8()));
-    fail_unless!((20u16 == 20i32.to_u16()));
-    fail_unless!((20u32 == 20i32.to_u32()));
-    fail_unless!((20u64 == 20i32.to_u64()));
-    fail_unless!((20i   == 20i32.to_int()));
-    fail_unless!((20i8  == 20i32.to_i8()));
-    fail_unless!((20i16 == 20i32.to_i16()));
-    fail_unless!((20i32 == 20i32.to_i32()));
-    fail_unless!((20i64 == 20i32.to_i64()));
-    fail_unless!((20f   == 20i32.to_float()));
-    fail_unless!((20f32 == 20i32.to_f32()));
-    fail_unless!((20f64 == 20i32.to_f64()));
+    assert!((20u   == 20i32.to_uint()));
+    assert!((20u8  == 20i32.to_u8()));
+    assert!((20u16 == 20i32.to_u16()));
+    assert!((20u32 == 20i32.to_u32()));
+    assert!((20u64 == 20i32.to_u64()));
+    assert!((20i   == 20i32.to_int()));
+    assert!((20i8  == 20i32.to_i8()));
+    assert!((20i16 == 20i32.to_i16()));
+    assert!((20i32 == 20i32.to_i32()));
+    assert!((20i64 == 20i32.to_i64()));
+    assert!((20f   == 20i32.to_float()));
+    assert!((20f32 == 20i32.to_f32()));
+    assert!((20f64 == 20i32.to_f64()));
 
-    fail_unless!((20i32 == NumCast::from(20u)));
-    fail_unless!((20i32 == NumCast::from(20u8)));
-    fail_unless!((20i32 == NumCast::from(20u16)));
-    fail_unless!((20i32 == NumCast::from(20u32)));
-    fail_unless!((20i32 == NumCast::from(20u64)));
-    fail_unless!((20i32 == NumCast::from(20i)));
-    fail_unless!((20i32 == NumCast::from(20i8)));
-    fail_unless!((20i32 == NumCast::from(20i16)));
-    fail_unless!((20i32 == NumCast::from(20i32)));
-    fail_unless!((20i32 == NumCast::from(20i64)));
-    fail_unless!((20i32 == NumCast::from(20f)));
-    fail_unless!((20i32 == NumCast::from(20f32)));
-    fail_unless!((20i32 == NumCast::from(20f64)));
+    assert!((20i32 == NumCast::from(20u)));
+    assert!((20i32 == NumCast::from(20u8)));
+    assert!((20i32 == NumCast::from(20u16)));
+    assert!((20i32 == NumCast::from(20u32)));
+    assert!((20i32 == NumCast::from(20u64)));
+    assert!((20i32 == NumCast::from(20i)));
+    assert!((20i32 == NumCast::from(20i8)));
+    assert!((20i32 == NumCast::from(20i16)));
+    assert!((20i32 == NumCast::from(20i32)));
+    assert!((20i32 == NumCast::from(20i64)));
+    assert!((20i32 == NumCast::from(20f)));
+    assert!((20i32 == NumCast::from(20f32)));
+    assert!((20i32 == NumCast::from(20f64)));
 
-    fail_unless!((20i32 == num::cast(20u)));
-    fail_unless!((20i32 == num::cast(20u8)));
-    fail_unless!((20i32 == num::cast(20u16)));
-    fail_unless!((20i32 == num::cast(20u32)));
-    fail_unless!((20i32 == num::cast(20u64)));
-    fail_unless!((20i32 == num::cast(20i)));
-    fail_unless!((20i32 == num::cast(20i8)));
-    fail_unless!((20i32 == num::cast(20i16)));
-    fail_unless!((20i32 == num::cast(20i32)));
-    fail_unless!((20i32 == num::cast(20i64)));
-    fail_unless!((20i32 == num::cast(20f)));
-    fail_unless!((20i32 == num::cast(20f32)));
-    fail_unless!((20i32 == num::cast(20f64)));
+    assert!((20i32 == num::cast(20u)));
+    assert!((20i32 == num::cast(20u8)));
+    assert!((20i32 == num::cast(20u16)));
+    assert!((20i32 == num::cast(20u32)));
+    assert!((20i32 == num::cast(20u64)));
+    assert!((20i32 == num::cast(20i)));
+    assert!((20i32 == num::cast(20i8)));
+    assert!((20i32 == num::cast(20i16)));
+    assert!((20i32 == num::cast(20i32)));
+    assert!((20i32 == num::cast(20i64)));
+    assert!((20i32 == num::cast(20f)));
+    assert!((20i32 == num::cast(20f32)));
+    assert!((20i32 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs
index 283de94e9d8..d02c46d9393 100644
--- a/src/libcore/num/int-template/i64.rs
+++ b/src/libcore/num/int-template/i64.rs
@@ -43,45 +43,45 @@ impl NumCast for i64 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20i64.to_uint()));
-    fail_unless!((20u8  == 20i64.to_u8()));
-    fail_unless!((20u16 == 20i64.to_u16()));
-    fail_unless!((20u32 == 20i64.to_u32()));
-    fail_unless!((20u64 == 20i64.to_u64()));
-    fail_unless!((20i   == 20i64.to_int()));
-    fail_unless!((20i8  == 20i64.to_i8()));
-    fail_unless!((20i16 == 20i64.to_i16()));
-    fail_unless!((20i32 == 20i64.to_i32()));
-    fail_unless!((20i64 == 20i64.to_i64()));
-    fail_unless!((20f   == 20i64.to_float()));
-    fail_unless!((20f32 == 20i64.to_f32()));
-    fail_unless!((20f64 == 20i64.to_f64()));
+    assert!((20u   == 20i64.to_uint()));
+    assert!((20u8  == 20i64.to_u8()));
+    assert!((20u16 == 20i64.to_u16()));
+    assert!((20u32 == 20i64.to_u32()));
+    assert!((20u64 == 20i64.to_u64()));
+    assert!((20i   == 20i64.to_int()));
+    assert!((20i8  == 20i64.to_i8()));
+    assert!((20i16 == 20i64.to_i16()));
+    assert!((20i32 == 20i64.to_i32()));
+    assert!((20i64 == 20i64.to_i64()));
+    assert!((20f   == 20i64.to_float()));
+    assert!((20f32 == 20i64.to_f32()));
+    assert!((20f64 == 20i64.to_f64()));
 
-    fail_unless!((20i64 == NumCast::from(20u)));
-    fail_unless!((20i64 == NumCast::from(20u8)));
-    fail_unless!((20i64 == NumCast::from(20u16)));
-    fail_unless!((20i64 == NumCast::from(20u32)));
-    fail_unless!((20i64 == NumCast::from(20u64)));
-    fail_unless!((20i64 == NumCast::from(20i)));
-    fail_unless!((20i64 == NumCast::from(20i8)));
-    fail_unless!((20i64 == NumCast::from(20i16)));
-    fail_unless!((20i64 == NumCast::from(20i32)));
-    fail_unless!((20i64 == NumCast::from(20i64)));
-    fail_unless!((20i64 == NumCast::from(20f)));
-    fail_unless!((20i64 == NumCast::from(20f32)));
-    fail_unless!((20i64 == NumCast::from(20f64)));
+    assert!((20i64 == NumCast::from(20u)));
+    assert!((20i64 == NumCast::from(20u8)));
+    assert!((20i64 == NumCast::from(20u16)));
+    assert!((20i64 == NumCast::from(20u32)));
+    assert!((20i64 == NumCast::from(20u64)));
+    assert!((20i64 == NumCast::from(20i)));
+    assert!((20i64 == NumCast::from(20i8)));
+    assert!((20i64 == NumCast::from(20i16)));
+    assert!((20i64 == NumCast::from(20i32)));
+    assert!((20i64 == NumCast::from(20i64)));
+    assert!((20i64 == NumCast::from(20f)));
+    assert!((20i64 == NumCast::from(20f32)));
+    assert!((20i64 == NumCast::from(20f64)));
 
-    fail_unless!((20i64 == num::cast(20u)));
-    fail_unless!((20i64 == num::cast(20u8)));
-    fail_unless!((20i64 == num::cast(20u16)));
-    fail_unless!((20i64 == num::cast(20u32)));
-    fail_unless!((20i64 == num::cast(20u64)));
-    fail_unless!((20i64 == num::cast(20i)));
-    fail_unless!((20i64 == num::cast(20i8)));
-    fail_unless!((20i64 == num::cast(20i16)));
-    fail_unless!((20i64 == num::cast(20i32)));
-    fail_unless!((20i64 == num::cast(20i64)));
-    fail_unless!((20i64 == num::cast(20f)));
-    fail_unless!((20i64 == num::cast(20f32)));
-    fail_unless!((20i64 == num::cast(20f64)));
+    assert!((20i64 == num::cast(20u)));
+    assert!((20i64 == num::cast(20u8)));
+    assert!((20i64 == num::cast(20u16)));
+    assert!((20i64 == num::cast(20u32)));
+    assert!((20i64 == num::cast(20u64)));
+    assert!((20i64 == num::cast(20i)));
+    assert!((20i64 == num::cast(20i8)));
+    assert!((20i64 == num::cast(20i16)));
+    assert!((20i64 == num::cast(20i32)));
+    assert!((20i64 == num::cast(20i64)));
+    assert!((20i64 == num::cast(20f)));
+    assert!((20i64 == num::cast(20f32)));
+    assert!((20i64 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs
index 2f2de358337..c0dd6e01d4b 100644
--- a/src/libcore/num/int-template/i8.rs
+++ b/src/libcore/num/int-template/i8.rs
@@ -43,45 +43,45 @@ impl NumCast for i8 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20i8.to_uint()));
-    fail_unless!((20u8  == 20i8.to_u8()));
-    fail_unless!((20u16 == 20i8.to_u16()));
-    fail_unless!((20u32 == 20i8.to_u32()));
-    fail_unless!((20u64 == 20i8.to_u64()));
-    fail_unless!((20i   == 20i8.to_int()));
-    fail_unless!((20i8  == 20i8.to_i8()));
-    fail_unless!((20i16 == 20i8.to_i16()));
-    fail_unless!((20i32 == 20i8.to_i32()));
-    fail_unless!((20i64 == 20i8.to_i64()));
-    fail_unless!((20f   == 20i8.to_float()));
-    fail_unless!((20f32 == 20i8.to_f32()));
-    fail_unless!((20f64 == 20i8.to_f64()));
+    assert!((20u   == 20i8.to_uint()));
+    assert!((20u8  == 20i8.to_u8()));
+    assert!((20u16 == 20i8.to_u16()));
+    assert!((20u32 == 20i8.to_u32()));
+    assert!((20u64 == 20i8.to_u64()));
+    assert!((20i   == 20i8.to_int()));
+    assert!((20i8  == 20i8.to_i8()));
+    assert!((20i16 == 20i8.to_i16()));
+    assert!((20i32 == 20i8.to_i32()));
+    assert!((20i64 == 20i8.to_i64()));
+    assert!((20f   == 20i8.to_float()));
+    assert!((20f32 == 20i8.to_f32()));
+    assert!((20f64 == 20i8.to_f64()));
 
-    fail_unless!((20i8 == NumCast::from(20u)));
-    fail_unless!((20i8 == NumCast::from(20u8)));
-    fail_unless!((20i8 == NumCast::from(20u16)));
-    fail_unless!((20i8 == NumCast::from(20u32)));
-    fail_unless!((20i8 == NumCast::from(20u64)));
-    fail_unless!((20i8 == NumCast::from(20i)));
-    fail_unless!((20i8 == NumCast::from(20i8)));
-    fail_unless!((20i8 == NumCast::from(20i16)));
-    fail_unless!((20i8 == NumCast::from(20i32)));
-    fail_unless!((20i8 == NumCast::from(20i64)));
-    fail_unless!((20i8 == NumCast::from(20f)));
-    fail_unless!((20i8 == NumCast::from(20f32)));
-    fail_unless!((20i8 == NumCast::from(20f64)));
+    assert!((20i8 == NumCast::from(20u)));
+    assert!((20i8 == NumCast::from(20u8)));
+    assert!((20i8 == NumCast::from(20u16)));
+    assert!((20i8 == NumCast::from(20u32)));
+    assert!((20i8 == NumCast::from(20u64)));
+    assert!((20i8 == NumCast::from(20i)));
+    assert!((20i8 == NumCast::from(20i8)));
+    assert!((20i8 == NumCast::from(20i16)));
+    assert!((20i8 == NumCast::from(20i32)));
+    assert!((20i8 == NumCast::from(20i64)));
+    assert!((20i8 == NumCast::from(20f)));
+    assert!((20i8 == NumCast::from(20f32)));
+    assert!((20i8 == NumCast::from(20f64)));
 
-    fail_unless!((20i8 == num::cast(20u)));
-    fail_unless!((20i8 == num::cast(20u8)));
-    fail_unless!((20i8 == num::cast(20u16)));
-    fail_unless!((20i8 == num::cast(20u32)));
-    fail_unless!((20i8 == num::cast(20u64)));
-    fail_unless!((20i8 == num::cast(20i)));
-    fail_unless!((20i8 == num::cast(20i8)));
-    fail_unless!((20i8 == num::cast(20i16)));
-    fail_unless!((20i8 == num::cast(20i32)));
-    fail_unless!((20i8 == num::cast(20i64)));
-    fail_unless!((20i8 == num::cast(20f)));
-    fail_unless!((20i8 == num::cast(20f32)));
-    fail_unless!((20i8 == num::cast(20f64)));
+    assert!((20i8 == num::cast(20u)));
+    assert!((20i8 == num::cast(20u8)));
+    assert!((20i8 == num::cast(20u16)));
+    assert!((20i8 == num::cast(20u32)));
+    assert!((20i8 == num::cast(20u64)));
+    assert!((20i8 == num::cast(20i)));
+    assert!((20i8 == num::cast(20i8)));
+    assert!((20i8 == num::cast(20i16)));
+    assert!((20i8 == num::cast(20i32)));
+    assert!((20i8 == num::cast(20i64)));
+    assert!((20i8 == num::cast(20f)));
+    assert!((20i8 == num::cast(20f32)));
+    assert!((20i8 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs
index 3c89492c7e4..ea8aec12224 100644
--- a/src/libcore/num/int-template/int.rs
+++ b/src/libcore/num/int-template/int.rs
@@ -40,21 +40,21 @@ mod inst {
 
     #[test]
     fn test_pow() {
-        fail_unless!((pow(0, 0u) == 1));
-        fail_unless!((pow(0, 1u) == 0));
-        fail_unless!((pow(0, 2u) == 0));
-        fail_unless!((pow(-1, 0u) == 1));
-        fail_unless!((pow(1, 0u) == 1));
-        fail_unless!((pow(-3, 2u) == 9));
-        fail_unless!((pow(-3, 3u) == -27));
-        fail_unless!((pow(4, 9u) == 262144));
+        assert!((pow(0, 0u) == 1));
+        assert!((pow(0, 1u) == 0));
+        assert!((pow(0, 2u) == 0));
+        assert!((pow(-1, 0u) == 1));
+        assert!((pow(1, 0u) == 1));
+        assert!((pow(-3, 2u) == 9));
+        assert!((pow(-3, 3u) == -27));
+        assert!((pow(4, 9u) == 262144));
     }
 
     #[test]
     fn test_overflows() {
-        fail_unless!((::int::max_value > 0));
-        fail_unless!((::int::min_value <= 0));
-        fail_unless!((::int::min_value + ::int::max_value + 1 == 0));
+        assert!((::int::max_value > 0));
+        assert!((::int::min_value <= 0));
+        assert!((::int::min_value + ::int::max_value + 1 == 0));
     }
 }
 
@@ -84,45 +84,45 @@ impl NumCast for int {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20i.to_uint()));
-    fail_unless!((20u8  == 20i.to_u8()));
-    fail_unless!((20u16 == 20i.to_u16()));
-    fail_unless!((20u32 == 20i.to_u32()));
-    fail_unless!((20u64 == 20i.to_u64()));
-    fail_unless!((20i   == 20i.to_int()));
-    fail_unless!((20i8  == 20i.to_i8()));
-    fail_unless!((20i16 == 20i.to_i16()));
-    fail_unless!((20i32 == 20i.to_i32()));
-    fail_unless!((20i64 == 20i.to_i64()));
-    fail_unless!((20f   == 20i.to_float()));
-    fail_unless!((20f32 == 20i.to_f32()));
-    fail_unless!((20f64 == 20i.to_f64()));
+    assert!((20u   == 20i.to_uint()));
+    assert!((20u8  == 20i.to_u8()));
+    assert!((20u16 == 20i.to_u16()));
+    assert!((20u32 == 20i.to_u32()));
+    assert!((20u64 == 20i.to_u64()));
+    assert!((20i   == 20i.to_int()));
+    assert!((20i8  == 20i.to_i8()));
+    assert!((20i16 == 20i.to_i16()));
+    assert!((20i32 == 20i.to_i32()));
+    assert!((20i64 == 20i.to_i64()));
+    assert!((20f   == 20i.to_float()));
+    assert!((20f32 == 20i.to_f32()));
+    assert!((20f64 == 20i.to_f64()));
 
-    fail_unless!((20i == NumCast::from(20u)));
-    fail_unless!((20i == NumCast::from(20u8)));
-    fail_unless!((20i == NumCast::from(20u16)));
-    fail_unless!((20i == NumCast::from(20u32)));
-    fail_unless!((20i == NumCast::from(20u64)));
-    fail_unless!((20i == NumCast::from(20i)));
-    fail_unless!((20i == NumCast::from(20i8)));
-    fail_unless!((20i == NumCast::from(20i16)));
-    fail_unless!((20i == NumCast::from(20i32)));
-    fail_unless!((20i == NumCast::from(20i64)));
-    fail_unless!((20i == NumCast::from(20f)));
-    fail_unless!((20i == NumCast::from(20f32)));
-    fail_unless!((20i == NumCast::from(20f64)));
+    assert!((20i == NumCast::from(20u)));
+    assert!((20i == NumCast::from(20u8)));
+    assert!((20i == NumCast::from(20u16)));
+    assert!((20i == NumCast::from(20u32)));
+    assert!((20i == NumCast::from(20u64)));
+    assert!((20i == NumCast::from(20i)));
+    assert!((20i == NumCast::from(20i8)));
+    assert!((20i == NumCast::from(20i16)));
+    assert!((20i == NumCast::from(20i32)));
+    assert!((20i == NumCast::from(20i64)));
+    assert!((20i == NumCast::from(20f)));
+    assert!((20i == NumCast::from(20f32)));
+    assert!((20i == NumCast::from(20f64)));
 
-    fail_unless!((20i == num::cast(20u)));
-    fail_unless!((20i == num::cast(20u8)));
-    fail_unless!((20i == num::cast(20u16)));
-    fail_unless!((20i == num::cast(20u32)));
-    fail_unless!((20i == num::cast(20u64)));
-    fail_unless!((20i == num::cast(20i)));
-    fail_unless!((20i == num::cast(20i8)));
-    fail_unless!((20i == num::cast(20i16)));
-    fail_unless!((20i == num::cast(20i32)));
-    fail_unless!((20i == num::cast(20i64)));
-    fail_unless!((20i == num::cast(20f)));
-    fail_unless!((20i == num::cast(20f32)));
-    fail_unless!((20i == num::cast(20f64)));
+    assert!((20i == num::cast(20u)));
+    assert!((20i == num::cast(20u8)));
+    assert!((20i == num::cast(20u16)));
+    assert!((20i == num::cast(20u32)));
+    assert!((20i == num::cast(20u64)));
+    assert!((20i == num::cast(20i)));
+    assert!((20i == num::cast(20i8)));
+    assert!((20i == num::cast(20i16)));
+    assert!((20i == num::cast(20i32)));
+    assert!((20i == num::cast(20i64)));
+    assert!((20i == num::cast(20f)));
+    assert!((20i == num::cast(20f32)));
+    assert!((20i == num::cast(20f64)));
 }
diff --git a/src/libcore/num/num.rs b/src/libcore/num/num.rs
index 0fe96c8b344..daa36f9dc32 100644
--- a/src/libcore/num/num.rs
+++ b/src/libcore/num/num.rs
@@ -55,7 +55,7 @@ pub enum RoundMode {
  *
  * ~~~
  * let twenty: f32 = num::cast(0x14);
- * fail_unless!(twenty == 20f32);
+ * assert!(twenty == 20f32);
  * ~~~
  */
 #[inline(always)]
diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs
index 410799f43ce..400417284a2 100644
--- a/src/libcore/num/uint-template.rs
+++ b/src/libcore/num/uint-template.rs
@@ -241,104 +241,104 @@ impl ToStrRadix for T {
 
 #[test]
 pub fn test_to_str() {
-    fail_unless!(to_str_radix(0 as T, 10u) == ~"0");
-    fail_unless!(to_str_radix(1 as T, 10u) == ~"1");
-    fail_unless!(to_str_radix(2 as T, 10u) == ~"2");
-    fail_unless!(to_str_radix(11 as T, 10u) == ~"11");
-    fail_unless!(to_str_radix(11 as T, 16u) == ~"b");
-    fail_unless!(to_str_radix(255 as T, 16u) == ~"ff");
-    fail_unless!(to_str_radix(0xff as T, 10u) == ~"255");
+    assert!(to_str_radix(0 as T, 10u) == ~"0");
+    assert!(to_str_radix(1 as T, 10u) == ~"1");
+    assert!(to_str_radix(2 as T, 10u) == ~"2");
+    assert!(to_str_radix(11 as T, 10u) == ~"11");
+    assert!(to_str_radix(11 as T, 16u) == ~"b");
+    assert!(to_str_radix(255 as T, 16u) == ~"ff");
+    assert!(to_str_radix(0xff as T, 10u) == ~"255");
 }
 
 #[test]
 pub fn test_from_str() {
-    fail_unless!(from_str(~"0") == Some(0u as T));
-    fail_unless!(from_str(~"3") == Some(3u as T));
-    fail_unless!(from_str(~"10") == Some(10u as T));
-    fail_unless!(u32::from_str(~"123456789") == Some(123456789 as u32));
-    fail_unless!(from_str(~"00100") == Some(100u as T));
+    assert!(from_str(~"0") == Some(0u as T));
+    assert!(from_str(~"3") == Some(3u as T));
+    assert!(from_str(~"10") == Some(10u as T));
+    assert!(u32::from_str(~"123456789") == Some(123456789 as u32));
+    assert!(from_str(~"00100") == Some(100u as T));
 
-    fail_unless!(from_str(~"").is_none());
-    fail_unless!(from_str(~" ").is_none());
-    fail_unless!(from_str(~"x").is_none());
+    assert!(from_str(~"").is_none());
+    assert!(from_str(~" ").is_none());
+    assert!(from_str(~"x").is_none());
 }
 
 #[test]
 pub fn test_parse_bytes() {
     use str::to_bytes;
-    fail_unless!(parse_bytes(to_bytes(~"123"), 10u) == Some(123u as T));
-    fail_unless!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9u as T));
-    fail_unless!(parse_bytes(to_bytes(~"123"), 8u) == Some(83u as T));
-    fail_unless!(u16::parse_bytes(to_bytes(~"123"), 16u) ==
+    assert!(parse_bytes(to_bytes(~"123"), 10u) == Some(123u as T));
+    assert!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9u as T));
+    assert!(parse_bytes(to_bytes(~"123"), 8u) == Some(83u as T));
+    assert!(u16::parse_bytes(to_bytes(~"123"), 16u) ==
                  Some(291u as u16));
-    fail_unless!(u16::parse_bytes(to_bytes(~"ffff"), 16u) ==
+    assert!(u16::parse_bytes(to_bytes(~"ffff"), 16u) ==
                  Some(65535u as u16));
-    fail_unless!(parse_bytes(to_bytes(~"z"), 36u) == Some(35u as T));
+    assert!(parse_bytes(to_bytes(~"z"), 36u) == Some(35u as T));
 
-    fail_unless!(parse_bytes(to_bytes(~"Z"), 10u).is_none());
-    fail_unless!(parse_bytes(to_bytes(~"_"), 2u).is_none());
+    assert!(parse_bytes(to_bytes(~"Z"), 10u).is_none());
+    assert!(parse_bytes(to_bytes(~"_"), 2u).is_none());
 }
 
 #[test]
 fn test_uint_to_str_overflow() {
     let mut u8_val: u8 = 255_u8;
-    fail_unless!((u8::to_str(u8_val) == ~"255"));
+    assert!((u8::to_str(u8_val) == ~"255"));
 
     u8_val += 1 as u8;
-    fail_unless!((u8::to_str(u8_val) == ~"0"));
+    assert!((u8::to_str(u8_val) == ~"0"));
 
     let mut u16_val: u16 = 65_535_u16;
-    fail_unless!((u16::to_str(u16_val) == ~"65535"));
+    assert!((u16::to_str(u16_val) == ~"65535"));
 
     u16_val += 1 as u16;
-    fail_unless!((u16::to_str(u16_val) == ~"0"));
+    assert!((u16::to_str(u16_val) == ~"0"));
 
     let mut u32_val: u32 = 4_294_967_295_u32;
-    fail_unless!((u32::to_str(u32_val) == ~"4294967295"));
+    assert!((u32::to_str(u32_val) == ~"4294967295"));
 
     u32_val += 1 as u32;
-    fail_unless!((u32::to_str(u32_val) == ~"0"));
+    assert!((u32::to_str(u32_val) == ~"0"));
 
     let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
-    fail_unless!((u64::to_str(u64_val) == ~"18446744073709551615"));
+    assert!((u64::to_str(u64_val) == ~"18446744073709551615"));
 
     u64_val += 1 as u64;
-    fail_unless!((u64::to_str(u64_val) == ~"0"));
+    assert!((u64::to_str(u64_val) == ~"0"));
 }
 
 #[test]
 fn test_uint_from_str_overflow() {
     let mut u8_val: u8 = 255_u8;
-    fail_unless!((u8::from_str(~"255") == Some(u8_val)));
-    fail_unless!((u8::from_str(~"256").is_none()));
+    assert!((u8::from_str(~"255") == Some(u8_val)));
+    assert!((u8::from_str(~"256").is_none()));
 
     u8_val += 1 as u8;
-    fail_unless!((u8::from_str(~"0") == Some(u8_val)));
-    fail_unless!((u8::from_str(~"-1").is_none()));
+    assert!((u8::from_str(~"0") == Some(u8_val)));
+    assert!((u8::from_str(~"-1").is_none()));
 
     let mut u16_val: u16 = 65_535_u16;
-    fail_unless!((u16::from_str(~"65535") == Some(u16_val)));
-    fail_unless!((u16::from_str(~"65536").is_none()));
+    assert!((u16::from_str(~"65535") == Some(u16_val)));
+    assert!((u16::from_str(~"65536").is_none()));
 
     u16_val += 1 as u16;
-    fail_unless!((u16::from_str(~"0") == Some(u16_val)));
-    fail_unless!((u16::from_str(~"-1").is_none()));
+    assert!((u16::from_str(~"0") == Some(u16_val)));
+    assert!((u16::from_str(~"-1").is_none()));
 
     let mut u32_val: u32 = 4_294_967_295_u32;
-    fail_unless!((u32::from_str(~"4294967295") == Some(u32_val)));
-    fail_unless!((u32::from_str(~"4294967296").is_none()));
+    assert!((u32::from_str(~"4294967295") == Some(u32_val)));
+    assert!((u32::from_str(~"4294967296").is_none()));
 
     u32_val += 1 as u32;
-    fail_unless!((u32::from_str(~"0") == Some(u32_val)));
-    fail_unless!((u32::from_str(~"-1").is_none()));
+    assert!((u32::from_str(~"0") == Some(u32_val)));
+    assert!((u32::from_str(~"-1").is_none()));
 
     let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
-    fail_unless!((u64::from_str(~"18446744073709551615") == Some(u64_val)));
-    fail_unless!((u64::from_str(~"18446744073709551616").is_none()));
+    assert!((u64::from_str(~"18446744073709551615") == Some(u64_val)));
+    assert!((u64::from_str(~"18446744073709551616").is_none()));
 
     u64_val += 1 as u64;
-    fail_unless!((u64::from_str(~"0") == Some(u64_val)));
-    fail_unless!((u64::from_str(~"-1").is_none()));
+    assert!((u64::from_str(~"0") == Some(u64_val)));
+    assert!((u64::from_str(~"-1").is_none()));
 }
 
 #[test]
@@ -372,7 +372,7 @@ pub fn test_ranges() {
         l.push(i);
     }
 
-    fail_unless!(l == ~[0,1,2,
+    assert!(l == ~[0,1,2,
                         13,12,11,
                         20,22,24,
                         36,34,32]);
@@ -397,11 +397,11 @@ pub fn test_num() {
     let ten: T = num::cast(10);
     let two: T = num::cast(2);
 
-    fail_unless!((ten.add(&two)    == num::cast(12)));
-    fail_unless!((ten.sub(&two)    == num::cast(8)));
-    fail_unless!((ten.mul(&two)    == num::cast(20)));
-    fail_unless!((ten.div(&two)    == num::cast(5)));
-    fail_unless!((ten.modulo(&two) == num::cast(0)));
+    assert!((ten.add(&two)    == num::cast(12)));
+    assert!((ten.sub(&two)    == num::cast(8)));
+    assert!((ten.mul(&two)    == num::cast(20)));
+    assert!((ten.div(&two)    == num::cast(5)));
+    assert!((ten.modulo(&two) == num::cast(0)));
 }
 
 #[test]
diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs
index c73313ac0f3..7445a43e486 100644
--- a/src/libcore/num/uint-template/u16.rs
+++ b/src/libcore/num/uint-template/u16.rs
@@ -45,45 +45,45 @@ impl NumCast for u16 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20u16.to_uint()));
-    fail_unless!((20u8  == 20u16.to_u8()));
-    fail_unless!((20u16 == 20u16.to_u16()));
-    fail_unless!((20u32 == 20u16.to_u32()));
-    fail_unless!((20u64 == 20u16.to_u64()));
-    fail_unless!((20i   == 20u16.to_int()));
-    fail_unless!((20i8  == 20u16.to_i8()));
-    fail_unless!((20i16 == 20u16.to_i16()));
-    fail_unless!((20i32 == 20u16.to_i32()));
-    fail_unless!((20i64 == 20u16.to_i64()));
-    fail_unless!((20f   == 20u16.to_float()));
-    fail_unless!((20f32 == 20u16.to_f32()));
-    fail_unless!((20f64 == 20u16.to_f64()));
+    assert!((20u   == 20u16.to_uint()));
+    assert!((20u8  == 20u16.to_u8()));
+    assert!((20u16 == 20u16.to_u16()));
+    assert!((20u32 == 20u16.to_u32()));
+    assert!((20u64 == 20u16.to_u64()));
+    assert!((20i   == 20u16.to_int()));
+    assert!((20i8  == 20u16.to_i8()));
+    assert!((20i16 == 20u16.to_i16()));
+    assert!((20i32 == 20u16.to_i32()));
+    assert!((20i64 == 20u16.to_i64()));
+    assert!((20f   == 20u16.to_float()));
+    assert!((20f32 == 20u16.to_f32()));
+    assert!((20f64 == 20u16.to_f64()));
 
-    fail_unless!((20u16 == NumCast::from(20u)));
-    fail_unless!((20u16 == NumCast::from(20u8)));
-    fail_unless!((20u16 == NumCast::from(20u16)));
-    fail_unless!((20u16 == NumCast::from(20u32)));
-    fail_unless!((20u16 == NumCast::from(20u64)));
-    fail_unless!((20u16 == NumCast::from(20i)));
-    fail_unless!((20u16 == NumCast::from(20i8)));
-    fail_unless!((20u16 == NumCast::from(20i16)));
-    fail_unless!((20u16 == NumCast::from(20i32)));
-    fail_unless!((20u16 == NumCast::from(20i64)));
-    fail_unless!((20u16 == NumCast::from(20f)));
-    fail_unless!((20u16 == NumCast::from(20f32)));
-    fail_unless!((20u16 == NumCast::from(20f64)));
+    assert!((20u16 == NumCast::from(20u)));
+    assert!((20u16 == NumCast::from(20u8)));
+    assert!((20u16 == NumCast::from(20u16)));
+    assert!((20u16 == NumCast::from(20u32)));
+    assert!((20u16 == NumCast::from(20u64)));
+    assert!((20u16 == NumCast::from(20i)));
+    assert!((20u16 == NumCast::from(20i8)));
+    assert!((20u16 == NumCast::from(20i16)));
+    assert!((20u16 == NumCast::from(20i32)));
+    assert!((20u16 == NumCast::from(20i64)));
+    assert!((20u16 == NumCast::from(20f)));
+    assert!((20u16 == NumCast::from(20f32)));
+    assert!((20u16 == NumCast::from(20f64)));
 
-    fail_unless!((20u16 == num::cast(20u)));
-    fail_unless!((20u16 == num::cast(20u8)));
-    fail_unless!((20u16 == num::cast(20u16)));
-    fail_unless!((20u16 == num::cast(20u32)));
-    fail_unless!((20u16 == num::cast(20u64)));
-    fail_unless!((20u16 == num::cast(20i)));
-    fail_unless!((20u16 == num::cast(20i8)));
-    fail_unless!((20u16 == num::cast(20i16)));
-    fail_unless!((20u16 == num::cast(20i32)));
-    fail_unless!((20u16 == num::cast(20i64)));
-    fail_unless!((20u16 == num::cast(20f)));
-    fail_unless!((20u16 == num::cast(20f32)));
-    fail_unless!((20u16 == num::cast(20f64)));
+    assert!((20u16 == num::cast(20u)));
+    assert!((20u16 == num::cast(20u8)));
+    assert!((20u16 == num::cast(20u16)));
+    assert!((20u16 == num::cast(20u32)));
+    assert!((20u16 == num::cast(20u64)));
+    assert!((20u16 == num::cast(20i)));
+    assert!((20u16 == num::cast(20i8)));
+    assert!((20u16 == num::cast(20i16)));
+    assert!((20u16 == num::cast(20i32)));
+    assert!((20u16 == num::cast(20i64)));
+    assert!((20u16 == num::cast(20f)));
+    assert!((20u16 == num::cast(20f32)));
+    assert!((20u16 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs
index eb63f1a370a..cfc112be8a6 100644
--- a/src/libcore/num/uint-template/u32.rs
+++ b/src/libcore/num/uint-template/u32.rs
@@ -45,45 +45,45 @@ impl NumCast for u32 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20u64.to_uint()));
-    fail_unless!((20u8  == 20u64.to_u8()));
-    fail_unless!((20u16 == 20u64.to_u16()));
-    fail_unless!((20u32 == 20u64.to_u32()));
-    fail_unless!((20u64 == 20u64.to_u64()));
-    fail_unless!((20i   == 20u64.to_int()));
-    fail_unless!((20i8  == 20u64.to_i8()));
-    fail_unless!((20i16 == 20u64.to_i16()));
-    fail_unless!((20i32 == 20u64.to_i32()));
-    fail_unless!((20i64 == 20u64.to_i64()));
-    fail_unless!((20f   == 20u64.to_float()));
-    fail_unless!((20f32 == 20u64.to_f32()));
-    fail_unless!((20f64 == 20u64.to_f64()));
+    assert!((20u   == 20u64.to_uint()));
+    assert!((20u8  == 20u64.to_u8()));
+    assert!((20u16 == 20u64.to_u16()));
+    assert!((20u32 == 20u64.to_u32()));
+    assert!((20u64 == 20u64.to_u64()));
+    assert!((20i   == 20u64.to_int()));
+    assert!((20i8  == 20u64.to_i8()));
+    assert!((20i16 == 20u64.to_i16()));
+    assert!((20i32 == 20u64.to_i32()));
+    assert!((20i64 == 20u64.to_i64()));
+    assert!((20f   == 20u64.to_float()));
+    assert!((20f32 == 20u64.to_f32()));
+    assert!((20f64 == 20u64.to_f64()));
 
-    fail_unless!((20u64 == NumCast::from(20u)));
-    fail_unless!((20u64 == NumCast::from(20u8)));
-    fail_unless!((20u64 == NumCast::from(20u16)));
-    fail_unless!((20u64 == NumCast::from(20u32)));
-    fail_unless!((20u64 == NumCast::from(20u64)));
-    fail_unless!((20u64 == NumCast::from(20i)));
-    fail_unless!((20u64 == NumCast::from(20i8)));
-    fail_unless!((20u64 == NumCast::from(20i16)));
-    fail_unless!((20u64 == NumCast::from(20i32)));
-    fail_unless!((20u64 == NumCast::from(20i64)));
-    fail_unless!((20u64 == NumCast::from(20f)));
-    fail_unless!((20u64 == NumCast::from(20f32)));
-    fail_unless!((20u64 == NumCast::from(20f64)));
+    assert!((20u64 == NumCast::from(20u)));
+    assert!((20u64 == NumCast::from(20u8)));
+    assert!((20u64 == NumCast::from(20u16)));
+    assert!((20u64 == NumCast::from(20u32)));
+    assert!((20u64 == NumCast::from(20u64)));
+    assert!((20u64 == NumCast::from(20i)));
+    assert!((20u64 == NumCast::from(20i8)));
+    assert!((20u64 == NumCast::from(20i16)));
+    assert!((20u64 == NumCast::from(20i32)));
+    assert!((20u64 == NumCast::from(20i64)));
+    assert!((20u64 == NumCast::from(20f)));
+    assert!((20u64 == NumCast::from(20f32)));
+    assert!((20u64 == NumCast::from(20f64)));
 
-    fail_unless!((20u64 == num::cast(20u)));
-    fail_unless!((20u64 == num::cast(20u8)));
-    fail_unless!((20u64 == num::cast(20u16)));
-    fail_unless!((20u64 == num::cast(20u32)));
-    fail_unless!((20u64 == num::cast(20u64)));
-    fail_unless!((20u64 == num::cast(20i)));
-    fail_unless!((20u64 == num::cast(20i8)));
-    fail_unless!((20u64 == num::cast(20i16)));
-    fail_unless!((20u64 == num::cast(20i32)));
-    fail_unless!((20u64 == num::cast(20i64)));
-    fail_unless!((20u64 == num::cast(20f)));
-    fail_unless!((20u64 == num::cast(20f32)));
-    fail_unless!((20u64 == num::cast(20f64)));
+    assert!((20u64 == num::cast(20u)));
+    assert!((20u64 == num::cast(20u8)));
+    assert!((20u64 == num::cast(20u16)));
+    assert!((20u64 == num::cast(20u32)));
+    assert!((20u64 == num::cast(20u64)));
+    assert!((20u64 == num::cast(20i)));
+    assert!((20u64 == num::cast(20i8)));
+    assert!((20u64 == num::cast(20i16)));
+    assert!((20u64 == num::cast(20i32)));
+    assert!((20u64 == num::cast(20i64)));
+    assert!((20u64 == num::cast(20f)));
+    assert!((20u64 == num::cast(20f32)));
+    assert!((20u64 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs
index 799421dc976..4e2f6640d69 100644
--- a/src/libcore/num/uint-template/u64.rs
+++ b/src/libcore/num/uint-template/u64.rs
@@ -45,45 +45,45 @@ impl NumCast for u64 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20u64.to_uint()));
-    fail_unless!((20u8  == 20u64.to_u8()));
-    fail_unless!((20u16 == 20u64.to_u16()));
-    fail_unless!((20u32 == 20u64.to_u32()));
-    fail_unless!((20u64 == 20u64.to_u64()));
-    fail_unless!((20i   == 20u64.to_int()));
-    fail_unless!((20i8  == 20u64.to_i8()));
-    fail_unless!((20i16 == 20u64.to_i16()));
-    fail_unless!((20i32 == 20u64.to_i32()));
-    fail_unless!((20i64 == 20u64.to_i64()));
-    fail_unless!((20f   == 20u64.to_float()));
-    fail_unless!((20f32 == 20u64.to_f32()));
-    fail_unless!((20f64 == 20u64.to_f64()));
+    assert!((20u   == 20u64.to_uint()));
+    assert!((20u8  == 20u64.to_u8()));
+    assert!((20u16 == 20u64.to_u16()));
+    assert!((20u32 == 20u64.to_u32()));
+    assert!((20u64 == 20u64.to_u64()));
+    assert!((20i   == 20u64.to_int()));
+    assert!((20i8  == 20u64.to_i8()));
+    assert!((20i16 == 20u64.to_i16()));
+    assert!((20i32 == 20u64.to_i32()));
+    assert!((20i64 == 20u64.to_i64()));
+    assert!((20f   == 20u64.to_float()));
+    assert!((20f32 == 20u64.to_f32()));
+    assert!((20f64 == 20u64.to_f64()));
 
-    fail_unless!((20u64 == NumCast::from(20u)));
-    fail_unless!((20u64 == NumCast::from(20u8)));
-    fail_unless!((20u64 == NumCast::from(20u16)));
-    fail_unless!((20u64 == NumCast::from(20u32)));
-    fail_unless!((20u64 == NumCast::from(20u64)));
-    fail_unless!((20u64 == NumCast::from(20i)));
-    fail_unless!((20u64 == NumCast::from(20i8)));
-    fail_unless!((20u64 == NumCast::from(20i16)));
-    fail_unless!((20u64 == NumCast::from(20i32)));
-    fail_unless!((20u64 == NumCast::from(20i64)));
-    fail_unless!((20u64 == NumCast::from(20f)));
-    fail_unless!((20u64 == NumCast::from(20f32)));
-    fail_unless!((20u64 == NumCast::from(20f64)));
+    assert!((20u64 == NumCast::from(20u)));
+    assert!((20u64 == NumCast::from(20u8)));
+    assert!((20u64 == NumCast::from(20u16)));
+    assert!((20u64 == NumCast::from(20u32)));
+    assert!((20u64 == NumCast::from(20u64)));
+    assert!((20u64 == NumCast::from(20i)));
+    assert!((20u64 == NumCast::from(20i8)));
+    assert!((20u64 == NumCast::from(20i16)));
+    assert!((20u64 == NumCast::from(20i32)));
+    assert!((20u64 == NumCast::from(20i64)));
+    assert!((20u64 == NumCast::from(20f)));
+    assert!((20u64 == NumCast::from(20f32)));
+    assert!((20u64 == NumCast::from(20f64)));
 
-    fail_unless!((20u64 == num::cast(20u)));
-    fail_unless!((20u64 == num::cast(20u8)));
-    fail_unless!((20u64 == num::cast(20u16)));
-    fail_unless!((20u64 == num::cast(20u32)));
-    fail_unless!((20u64 == num::cast(20u64)));
-    fail_unless!((20u64 == num::cast(20i)));
-    fail_unless!((20u64 == num::cast(20i8)));
-    fail_unless!((20u64 == num::cast(20i16)));
-    fail_unless!((20u64 == num::cast(20i32)));
-    fail_unless!((20u64 == num::cast(20i64)));
-    fail_unless!((20u64 == num::cast(20f)));
-    fail_unless!((20u64 == num::cast(20f32)));
-    fail_unless!((20u64 == num::cast(20f64)));
+    assert!((20u64 == num::cast(20u)));
+    assert!((20u64 == num::cast(20u8)));
+    assert!((20u64 == num::cast(20u16)));
+    assert!((20u64 == num::cast(20u32)));
+    assert!((20u64 == num::cast(20u64)));
+    assert!((20u64 == num::cast(20i)));
+    assert!((20u64 == num::cast(20i8)));
+    assert!((20u64 == num::cast(20i16)));
+    assert!((20u64 == num::cast(20i32)));
+    assert!((20u64 == num::cast(20i64)));
+    assert!((20u64 == num::cast(20f)));
+    assert!((20u64 == num::cast(20f32)));
+    assert!((20u64 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs
index b173d29510c..52bc56b955c 100644
--- a/src/libcore/num/uint-template/u8.rs
+++ b/src/libcore/num/uint-template/u8.rs
@@ -52,45 +52,45 @@ impl NumCast for u8 {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u     == 20u8.to_uint()));
-    fail_unless!((20u8    == 20u8.to_u8()));
-    fail_unless!((20u16   == 20u8.to_u16()));
-    fail_unless!((20u32   == 20u8.to_u32()));
-    fail_unless!((20u64   == 20u8.to_u64()));
-    fail_unless!((20i     == 20u8.to_int()));
-    fail_unless!((20i8    == 20u8.to_i8()));
-    fail_unless!((20i16   == 20u8.to_i16()));
-    fail_unless!((20i32   == 20u8.to_i32()));
-    fail_unless!((20i64   == 20u8.to_i64()));
-    fail_unless!((20f     == 20u8.to_float()));
-    fail_unless!((20f32   == 20u8.to_f32()));
-    fail_unless!((20f64   == 20u8.to_f64()));
+    assert!((20u     == 20u8.to_uint()));
+    assert!((20u8    == 20u8.to_u8()));
+    assert!((20u16   == 20u8.to_u16()));
+    assert!((20u32   == 20u8.to_u32()));
+    assert!((20u64   == 20u8.to_u64()));
+    assert!((20i     == 20u8.to_int()));
+    assert!((20i8    == 20u8.to_i8()));
+    assert!((20i16   == 20u8.to_i16()));
+    assert!((20i32   == 20u8.to_i32()));
+    assert!((20i64   == 20u8.to_i64()));
+    assert!((20f     == 20u8.to_float()));
+    assert!((20f32   == 20u8.to_f32()));
+    assert!((20f64   == 20u8.to_f64()));
 
-    fail_unless!((20u8 == NumCast::from(20u)));
-    fail_unless!((20u8 == NumCast::from(20u8)));
-    fail_unless!((20u8 == NumCast::from(20u16)));
-    fail_unless!((20u8 == NumCast::from(20u32)));
-    fail_unless!((20u8 == NumCast::from(20u64)));
-    fail_unless!((20u8 == NumCast::from(20i)));
-    fail_unless!((20u8 == NumCast::from(20i8)));
-    fail_unless!((20u8 == NumCast::from(20i16)));
-    fail_unless!((20u8 == NumCast::from(20i32)));
-    fail_unless!((20u8 == NumCast::from(20i64)));
-    fail_unless!((20u8 == NumCast::from(20f)));
-    fail_unless!((20u8 == NumCast::from(20f32)));
-    fail_unless!((20u8 == NumCast::from(20f64)));
+    assert!((20u8 == NumCast::from(20u)));
+    assert!((20u8 == NumCast::from(20u8)));
+    assert!((20u8 == NumCast::from(20u16)));
+    assert!((20u8 == NumCast::from(20u32)));
+    assert!((20u8 == NumCast::from(20u64)));
+    assert!((20u8 == NumCast::from(20i)));
+    assert!((20u8 == NumCast::from(20i8)));
+    assert!((20u8 == NumCast::from(20i16)));
+    assert!((20u8 == NumCast::from(20i32)));
+    assert!((20u8 == NumCast::from(20i64)));
+    assert!((20u8 == NumCast::from(20f)));
+    assert!((20u8 == NumCast::from(20f32)));
+    assert!((20u8 == NumCast::from(20f64)));
 
-    fail_unless!((20u8 == num::cast(20u)));
-    fail_unless!((20u8 == num::cast(20u8)));
-    fail_unless!((20u8 == num::cast(20u16)));
-    fail_unless!((20u8 == num::cast(20u32)));
-    fail_unless!((20u8 == num::cast(20u64)));
-    fail_unless!((20u8 == num::cast(20i)));
-    fail_unless!((20u8 == num::cast(20i8)));
-    fail_unless!((20u8 == num::cast(20i16)));
-    fail_unless!((20u8 == num::cast(20i32)));
-    fail_unless!((20u8 == num::cast(20i64)));
-    fail_unless!((20u8 == num::cast(20f)));
-    fail_unless!((20u8 == num::cast(20f32)));
-    fail_unless!((20u8 == num::cast(20f64)));
+    assert!((20u8 == num::cast(20u)));
+    assert!((20u8 == num::cast(20u8)));
+    assert!((20u8 == num::cast(20u16)));
+    assert!((20u8 == num::cast(20u32)));
+    assert!((20u8 == num::cast(20u64)));
+    assert!((20u8 == num::cast(20i)));
+    assert!((20u8 == num::cast(20i8)));
+    assert!((20u8 == num::cast(20i16)));
+    assert!((20u8 == num::cast(20i32)));
+    assert!((20u8 == num::cast(20i64)));
+    assert!((20u8 == num::cast(20f)));
+    assert!((20u8 == num::cast(20f32)));
+    assert!((20u8 == num::cast(20f64)));
 }
diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs
index 741e0f36a33..16e53eb4b6c 100644
--- a/src/libcore/num/uint-template/uint.rs
+++ b/src/libcore/num/uint-template/uint.rs
@@ -143,61 +143,61 @@ pub mod inst {
 
     #[test]
     fn test_next_power_of_two() {
-        fail_unless!((next_power_of_two(0u) == 0u));
-        fail_unless!((next_power_of_two(1u) == 1u));
-        fail_unless!((next_power_of_two(2u) == 2u));
-        fail_unless!((next_power_of_two(3u) == 4u));
-        fail_unless!((next_power_of_two(4u) == 4u));
-        fail_unless!((next_power_of_two(5u) == 8u));
-        fail_unless!((next_power_of_two(6u) == 8u));
-        fail_unless!((next_power_of_two(7u) == 8u));
-        fail_unless!((next_power_of_two(8u) == 8u));
-        fail_unless!((next_power_of_two(9u) == 16u));
-        fail_unless!((next_power_of_two(10u) == 16u));
-        fail_unless!((next_power_of_two(11u) == 16u));
-        fail_unless!((next_power_of_two(12u) == 16u));
-        fail_unless!((next_power_of_two(13u) == 16u));
-        fail_unless!((next_power_of_two(14u) == 16u));
-        fail_unless!((next_power_of_two(15u) == 16u));
-        fail_unless!((next_power_of_two(16u) == 16u));
-        fail_unless!((next_power_of_two(17u) == 32u));
-        fail_unless!((next_power_of_two(18u) == 32u));
-        fail_unless!((next_power_of_two(19u) == 32u));
-        fail_unless!((next_power_of_two(20u) == 32u));
-        fail_unless!((next_power_of_two(21u) == 32u));
-        fail_unless!((next_power_of_two(22u) == 32u));
-        fail_unless!((next_power_of_two(23u) == 32u));
-        fail_unless!((next_power_of_two(24u) == 32u));
-        fail_unless!((next_power_of_two(25u) == 32u));
-        fail_unless!((next_power_of_two(26u) == 32u));
-        fail_unless!((next_power_of_two(27u) == 32u));
-        fail_unless!((next_power_of_two(28u) == 32u));
-        fail_unless!((next_power_of_two(29u) == 32u));
-        fail_unless!((next_power_of_two(30u) == 32u));
-        fail_unless!((next_power_of_two(31u) == 32u));
-        fail_unless!((next_power_of_two(32u) == 32u));
-        fail_unless!((next_power_of_two(33u) == 64u));
-        fail_unless!((next_power_of_two(34u) == 64u));
-        fail_unless!((next_power_of_two(35u) == 64u));
-        fail_unless!((next_power_of_two(36u) == 64u));
-        fail_unless!((next_power_of_two(37u) == 64u));
-        fail_unless!((next_power_of_two(38u) == 64u));
-        fail_unless!((next_power_of_two(39u) == 64u));
+        assert!((next_power_of_two(0u) == 0u));
+        assert!((next_power_of_two(1u) == 1u));
+        assert!((next_power_of_two(2u) == 2u));
+        assert!((next_power_of_two(3u) == 4u));
+        assert!((next_power_of_two(4u) == 4u));
+        assert!((next_power_of_two(5u) == 8u));
+        assert!((next_power_of_two(6u) == 8u));
+        assert!((next_power_of_two(7u) == 8u));
+        assert!((next_power_of_two(8u) == 8u));
+        assert!((next_power_of_two(9u) == 16u));
+        assert!((next_power_of_two(10u) == 16u));
+        assert!((next_power_of_two(11u) == 16u));
+        assert!((next_power_of_two(12u) == 16u));
+        assert!((next_power_of_two(13u) == 16u));
+        assert!((next_power_of_two(14u) == 16u));
+        assert!((next_power_of_two(15u) == 16u));
+        assert!((next_power_of_two(16u) == 16u));
+        assert!((next_power_of_two(17u) == 32u));
+        assert!((next_power_of_two(18u) == 32u));
+        assert!((next_power_of_two(19u) == 32u));
+        assert!((next_power_of_two(20u) == 32u));
+        assert!((next_power_of_two(21u) == 32u));
+        assert!((next_power_of_two(22u) == 32u));
+        assert!((next_power_of_two(23u) == 32u));
+        assert!((next_power_of_two(24u) == 32u));
+        assert!((next_power_of_two(25u) == 32u));
+        assert!((next_power_of_two(26u) == 32u));
+        assert!((next_power_of_two(27u) == 32u));
+        assert!((next_power_of_two(28u) == 32u));
+        assert!((next_power_of_two(29u) == 32u));
+        assert!((next_power_of_two(30u) == 32u));
+        assert!((next_power_of_two(31u) == 32u));
+        assert!((next_power_of_two(32u) == 32u));
+        assert!((next_power_of_two(33u) == 64u));
+        assert!((next_power_of_two(34u) == 64u));
+        assert!((next_power_of_two(35u) == 64u));
+        assert!((next_power_of_two(36u) == 64u));
+        assert!((next_power_of_two(37u) == 64u));
+        assert!((next_power_of_two(38u) == 64u));
+        assert!((next_power_of_two(39u) == 64u));
     }
 
     #[test]
     fn test_overflows() {
         use uint;
-        fail_unless!((uint::max_value > 0u));
-        fail_unless!((uint::min_value <= 0u));
-        fail_unless!((uint::min_value + uint::max_value + 1u == 0u));
+        assert!((uint::max_value > 0u));
+        assert!((uint::min_value <= 0u));
+        assert!((uint::min_value + uint::max_value + 1u == 0u));
     }
 
     #[test]
     fn test_div() {
-        fail_unless!((div_floor(3u, 4u) == 0u));
-        fail_unless!((div_ceil(3u, 4u)  == 1u));
-        fail_unless!((div_round(3u, 4u) == 1u));
+        assert!((div_floor(3u, 4u) == 0u));
+        assert!((div_ceil(3u, 4u)  == 1u));
+        assert!((div_round(3u, 4u) == 1u));
     }
 
     #[test]
@@ -206,7 +206,7 @@ pub mod inst {
         let ten = 10 as uint;
         let mut accum = 0;
         for ten.times { accum += 1; }
-        fail_unless!((accum == 10));
+        assert!((accum == 10));
     }
 }
 
@@ -236,45 +236,45 @@ impl NumCast for uint {
 
 #[test]
 fn test_numcast() {
-    fail_unless!((20u   == 20u.to_uint()));
-    fail_unless!((20u8  == 20u.to_u8()));
-    fail_unless!((20u16 == 20u.to_u16()));
-    fail_unless!((20u32 == 20u.to_u32()));
-    fail_unless!((20u64 == 20u.to_u64()));
-    fail_unless!((20i   == 20u.to_int()));
-    fail_unless!((20i8  == 20u.to_i8()));
-    fail_unless!((20i16 == 20u.to_i16()));
-    fail_unless!((20i32 == 20u.to_i32()));
-    fail_unless!((20i64 == 20u.to_i64()));
-    fail_unless!((20f   == 20u.to_float()));
-    fail_unless!((20f32 == 20u.to_f32()));
-    fail_unless!((20f64 == 20u.to_f64()));
+    assert!((20u   == 20u.to_uint()));
+    assert!((20u8  == 20u.to_u8()));
+    assert!((20u16 == 20u.to_u16()));
+    assert!((20u32 == 20u.to_u32()));
+    assert!((20u64 == 20u.to_u64()));
+    assert!((20i   == 20u.to_int()));
+    assert!((20i8  == 20u.to_i8()));
+    assert!((20i16 == 20u.to_i16()));
+    assert!((20i32 == 20u.to_i32()));
+    assert!((20i64 == 20u.to_i64()));
+    assert!((20f   == 20u.to_float()));
+    assert!((20f32 == 20u.to_f32()));
+    assert!((20f64 == 20u.to_f64()));
 
-    fail_unless!((20u == NumCast::from(20u)));
-    fail_unless!((20u == NumCast::from(20u8)));
-    fail_unless!((20u == NumCast::from(20u16)));
-    fail_unless!((20u == NumCast::from(20u32)));
-    fail_unless!((20u == NumCast::from(20u64)));
-    fail_unless!((20u == NumCast::from(20i)));
-    fail_unless!((20u == NumCast::from(20i8)));
-    fail_unless!((20u == NumCast::from(20i16)));
-    fail_unless!((20u == NumCast::from(20i32)));
-    fail_unless!((20u == NumCast::from(20i64)));
-    fail_unless!((20u == NumCast::from(20f)));
-    fail_unless!((20u == NumCast::from(20f32)));
-    fail_unless!((20u == NumCast::from(20f64)));
+    assert!((20u == NumCast::from(20u)));
+    assert!((20u == NumCast::from(20u8)));
+    assert!((20u == NumCast::from(20u16)));
+    assert!((20u == NumCast::from(20u32)));
+    assert!((20u == NumCast::from(20u64)));
+    assert!((20u == NumCast::from(20i)));
+    assert!((20u == NumCast::from(20i8)));
+    assert!((20u == NumCast::from(20i16)));
+    assert!((20u == NumCast::from(20i32)));
+    assert!((20u == NumCast::from(20i64)));
+    assert!((20u == NumCast::from(20f)));
+    assert!((20u == NumCast::from(20f32)));
+    assert!((20u == NumCast::from(20f64)));
 
-    fail_unless!((20u == num::cast(20u)));
-    fail_unless!((20u == num::cast(20u8)));
-    fail_unless!((20u == num::cast(20u16)));
-    fail_unless!((20u == num::cast(20u32)));
-    fail_unless!((20u == num::cast(20u64)));
-    fail_unless!((20u == num::cast(20i)));
-    fail_unless!((20u == num::cast(20i8)));
-    fail_unless!((20u == num::cast(20i16)));
-    fail_unless!((20u == num::cast(20i32)));
-    fail_unless!((20u == num::cast(20i64)));
-    fail_unless!((20u == num::cast(20f)));
-    fail_unless!((20u == num::cast(20f32)));
-    fail_unless!((20u == num::cast(20f64)));
+    assert!((20u == num::cast(20u)));
+    assert!((20u == num::cast(20u8)));
+    assert!((20u == num::cast(20u16)));
+    assert!((20u == num::cast(20u32)));
+    assert!((20u == num::cast(20u64)));
+    assert!((20u == num::cast(20i)));
+    assert!((20u == num::cast(20i8)));
+    assert!((20u == num::cast(20i16)));
+    assert!((20u == num::cast(20i32)));
+    assert!((20u == num::cast(20i64)));
+    assert!((20u == num::cast(20f)));
+    assert!((20u == num::cast(20f32)));
+    assert!((20u == num::cast(20f64)));
 }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 59c836eba65..cd34d7ab0c0 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -356,7 +356,7 @@ fn test_unwrap_ptr() {
     let opt = Some(x);
     let y = opt.unwrap();
     let addr_y = ptr::addr_of(&(*y));
-    fail_unless!(addr_x == addr_y);
+    assert!(addr_x == addr_y);
 }
 
 #[test]
@@ -366,7 +366,7 @@ fn test_unwrap_str() {
     let opt = Some(x);
     let y = opt.unwrap();
     let addr_y = str::as_buf(y, |buf, _len| buf);
-    fail_unless!(addr_x == addr_y);
+    assert!(addr_x == addr_y);
 }
 
 #[test]
@@ -392,7 +392,7 @@ fn test_unwrap_resource() {
         let opt = Some(x);
         let _y = opt.unwrap();
     }
-    fail_unless!(*i == 1);
+    assert!(*i == 1);
 }
 
 #[test]
@@ -403,8 +403,8 @@ fn test_option_dance() {
     for x.each |_x| {
         y2 = y.swap_unwrap();
     }
-    fail_unless!(y2 == 5);
-    fail_unless!(y.is_none());
+    assert!(y2 == 5);
+    assert!(y.is_none());
 }
 #[test] #[should_fail] #[ignore(cfg(windows))]
 fn test_option_too_much_dance() {
@@ -424,15 +424,15 @@ fn test_option_while_some() {
             None
         }
     }
-    fail_unless!(i == 11);
+    assert!(i == 11);
 }
 
 #[test]
 fn test_get_or_zero() {
     let some_stuff = Some(42);
-    fail_unless!(some_stuff.get_or_zero() == 42);
+    assert!(some_stuff.get_or_zero() == 42);
     let no_stuff: Option<int> = None;
-    fail_unless!(no_stuff.get_or_zero() == 0);
+    assert!(no_stuff.get_or_zero() == 0);
 }
 
 // Local Variables:
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index fa10f39c90d..7dbc1773994 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -222,7 +222,7 @@ pub fn env() -> ~[(~str,~str)] {
                 for str::each_splitn_char(*p, '=', 1) |s| { vs.push(s.to_owned()) }
                 debug!("splitting: len: %u",
                     vs.len());
-                fail_unless!(vs.len() == 2);
+                assert!(vs.len() == 2);
                 pairs.push((copy vs[0], copy vs[1]));
             }
             pairs
@@ -366,7 +366,7 @@ pub fn waitpid(pid: pid_t) -> c_int {
         use libc::funcs::posix01::wait::*;
         let mut status = 0 as c_int;
 
-        fail_unless!((waitpid(pid, &mut status, 0 as c_int) !=
+        assert!((waitpid(pid, &mut status, 0 as c_int) !=
                      (-1 as c_int)));
         return status;
     }
@@ -380,7 +380,7 @@ pub fn pipe() -> Pipe {
     unsafe {
         let mut fds = Pipe {in: 0 as c_int,
                         out: 0 as c_int };
-        fail_unless!((libc::pipe(&mut fds.in) == (0 as c_int)));
+        assert!((libc::pipe(&mut fds.in) == (0 as c_int)));
         return Pipe {in: fds.in, out: fds.out};
     }
 }
@@ -399,9 +399,9 @@ pub fn pipe() -> Pipe {
                     out: 0 as c_int };
         let res = libc::pipe(&mut fds.in, 1024 as ::libc::c_uint,
                              (libc::O_BINARY | libc::O_NOINHERIT) as c_int);
-        fail_unless!((res == 0 as c_int));
-        fail_unless!((fds.in != -1 as c_int && fds.in != 0 as c_int));
-        fail_unless!((fds.out != -1 as c_int && fds.in != 0 as c_int));
+        assert!((res == 0 as c_int));
+        assert!((fds.in != -1 as c_int && fds.in != 0 as c_int));
+        assert!((fds.out != -1 as c_int && fds.in != 0 as c_int));
         return Pipe {in: fds.in, out: fds.out};
     }
 }
@@ -1277,13 +1277,13 @@ mod tests {
     #[test]
     pub fn test_args() {
         let a = real_args();
-        fail_unless!(a.len() >= 1);
+        assert!(a.len() >= 1);
     }
 
     fn make_rand_name() -> ~str {
         let rng: @rand::Rng = rand::Rng();
         let n = ~"TEST" + rng.gen_str(10u);
-        fail_unless!(getenv(n).is_none());
+        assert!(getenv(n).is_none());
         n
     }
 
@@ -1291,7 +1291,7 @@ mod tests {
     fn test_setenv() {
         let n = make_rand_name();
         setenv(n, ~"VALUE");
-        fail_unless!(getenv(n) == option::Some(~"VALUE"));
+        assert!(getenv(n) == option::Some(~"VALUE"));
     }
 
     #[test]
@@ -1301,9 +1301,9 @@ mod tests {
         let n = make_rand_name();
         setenv(n, ~"1");
         setenv(n, ~"2");
-        fail_unless!(getenv(n) == option::Some(~"2"));
+        assert!(getenv(n) == option::Some(~"2"));
         setenv(n, ~"");
-        fail_unless!(getenv(n) == option::Some(~""));
+        assert!(getenv(n) == option::Some(~""));
     }
 
     // Windows GetEnvironmentVariable requires some extra work to make sure
@@ -1318,25 +1318,25 @@ mod tests {
         let n = make_rand_name();
         setenv(n, s);
         debug!(copy s);
-        fail_unless!(getenv(n) == option::Some(s));
+        assert!(getenv(n) == option::Some(s));
     }
 
     #[test]
     fn test_self_exe_path() {
         let path = os::self_exe_path();
-        fail_unless!(path.is_some());
+        assert!(path.is_some());
         let path = path.get();
         debug!(copy path);
 
         // Hard to test this function
-        fail_unless!(path.is_absolute);
+        assert!(path.is_absolute);
     }
 
     #[test]
     #[ignore]
     fn test_env_getenv() {
         let e = env();
-        fail_unless!(vec::len(e) > 0u);
+        assert!(vec::len(e) > 0u);
         for vec::each(e) |p| {
             let (n, v) = copy *p;
             debug!(copy n);
@@ -1344,7 +1344,7 @@ mod tests {
             // MingW seems to set some funky environment variables like
             // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned
             // from env() but not visible from getenv().
-            fail_unless!(v2.is_none() || v2 == option::Some(v));
+            assert!(v2.is_none() || v2 == option::Some(v));
         }
     }
 
@@ -1354,15 +1354,15 @@ mod tests {
 
         let mut e = env();
         setenv(n, ~"VALUE");
-        fail_unless!(!vec::contains(e, &(copy n, ~"VALUE")));
+        assert!(!vec::contains(e, &(copy n, ~"VALUE")));
 
         e = env();
-        fail_unless!(vec::contains(e, &(n, ~"VALUE")));
+        assert!(vec::contains(e, &(n, ~"VALUE")));
     }
 
     #[test]
     fn test() {
-        fail_unless!((!Path("test-path").is_absolute));
+        assert!((!Path("test-path").is_absolute));
 
         debug!(~"Current working directory: " + getcwd().to_str());
 
@@ -1376,10 +1376,10 @@ mod tests {
         let oldhome = getenv(~"HOME");
 
         setenv(~"HOME", ~"/home/MountainView");
-        fail_unless!(os::homedir() == Some(Path("/home/MountainView")));
+        assert!(os::homedir() == Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"");
-        fail_unless!(os::homedir().is_none());
+        assert!(os::homedir().is_none());
 
         for oldhome.each |s| { setenv(~"HOME", *s) }
     }
@@ -1394,19 +1394,19 @@ mod tests {
         setenv(~"HOME", ~"");
         setenv(~"USERPROFILE", ~"");
 
-        fail_unless!(os::homedir().is_none());
+        assert!(os::homedir().is_none());
 
         setenv(~"HOME", ~"/home/MountainView");
-        fail_unless!(os::homedir() == Some(Path("/home/MountainView")));
+        assert!(os::homedir() == Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"");
 
         setenv(~"USERPROFILE", ~"/home/MountainView");
-        fail_unless!(os::homedir() == Some(Path("/home/MountainView")));
+        assert!(os::homedir() == Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"/home/MountainView");
         setenv(~"USERPROFILE", ~"/home/PaloAlto");
-        fail_unless!(os::homedir() == Some(Path("/home/MountainView")));
+        assert!(os::homedir() == Some(Path("/home/MountainView")));
 
         oldhome.each(|s| {setenv(~"HOME", *s);true});
         olduserprofile.each(|s| {setenv(~"USERPROFILE", *s);true});
@@ -1414,7 +1414,7 @@ mod tests {
 
     #[test]
     fn tmpdir() {
-        fail_unless!(!str::is_empty(os::tmpdir().to_str()));
+        assert!(!str::is_empty(os::tmpdir().to_str()));
     }
 
     // Issue #712
@@ -1427,7 +1427,7 @@ mod tests {
     fn list_dir() {
         let dirs = os::list_dir(&Path("."));
         // Just assuming that we've got some contents in the current directory
-        fail_unless!((vec::len(dirs) > 0u));
+        assert!((vec::len(dirs) > 0u));
 
         for vec::each(dirs) |dir| {
             debug!(copy *dir);
@@ -1436,22 +1436,22 @@ mod tests {
 
     #[test]
     fn path_is_dir() {
-        fail_unless!((os::path_is_dir(&Path("."))));
-        fail_unless!((!os::path_is_dir(&Path("test/stdtest/fs.rs"))));
+        assert!((os::path_is_dir(&Path("."))));
+        assert!((!os::path_is_dir(&Path("test/stdtest/fs.rs"))));
     }
 
     #[test]
     fn path_exists() {
-        fail_unless!((os::path_exists(&Path("."))));
-        fail_unless!((!os::path_exists(&Path(
+        assert!((os::path_exists(&Path("."))));
+        assert!((!os::path_exists(&Path(
                      "test/nonexistent-bogus-path"))));
     }
 
     #[test]
     fn copy_file_does_not_exist() {
-      fail_unless!(!os::copy_file(&Path("test/nonexistent-bogus-path"),
+      assert!(!os::copy_file(&Path("test/nonexistent-bogus-path"),
                             &Path("test/other-bogus-path")));
-      fail_unless!(!os::path_exists(&Path("test/other-bogus-path")));
+      assert!(!os::path_exists(&Path("test/other-bogus-path")));
     }
 
     #[test]
@@ -1459,7 +1459,7 @@ mod tests {
         unsafe {
           let tempdir = getcwd(); // would like to use $TMPDIR,
                                   // doesn't seem to work on Linux
-          fail_unless!((str::len(tempdir.to_str()) > 0u));
+          assert!((str::len(tempdir.to_str()) > 0u));
           let in = tempdir.push("in.txt");
           let out = tempdir.push("out.txt");
 
@@ -1469,24 +1469,24 @@ mod tests {
                     libc::fopen(fromp, modebuf)
                 }
           };
-          fail_unless!((ostream as uint != 0u));
+          assert!((ostream as uint != 0u));
           let s = ~"hello";
           let mut buf = str::to_bytes(s) + ~[0 as u8];
           do vec::as_mut_buf(buf) |b, _len| {
-              fail_unless!((libc::fwrite(b as *c_void, 1u as size_t,
+              assert!((libc::fwrite(b as *c_void, 1u as size_t,
                                    (str::len(s) + 1u) as size_t, ostream)
                       == buf.len() as size_t))
           }
-          fail_unless!((libc::fclose(ostream) == (0u as c_int)));
+          assert!((libc::fclose(ostream) == (0u as c_int)));
           let rs = os::copy_file(&in, &out);
           if (!os::path_exists(&in)) {
             fail!(fmt!("%s doesn't exist", in.to_str()));
           }
-          fail_unless!((rs));
+          assert!((rs));
           let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]);
-          fail_unless!((rslt == 0));
-          fail_unless!((remove_file(&in)));
-          fail_unless!((remove_file(&out)));
+          assert!((rslt == 0));
+          assert!((remove_file(&in)));
+          assert!((remove_file(&out)));
         }
     }
 }
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index 3d06809a452..7de0f355dd2 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -440,7 +440,7 @@ impl GenericPath for PosixPath {
 
     fn with_filename(&self, f: &str) -> PosixPath {
         unsafe {
-            fail_unless!(! str::any(f, |c| windows::is_sep(c as u8)));
+            assert!(! str::any(f, |c| windows::is_sep(c as u8)));
             self.dir_path().push(f)
         }
     }
@@ -485,7 +485,7 @@ impl GenericPath for PosixPath {
     }
 
     fn push_rel(&self, other: &PosixPath) -> PosixPath {
-        fail_unless!(!other.is_absolute);
+        assert!(!other.is_absolute);
         self.push_many(other.components)
     }
 
@@ -657,7 +657,7 @@ impl GenericPath for WindowsPath {
     }
 
     fn with_filename(&self, f: &str) -> WindowsPath {
-        fail_unless!(! str::any(f, |c| windows::is_sep(c as u8)));
+        assert!(! str::any(f, |c| windows::is_sep(c as u8)));
         self.dir_path().push(f)
     }
 
@@ -704,7 +704,7 @@ impl GenericPath for WindowsPath {
     }
 
     fn push_rel(&self, other: &WindowsPath) -> WindowsPath {
-        fail_unless!(!other.is_absolute);
+        assert!(!other.is_absolute);
         self.push_many(other.components)
     }
 
@@ -891,30 +891,30 @@ mod tests {
         let path = PosixPath("tmp/");
         let path = path.push("/hmm");
         let path = path.normalize();
-        fail_unless!(~"tmp/hmm" == path.to_str());
+        assert!(~"tmp/hmm" == path.to_str());
 
         let path = WindowsPath("tmp/");
         let path = path.push("/hmm");
         let path = path.normalize();
-        fail_unless!(~"tmp\\hmm" == path.to_str());
+        assert!(~"tmp\\hmm" == path.to_str());
     }
 
     #[test]
     fn test_filetype_foo_bar() {
         let wp = PosixPath("foo.bar");
-        fail_unless!(wp.filetype() == Some(~".bar"));
+        assert!(wp.filetype() == Some(~".bar"));
 
         let wp = WindowsPath("foo.bar");
-        fail_unless!(wp.filetype() == Some(~".bar"));
+        assert!(wp.filetype() == Some(~".bar"));
     }
 
     #[test]
     fn test_filetype_foo() {
         let wp = PosixPath("foo");
-        fail_unless!(wp.filetype() == None);
+        assert!(wp.filetype() == None);
 
         let wp = WindowsPath("foo");
-        fail_unless!(wp.filetype() == None);
+        assert!(wp.filetype() == None);
     }
 
     #[test]
@@ -925,7 +925,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                fail_unless!(ss == sss);
+                assert!(ss == sss);
             }
         }
 
@@ -983,7 +983,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                fail_unless!(ss == sss);
+                assert!(ss == sss);
             }
         }
 
@@ -999,42 +999,42 @@ mod tests {
 
     #[test]
     fn test_extract_unc_prefixes() {
-        fail_unless!(windows::extract_unc_prefix("\\\\").is_none());
-        fail_unless!(windows::extract_unc_prefix("//").is_none());
-        fail_unless!(windows::extract_unc_prefix("\\\\hi").is_none());
-        fail_unless!(windows::extract_unc_prefix("//hi").is_none());
-        fail_unless!(windows::extract_unc_prefix("\\\\hi\\") ==
+        assert!(windows::extract_unc_prefix("\\\\").is_none());
+        assert!(windows::extract_unc_prefix("//").is_none());
+        assert!(windows::extract_unc_prefix("\\\\hi").is_none());
+        assert!(windows::extract_unc_prefix("//hi").is_none());
+        assert!(windows::extract_unc_prefix("\\\\hi\\") ==
             Some((~"hi", ~"\\")));
-        fail_unless!(windows::extract_unc_prefix("//hi\\") ==
+        assert!(windows::extract_unc_prefix("//hi\\") ==
             Some((~"hi", ~"\\")));
-        fail_unless!(windows::extract_unc_prefix("\\\\hi\\there") ==
+        assert!(windows::extract_unc_prefix("\\\\hi\\there") ==
             Some((~"hi", ~"\\there")));
-        fail_unless!(windows::extract_unc_prefix("//hi/there") ==
+        assert!(windows::extract_unc_prefix("//hi/there") ==
             Some((~"hi", ~"/there")));
-        fail_unless!(windows::extract_unc_prefix(
+        assert!(windows::extract_unc_prefix(
             "\\\\hi\\there\\friends.txt") ==
             Some((~"hi", ~"\\there\\friends.txt")));
-        fail_unless!(windows::extract_unc_prefix(
+        assert!(windows::extract_unc_prefix(
             "//hi\\there\\friends.txt") ==
             Some((~"hi", ~"\\there\\friends.txt")));
     }
 
     #[test]
     fn test_extract_drive_prefixes() {
-        fail_unless!(windows::extract_drive_prefix("c").is_none());
-        fail_unless!(windows::extract_drive_prefix("c:") ==
+        assert!(windows::extract_drive_prefix("c").is_none());
+        assert!(windows::extract_drive_prefix("c:") ==
                      Some((~"c", ~"")));
-        fail_unless!(windows::extract_drive_prefix("d:") ==
+        assert!(windows::extract_drive_prefix("d:") ==
                      Some((~"d", ~"")));
-        fail_unless!(windows::extract_drive_prefix("z:") ==
+        assert!(windows::extract_drive_prefix("z:") ==
                      Some((~"z", ~"")));
-        fail_unless!(windows::extract_drive_prefix("c:\\hi") ==
+        assert!(windows::extract_drive_prefix("c:\\hi") ==
                      Some((~"c", ~"\\hi")));
-        fail_unless!(windows::extract_drive_prefix("d:hi") ==
+        assert!(windows::extract_drive_prefix("d:hi") ==
                      Some((~"d", ~"hi")));
-        fail_unless!(windows::extract_drive_prefix("c:hi\\there.txt") ==
+        assert!(windows::extract_drive_prefix("c:hi\\there.txt") ==
                      Some((~"c", ~"hi\\there.txt")));
-        fail_unless!(windows::extract_drive_prefix("c:\\hi\\there.txt") ==
+        assert!(windows::extract_drive_prefix("c:\\hi\\there.txt") ==
                      Some((~"c", ~"\\hi\\there.txt")));
     }
 
@@ -1046,7 +1046,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                fail_unless!(ss == sss);
+                assert!(ss == sss);
             }
         }
 
@@ -1131,9 +1131,9 @@ mod tests {
 
     #[test]
     fn test_windows_path_restrictions() {
-        fail_unless!(WindowsPath("hi").is_restricted() == false);
-        fail_unless!(WindowsPath("C:\\NUL").is_restricted() == true);
-        fail_unless!(WindowsPath("C:\\COM1.TXT").is_restricted() == true);
-        fail_unless!(WindowsPath("c:\\prn.exe").is_restricted() == true);
+        assert!(WindowsPath("hi").is_restricted() == false);
+        assert!(WindowsPath("C:\\NUL").is_restricted() == true);
+        assert!(WindowsPath("C:\\COM1.TXT").is_restricted() == true);
+        assert!(WindowsPath("c:\\prn.exe").is_restricted() == true);
     }
 }
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 132ac11566d..18f8030d5b8 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -153,7 +153,7 @@ pub impl PacketHeader {
     unsafe fn mark_blocked(&self, this: *rust_task) -> State {
         rustrt::rust_task_ref(this);
         let old_task = swap_task(&mut self.blocked_task, this);
-        fail_unless!(old_task.is_null());
+        assert!(old_task.is_null());
         swap_state_acq(&mut self.state, Blocked)
     }
 
@@ -175,7 +175,7 @@ pub impl PacketHeader {
     // continuum. It ends making multiple unique pointers to the same
     // thing. You'll proobably want to forget them when you're done.
     unsafe fn buf_header(&self) -> ~BufferHeader {
-        fail_unless!(self.buffer.is_not_null());
+        assert!(self.buffer.is_not_null());
         reinterpret_cast(&self.buffer)
     }
 
@@ -379,8 +379,8 @@ pub fn send<T,Tbuffer>(p: SendPacketBuffered<T,Tbuffer>, payload: T) -> bool {
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &*p_ };
-    fail_unless!(ptr::addr_of(&(p.header)) == header);
-    fail_unless!(p.payload.is_none());
+    assert!(ptr::addr_of(&(p.header)) == header);
+    assert!(p.payload.is_none());
     p.payload = Some(payload);
     let old_state = swap_state_rel(&mut p.header.state, Full);
     match old_state {
@@ -482,7 +482,7 @@ pub fn try_recv<T:Owned,Tbuffer:Owned>(p: RecvPacketBuffered<T, Tbuffer>)
     debug!("blocked = %x this = %x old_task = %x",
            p.header.blocked_task as uint,
            this as uint, old_task as uint);
-    fail_unless!(old_task.is_null());
+    assert!(old_task.is_null());
     let mut first = true;
     let mut count = SPIN_COUNT;
     loop {
@@ -527,7 +527,7 @@ pub fn try_recv<T:Owned,Tbuffer:Owned>(p: RecvPacketBuffered<T, Tbuffer>)
           Terminated => {
             // This assert detects when we've accidentally unsafely
             // casted too big of a number to a state.
-            fail_unless!(old_state == Terminated);
+            assert!(old_state == Terminated);
 
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
@@ -576,7 +576,7 @@ fn sender_terminate<T:Owned>(p: *Packet<T>) {
         fail!(~"you dun goofed")
       }
       Terminated => {
-        fail_unless!(p.header.blocked_task.is_null());
+        assert!(p.header.blocked_task.is_null());
         // I have to clean up, use drop_glue
       }
     }
@@ -587,7 +587,7 @@ fn receiver_terminate<T:Owned>(p: *Packet<T>) {
     let p = unsafe { &*p };
     match swap_state_rel(&mut p.header.state, Terminated) {
       Empty => {
-        fail_unless!(p.header.blocked_task.is_null());
+        assert!(p.header.blocked_task.is_null());
         // the sender will clean up
       }
       Blocked => {
@@ -595,12 +595,12 @@ fn receiver_terminate<T:Owned>(p: *Packet<T>) {
         if !old_task.is_null() {
             unsafe {
                 rustrt::rust_task_deref(old_task);
-                fail_unless!(old_task == rustrt::rust_get_task());
+                assert!(old_task == rustrt::rust_get_task());
             }
         }
       }
       Terminated | Full => {
-        fail_unless!(p.header.blocked_task.is_null());
+        assert!(p.header.blocked_task.is_null());
         // I have to clean up, use drop_glue
       }
     }
@@ -663,7 +663,7 @@ pub fn wait_many<T: Selectable>(pkts: &[T]) -> uint {
     debug!("%?, %?", ready_packet, pkts[ready_packet]);
 
     unsafe {
-        fail_unless!((*pkts[ready_packet].header()).state == Full
+        assert!((*pkts[ready_packet].header()).state == Full
                      || (*pkts[ready_packet].header()).state == Terminated);
     }
 
@@ -995,6 +995,6 @@ pub mod test {
             let _chan = chan;
         }
 
-        fail_unless!(!port.peek());
+        assert!(!port.peek());
     }
 }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index ecc60f61e18..fc95e320013 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -352,29 +352,29 @@ pub fn test() {
         let mut p = Pair {fst: 10, snd: 20};
         let pptr: *mut Pair = &mut p;
         let iptr: *mut int = cast::reinterpret_cast(&pptr);
-        fail_unless!((*iptr == 10));;
+        assert!((*iptr == 10));;
         *iptr = 30;
-        fail_unless!((*iptr == 30));
-        fail_unless!((p.fst == 30));;
+        assert!((*iptr == 30));
+        assert!((p.fst == 30));;
 
         *pptr = Pair {fst: 50, snd: 60};
-        fail_unless!((*iptr == 50));
-        fail_unless!((p.fst == 50));
-        fail_unless!((p.snd == 60));
+        assert!((*iptr == 50));
+        assert!((p.fst == 50));
+        assert!((p.snd == 60));
 
         let mut v0 = ~[32000u16, 32001u16, 32002u16];
         let mut v1 = ~[0u16, 0u16, 0u16];
 
         copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 1u),
                     offset(vec::raw::to_ptr(v0), 1u), 1u);
-        fail_unless!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
+        assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16));
         copy_memory(vec::raw::to_mut_ptr(v1),
                     offset(vec::raw::to_ptr(v0), 2u), 1u);
-        fail_unless!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
+        assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
                       v1[2] == 0u16));
         copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 2u),
                     vec::raw::to_ptr(v0), 1u);
-        fail_unless!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
+        assert!((v1[0] == 32002u16 && v1[1] == 32001u16 &&
                       v1[2] == 32000u16));
     }
 }
@@ -386,11 +386,11 @@ pub fn test_position() {
 
     let s = ~"hello";
     unsafe {
-        fail_unless!(2u == as_c_str(s, |p| position(p,
+        assert!(2u == as_c_str(s, |p| position(p,
             |c| *c == 'l' as c_char)));
-        fail_unless!(4u == as_c_str(s, |p| position(p,
+        assert!(4u == as_c_str(s, |p| position(p,
             |c| *c == 'o' as c_char)));
-        fail_unless!(5u == as_c_str(s, |p| position(p,
+        assert!(5u == as_c_str(s, |p| position(p,
             |c| *c == 0 as c_char)));
     }
 }
@@ -405,8 +405,8 @@ pub fn test_buf_len() {
             do str::as_c_str(s2) |p2| {
                 let v = ~[p0, p1, p2, null()];
                 do vec::as_imm_buf(v) |vp, len| {
-                    fail_unless!(unsafe { buf_len(vp) } == 3u);
-                    fail_unless!(len == 4u);
+                    assert!(unsafe { buf_len(vp) } == 3u);
+                    assert!(len == 4u);
                 }
             }
         }
@@ -416,20 +416,20 @@ pub fn test_buf_len() {
 #[test]
 pub fn test_is_null() {
    let p: *int = null();
-   fail_unless!(p.is_null());
-   fail_unless!(!p.is_not_null());
+   assert!(p.is_null());
+   assert!(!p.is_not_null());
 
    let q = offset(p, 1u);
-   fail_unless!(!q.is_null());
-   fail_unless!(q.is_not_null());
+   assert!(!q.is_null());
+   assert!(q.is_not_null());
 
    let mp: *mut int = mut_null();
-   fail_unless!(mp.is_null());
-   fail_unless!(!mp.is_not_null());
+   assert!(mp.is_null());
+   assert!(!mp.is_not_null());
 
    let mq = mp.offset(1u);
-   fail_unless!(!mq.is_null());
-   fail_unless!(mq.is_not_null());
+   assert!(!mq.is_null());
+   assert!(mq.is_not_null());
 }
 
 #[cfg(test)]
@@ -462,11 +462,11 @@ pub mod ptr_tests {
                 debug!(
                     "test_ptr_array_each e: %s, a: %s",
                          expected, actual);
-                fail_unless!(actual == expected);
+                assert!(actual == expected);
                 ctr += 1;
                 iteration_count += 1;
             });
-            fail_unless!(iteration_count == 3u);
+            assert!(iteration_count == 3u);
         }
     }
     #[test]
@@ -494,11 +494,11 @@ pub mod ptr_tests {
                 debug!(
                     "test_ptr_array_each e: %s, a: %s",
                          expected, actual);
-                fail_unless!(actual == expected);
+                assert!(actual == expected);
                 ctr += 1;
                 iteration_count += 1;
             });
-            fail_unless!(iteration_count == 3);
+            assert!(iteration_count == 3);
         }
     }
     #[test]
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index 687d9030d45..a4e53418fc8 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -240,7 +240,7 @@ impl RngUtil for @Rng {
      * failing if start >= end
      */
     fn gen_int_range(&self, start: int, end: int) -> int {
-        fail_unless!(start < end);
+        assert!(start < end);
         start + int::abs(self.gen_int() % (end - start))
     }
 
@@ -274,7 +274,7 @@ impl RngUtil for @Rng {
      * failing if start >= end
      */
     fn gen_uint_range(&self, start: uint, end: uint) -> uint {
-        fail_unless!(start < end);
+        assert!(start < end);
         start + (self.gen_uint() % (end - start))
     }
 
@@ -326,7 +326,7 @@ impl RngUtil for @Rng {
      * Return a char randomly chosen from chars, failing if chars is empty
      */
     fn gen_char_from(&self, chars: &str) -> char {
-        fail_unless!(!chars.is_empty());
+        assert!(!chars.is_empty());
         let mut cs = ~[];
         for str::each_char(chars) |c| { cs.push(c) }
         self.choose(cs)
@@ -582,7 +582,7 @@ pub mod tests {
         let seed = rand::seed();
         let ra = rand::seeded_rng(seed);
         let rb = rand::seeded_rng(seed);
-        fail_unless!(ra.gen_str(100u) == rb.gen_str(100u));
+        assert!(ra.gen_str(100u) == rb.gen_str(100u));
     }
 
     #[test]
@@ -591,7 +591,7 @@ pub mod tests {
         let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
         let ra = rand::seeded_rng(seed);
         let rb = rand::seeded_rng(seed);
-        fail_unless!(ra.gen_str(100u) == rb.gen_str(100u));
+        assert!(ra.gen_str(100u) == rb.gen_str(100u));
     }
 
     #[test]
@@ -601,7 +601,7 @@ pub mod tests {
         // Regression test that isaac is actually using the above vector
         let r = ra.next();
         error!("%?", r);
-        fail_unless!(r == 890007737u32 // on x86_64
+        assert!(r == 890007737u32 // on x86_64
                      || r == 2935188040u32); // on x86
     }
 
@@ -609,9 +609,9 @@ pub mod tests {
     pub fn gen_int_range() {
         let r = rand::Rng();
         let a = r.gen_int_range(-3, 42);
-        fail_unless!(a >= -3 && a < 42);
-        fail_unless!(r.gen_int_range(0, 1) == 0);
-        fail_unless!(r.gen_int_range(-12, -11) == -12);
+        assert!(a >= -3 && a < 42);
+        assert!(r.gen_int_range(0, 1) == 0);
+        assert!(r.gen_int_range(-12, -11) == -12);
     }
 
     #[test]
@@ -625,9 +625,9 @@ pub mod tests {
     pub fn gen_uint_range() {
         let r = rand::Rng();
         let a = r.gen_uint_range(3u, 42u);
-        fail_unless!(a >= 3u && a < 42u);
-        fail_unless!(r.gen_uint_range(0u, 1u) == 0u);
-        fail_unless!(r.gen_uint_range(12u, 13u) == 12u);
+        assert!(a >= 3u && a < 42u);
+        assert!(r.gen_uint_range(0u, 1u) == 0u);
+        assert!(r.gen_uint_range(12u, 13u) == 12u);
     }
 
     #[test]
@@ -648,8 +648,8 @@ pub mod tests {
     #[test]
     pub fn gen_weighted_bool() {
         let r = rand::Rng();
-        fail_unless!(r.gen_weighted_bool(0u) == true);
-        fail_unless!(r.gen_weighted_bool(1u) == true);
+        assert!(r.gen_weighted_bool(0u) == true);
+        assert!(r.gen_weighted_bool(1u) == true);
     }
 
     #[test]
@@ -658,40 +658,40 @@ pub mod tests {
         debug!(r.gen_str(10u));
         debug!(r.gen_str(10u));
         debug!(r.gen_str(10u));
-        fail_unless!(r.gen_str(0u).len() == 0u);
-        fail_unless!(r.gen_str(10u).len() == 10u);
-        fail_unless!(r.gen_str(16u).len() == 16u);
+        assert!(r.gen_str(0u).len() == 0u);
+        assert!(r.gen_str(10u).len() == 10u);
+        assert!(r.gen_str(16u).len() == 16u);
     }
 
     #[test]
     pub fn gen_bytes() {
         let r = rand::Rng();
-        fail_unless!(r.gen_bytes(0u).len() == 0u);
-        fail_unless!(r.gen_bytes(10u).len() == 10u);
-        fail_unless!(r.gen_bytes(16u).len() == 16u);
+        assert!(r.gen_bytes(0u).len() == 0u);
+        assert!(r.gen_bytes(10u).len() == 10u);
+        assert!(r.gen_bytes(16u).len() == 16u);
     }
 
     #[test]
     pub fn choose() {
         let r = rand::Rng();
-        fail_unless!(r.choose([1, 1, 1]) == 1);
+        assert!(r.choose([1, 1, 1]) == 1);
     }
 
     #[test]
     pub fn choose_option() {
         let r = rand::Rng();
         let x: Option<int> = r.choose_option([]);
-        fail_unless!(x.is_none());
-        fail_unless!(r.choose_option([1, 1, 1]) == Some(1));
+        assert!(x.is_none());
+        assert!(r.choose_option([1, 1, 1]) == Some(1));
     }
 
     #[test]
     pub fn choose_weighted() {
         let r = rand::Rng();
-        fail_unless!(r.choose_weighted(~[
+        assert!(r.choose_weighted(~[
             rand::Weighted { weight: 1u, item: 42 },
         ]) == 42);
-        fail_unless!(r.choose_weighted(~[
+        assert!(r.choose_weighted(~[
             rand::Weighted { weight: 0u, item: 42 },
             rand::Weighted { weight: 1u, item: 43 },
         ]) == 43);
@@ -700,23 +700,23 @@ pub mod tests {
     #[test]
     pub fn choose_weighted_option() {
         let r = rand::Rng();
-        fail_unless!(r.choose_weighted_option(~[
+        assert!(r.choose_weighted_option(~[
             rand::Weighted { weight: 1u, item: 42 },
         ]) == Some(42));
-        fail_unless!(r.choose_weighted_option(~[
+        assert!(r.choose_weighted_option(~[
             rand::Weighted { weight: 0u, item: 42 },
             rand::Weighted { weight: 1u, item: 43 },
         ]) == Some(43));
         let v: Option<int> = r.choose_weighted_option([]);
-        fail_unless!(v.is_none());
+        assert!(v.is_none());
     }
 
     #[test]
     pub fn weighted_vec() {
         let r = rand::Rng();
         let empty: ~[int] = ~[];
-        fail_unless!(r.weighted_vec(~[]) == empty);
-        fail_unless!(r.weighted_vec(~[
+        assert!(r.weighted_vec(~[]) == empty);
+        assert!(r.weighted_vec(~[
             rand::Weighted { weight: 0u, item: 3u },
             rand::Weighted { weight: 1u, item: 2u },
             rand::Weighted { weight: 2u, item: 1u },
@@ -727,16 +727,16 @@ pub mod tests {
     pub fn shuffle() {
         let r = rand::Rng();
         let empty: ~[int] = ~[];
-        fail_unless!(r.shuffle(~[]) == empty);
-        fail_unless!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
+        assert!(r.shuffle(~[]) == empty);
+        assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
     }
 
     #[test]
     pub fn task_rng() {
         let r = rand::task_rng();
         r.gen_int();
-        fail_unless!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
-        fail_unless!(r.gen_uint_range(0u, 1u) == 0u);
+        assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
+        assert!(r.gen_uint_range(0u, 1u) == 0u);
     }
 
     #[test]
diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index de3c81b5361..a51f874f371 100644
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -229,7 +229,7 @@ pub impl ReprVisitor {
         } else if mtbl == 1 {
             // skip, this is ast::m_imm
         } else {
-            fail_unless!(mtbl == 2);
+            assert!(mtbl == 2);
             self.writer.write_str("const ");
         }
     }
@@ -591,7 +591,7 @@ fn test_repr() {
             error!("expected '%s', got '%s'",
                    e, s);
         }
-        fail_unless!(s == e);
+        assert!(s == e);
     }
 
     exact_test(&10, "10");
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 0a2c803ff07..24822f52e1e 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -294,7 +294,7 @@ pub impl<T, E: Copy> Result<T, E> {
  *         else { return ok(x+1u); }
  *     }
  *     map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
- *         fail_unless!(incd == ~[2u, 3u, 4u]);
+ *         assert!(incd == ~[2u, 3u, 4u]);
  *     }
  */
 #[inline(always)]
@@ -337,7 +337,7 @@ pub fn map_opt<T,U:Copy,V:Copy>(
 pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
                 op: &fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
 
-    fail_unless!(vec::same_length(ss, ts));
+    assert!(vec::same_length(ss, ts));
     let n = vec::len(ts);
     let mut vs = vec::with_capacity(n);
     let mut i = 0u;
@@ -360,7 +360,7 @@ pub fn map_vec2<S,T,U:Copy,V:Copy>(ss: &[S], ts: &[T],
 pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
                          op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
 
-    fail_unless!(vec::same_length(ss, ts));
+    assert!(vec::same_length(ss, ts));
     let n = vec::len(ts);
     let mut i = 0u;
     while i < n {
@@ -407,50 +407,50 @@ mod tests {
 
     #[test]
     pub fn chain_success() {
-        fail_unless!(get(&chain(op1(), op2)) == 667u);
+        assert!(get(&chain(op1(), op2)) == 667u);
     }
 
     #[test]
     pub fn chain_failure() {
-        fail_unless!(get_err(&chain(op3(), op2)) == ~"sadface");
+        assert!(get_err(&chain(op3(), op2)) == ~"sadface");
     }
 
     #[test]
     pub fn test_impl_iter() {
         let mut valid = false;
         Ok::<~str, ~str>(~"a").iter(|_x| valid = true);
-        fail_unless!(valid);
+        assert!(valid);
 
         Err::<~str, ~str>(~"b").iter(|_x| valid = false);
-        fail_unless!(valid);
+        assert!(valid);
     }
 
     #[test]
     pub fn test_impl_iter_err() {
         let mut valid = true;
         Ok::<~str, ~str>(~"a").iter_err(|_x| valid = false);
-        fail_unless!(valid);
+        assert!(valid);
 
         valid = false;
         Err::<~str, ~str>(~"b").iter_err(|_x| valid = true);
-        fail_unless!(valid);
+        assert!(valid);
     }
 
     #[test]
     pub fn test_impl_map() {
-        fail_unless!(Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b"));
-        fail_unless!(Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a"));
+        assert!(Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b"));
+        assert!(Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a"));
     }
 
     #[test]
     pub fn test_impl_map_err() {
-        fail_unless!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a"));
-        fail_unless!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b"));
+        assert!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a"));
+        assert!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b"));
     }
 
     #[test]
     pub fn test_get_ref_method() {
         let foo: Result<int, ()> = Ok(100);
-        fail_unless!(*foo.get_ref() == 100);
+        assert!(*foo.get_ref() == 100);
     }
 }
diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs
index 5034ffa3c60..46ea5713e2a 100644
--- a/src/libcore/rt/sched.rs
+++ b/src/libcore/rt/sched.rs
@@ -93,7 +93,7 @@ pub impl Scheduler {
     // That will be important for embedding the runtime into external
     // event loops.
     fn run(~self) -> ~Scheduler {
-        fail_unless!(!self.in_task_context());
+        assert!(!self.in_task_context());
 
         // Give ownership of the scheduler (self) to the thread
         do self.install |scheduler| {
@@ -129,7 +129,7 @@ pub impl Scheduler {
     // * Scheduler-context operations
 
     fn resume_task_from_queue(&mut self) -> bool {
-        fail_unless!(!self.in_task_context());
+        assert!(!self.in_task_context());
 
         let mut self = self;
         match self.task_queue.pop_front() {
@@ -145,7 +145,7 @@ pub impl Scheduler {
     }
 
     fn resume_task_immediately(&mut self, task: ~Task) {
-        fail_unless!(!self.in_task_context());
+        assert!(!self.in_task_context());
 
         rtdebug!("scheduling a task");
 
@@ -153,7 +153,7 @@ pub impl Scheduler {
         self.current_task = Some(task);
         self.swap_in_task();
         // The running task should have passed ownership elsewhere
-        fail_unless!(self.current_task.is_none());
+        assert!(self.current_task.is_none());
 
         // Running tasks may have asked us to do some cleanup
         self.run_cleanup_jobs();
@@ -165,7 +165,7 @@ pub impl Scheduler {
     /// Called by a running task to end execution, after which it will
     /// be recycled by the scheduler for reuse in a new task.
     fn terminate_current_task(&mut self) {
-        fail_unless!(self.in_task_context());
+        assert!(self.in_task_context());
 
         rtdebug!("ending running task");
 
@@ -184,7 +184,7 @@ pub impl Scheduler {
     /// running task.  It gets transmuted to the scheduler's lifetime
     /// and called while the task is blocked.
     fn block_running_task_and_then(&mut self, f: &fn(&mut Scheduler, ~Task)) {
-        fail_unless!(self.in_task_context());
+        assert!(self.in_task_context());
 
         rtdebug!("blocking task");
 
@@ -203,7 +203,7 @@ pub impl Scheduler {
     /// You would want to think hard about doing this, e.g. if there are
     /// pending I/O events it would be a bad idea.
     fn resume_task_from_running_task_direct(&mut self, next_task: ~Task) {
-        fail_unless!(self.in_task_context());
+        assert!(self.in_task_context());
 
         rtdebug!("switching tasks");
 
@@ -255,7 +255,7 @@ pub impl Scheduler {
     }
 
     fn run_cleanup_jobs(&mut self) {
-        fail_unless!(!self.in_task_context());
+        assert!(!self.in_task_context());
         rtdebug!("running cleanup jobs");
 
         while !self.cleanup_jobs.is_empty() {
@@ -273,7 +273,7 @@ pub impl Scheduler {
     // XXX: Hack. This should return &'self mut but I don't know how to
     // make the borrowcheck happy
     fn task_from_last_cleanup_job(&mut self) -> &mut Task {
-        fail_unless!(!self.cleanup_jobs.is_empty());
+        assert!(!self.cleanup_jobs.is_empty());
         let last_job: &'self mut CleanupJob = &mut self.cleanup_jobs[0];
         let last_task: &'self Task = match last_job {
             &RescheduleTask(~ref task) => task,
@@ -358,7 +358,7 @@ impl ThreadLocalScheduler {
         unsafe {
             let key = match self { &ThreadLocalScheduler(key) => key };
             let mut value: *mut c_void = tls::get(key);
-            fail_unless!(value.is_not_null());
+            assert!(value.is_not_null());
             {
                 let value_ptr = &mut value;
                 let sched: &mut ~Scheduler = {
@@ -374,7 +374,7 @@ impl ThreadLocalScheduler {
         unsafe {
             let key = match self { &ThreadLocalScheduler(key) => key };
             let value: *mut c_void = tls::get(key);
-            fail_unless!(value.is_not_null());
+            assert!(value.is_not_null());
             let sched = transmute(value);
             tls::set(key, mut_null());
             return sched;
@@ -430,7 +430,7 @@ fn test_simple_scheduling() {
         };
         sched.task_queue.push_back(task);
         sched.run();
-        fail_unless!(task_ran);
+        assert!(task_ran);
     }
 }
 
@@ -449,7 +449,7 @@ fn test_several_tasks() {
             sched.task_queue.push_back(task);
         }
         sched.run();
-        fail_unless!(task_count == total);
+        assert!(task_count == total);
     }
 }
 
@@ -473,7 +473,7 @@ fn test_swap_tasks() {
         };
         sched.task_queue.push_back(task1);
         sched.run();
-        fail_unless!(count == 3);
+        assert!(count == 3);
     }
 }
 
@@ -492,7 +492,7 @@ fn test_run_a_lot_of_tasks_queued() {
         sched.task_queue.push_back(start_task);
         sched.run();
 
-        fail_unless!(count == MAX);
+        assert!(count == MAX);
 
         fn run_task(count_ptr: *mut int) {
             do Scheduler::local |sched| {
@@ -525,7 +525,7 @@ fn test_run_a_lot_of_tasks_direct() {
         sched.task_queue.push_back(start_task);
         sched.run();
 
-        fail_unless!(count == MAX);
+        assert!(count == MAX);
 
         fn run_task(count_ptr: *mut int) {
             do Scheduler::local |sched| {
@@ -550,9 +550,9 @@ fn test_block_task() {
         let mut sched = ~UvEventLoop::new_scheduler();
         let task = ~do Task::new(&mut sched.stack_pool) {
             do Scheduler::local |sched| {
-                fail_unless!(sched.in_task_context());
+                assert!(sched.in_task_context());
                 do sched.block_running_task_and_then() |sched, task| {
-                    fail_unless!(!sched.in_task_context());
+                    assert!(!sched.in_task_context());
                     sched.task_queue.push_back(task);
                 }
             }
diff --git a/src/libcore/rt/thread_local_storage.rs b/src/libcore/rt/thread_local_storage.rs
index 80635560380..76111328b3a 100644
--- a/src/libcore/rt/thread_local_storage.rs
+++ b/src/libcore/rt/thread_local_storage.rs
@@ -21,12 +21,12 @@ pub type Key = pthread_key_t;
 
 #[cfg(unix)]
 pub unsafe fn create(key: &mut Key) {
-    unsafe { fail_unless!(0 == pthread_key_create(key, null())); }
+    unsafe { assert!(0 == pthread_key_create(key, null())); }
 }
 
 #[cfg(unix)]
 pub unsafe fn set(key: Key, value: *mut c_void) {
-    unsafe { fail_unless!(0 == pthread_setspecific(key, value)); }
+    unsafe { assert!(0 == pthread_setspecific(key, value)); }
 }
 
 #[cfg(unix)]
@@ -58,12 +58,12 @@ pub type Key = DWORD;
 pub unsafe fn create(key: &mut Key) {
     static TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
     *key = unsafe { TlsAlloc() };
-    fail_unless!(*key != TLS_OUT_OF_INDEXES);
+    assert!(*key != TLS_OUT_OF_INDEXES);
 }
 
 #[cfg(windows)]
 pub unsafe fn set(key: Key, value: *mut c_void) {
-    unsafe { fail_unless!(0 != TlsSetValue(key, value)) }
+    unsafe { assert!(0 != TlsSetValue(key, value)) }
 }
 
 #[cfg(windows)]
@@ -88,10 +88,10 @@ fn tls_smoke_test() {
         create(&mut key);
         set(key, transmute(value));
         let value: ~int = transmute(get(key));
-        fail_unless!(value == ~20);
+        assert!(value == ~20);
         let value = ~30;
         set(key, transmute(value));
         let value: ~int = transmute(get(key));
-        fail_unless!(value == ~30);
+        assert!(value == ~30);
     }
 }
diff --git a/src/libcore/rt/uv/file.rs b/src/libcore/rt/uv/file.rs
index 7df06f87dfe..a4aef7485d7 100644
--- a/src/libcore/rt/uv/file.rs
+++ b/src/libcore/rt/uv/file.rs
@@ -25,7 +25,7 @@ impl Request for FsRequest;
 impl FsRequest {
     fn new() -> FsRequest {
         let fs_req = unsafe { malloc_req(UV_FS) };
-        fail_unless!(fs_req.is_not_null());
+        assert!(fs_req.is_not_null());
         let fs_req = fs_req as *uvll::uv_write_t;
         unsafe { uvll::set_data_for_req(fs_req, null::<()>()); }
         NativeHandle::from_native_handle(fs_req)
diff --git a/src/libcore/rt/uv/mod.rs b/src/libcore/rt/uv/mod.rs
index 2bd5023f22f..32757d6376e 100644
--- a/src/libcore/rt/uv/mod.rs
+++ b/src/libcore/rt/uv/mod.rs
@@ -89,7 +89,7 @@ pub struct Loop {
 pub impl Loop {
     fn new() -> Loop {
         let handle = unsafe { uvll::loop_new() };
-        fail_unless!(handle.is_not_null());
+        assert!(handle.is_not_null());
         NativeHandle::from_native_handle(handle)
     }
 
@@ -126,8 +126,8 @@ pub impl IdleWatcher {
     fn new(loop_: &mut Loop) -> IdleWatcher {
         unsafe {
             let handle = uvll::idle_new();
-            fail_unless!(handle.is_not_null());
-            fail_unless!(0 == uvll::idle_init(loop_.native_handle(), handle));
+            assert!(handle.is_not_null());
+            assert!(0 == uvll::idle_init(loop_.native_handle(), handle));
             uvll::set_data_for_uv_handle(handle, null::<()>());
             NativeHandle::from_native_handle(handle)
         }
@@ -137,7 +137,7 @@ pub impl IdleWatcher {
 
         set_watcher_callback(self, cb);
         unsafe {
-            fail_unless!(0 == uvll::idle_start(self.native_handle(), idle_cb))
+            assert!(0 == uvll::idle_start(self.native_handle(), idle_cb))
         };
 
         extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) {
@@ -149,7 +149,7 @@ pub impl IdleWatcher {
     }
 
     fn stop(&mut self) {
-        unsafe { fail_unless!(0 == uvll::idle_stop(self.native_handle())); }
+        unsafe { assert!(0 == uvll::idle_stop(self.native_handle())); }
     }
 
     fn close(self) {
@@ -183,7 +183,7 @@ pub impl UvError {
         unsafe {
             let inner = match self { &UvError(ref a) => a };
             let name_str = uvll::err_name(inner);
-            fail_unless!(name_str.is_not_null());
+            assert!(name_str.is_not_null());
             from_c_str(name_str)
         }
     }
@@ -192,7 +192,7 @@ pub impl UvError {
         unsafe {
             let inner = match self { &UvError(ref a) => a };
             let desc_str = uvll::strerror(inner);
-            fail_unless!(desc_str.is_not_null());
+            assert!(desc_str.is_not_null());
             from_c_str(desc_str)
         }
     }
@@ -208,7 +208,7 @@ impl ToStr for UvError {
 fn error_smoke_test() {
     let err = uvll::uv_err_t { code: 1, sys_errno_: 1 };
     let err: UvError = UvError(err);
-    fail_unless!(err.to_str() == ~"EOF: end of file");
+    assert!(err.to_str() == ~"EOF: end of file");
 }
 
 
@@ -274,7 +274,7 @@ pub fn borrow_callback_from_watcher<H, W: Watcher + NativeHandle<*H>,
     unsafe {
         let handle = watcher.native_handle();
         let handle_data: *c_void = uvll::get_data_for_uv_handle(handle);
-        fail_unless!(handle_data.is_not_null());
+        assert!(handle_data.is_not_null());
         let cb = transmute::<&*c_void, &~CB>(&handle_data);
         return &**cb;
     }
@@ -287,7 +287,7 @@ pub fn take_callback_from_watcher<H, W: Watcher + NativeHandle<*H>, CB: Callback
     unsafe {
         let handle = watcher.native_handle();
         let handle_data: *c_void = uvll::get_data_for_uv_handle(handle);
-        fail_unless!(handle_data.is_not_null());
+        assert!(handle_data.is_not_null());
         uvll::set_data_for_uv_handle(handle, null::<()>());
         let cb: ~CB = transmute::<*c_void, ~CB>(handle_data);
         let cb = match cb { ~cb => cb };
@@ -341,7 +341,7 @@ fn test_slice_to_uv_buf() {
     let slice = [0, .. 20];
     let buf = slice_to_uv_buf(slice);
 
-    fail_unless!(buf.len == 20);
+    assert!(buf.len == 20);
 
     unsafe {
         let base = transmute::<*u8, *mut u8>(buf.base);
@@ -349,8 +349,8 @@ fn test_slice_to_uv_buf() {
         (*ptr::mut_offset(base, 1)) = 2;
     }
 
-    fail_unless!(slice[0] == 1);
-    fail_unless!(slice[1] == 2);
+    assert!(slice[0] == 1);
+    assert!(slice[1] == 2);
 }
 
 /// The uv buffer type
@@ -367,7 +367,7 @@ pub fn slice_to_uv_buf(v: &[u8]) -> Buf {
 /// Transmute an owned vector to a Buf
 pub fn vec_to_uv_buf(v: ~[u8]) -> Buf {
     let data = unsafe { malloc(v.len() as size_t) } as *u8;
-    fail_unless!(data.is_not_null());
+    assert!(data.is_not_null());
     do vec::as_imm_buf(v) |b, l| {
         let data = data as *mut u8;
         unsafe { ptr::copy_memory(data, b, l) }
@@ -416,7 +416,7 @@ fn idle_smoke_test() {
         let count_ptr: *mut int = &mut count;
         do idle_watcher.start |idle_watcher, status| {
             let mut idle_watcher = idle_watcher;
-            fail_unless!(status.is_none());
+            assert!(status.is_none());
             if unsafe { *count_ptr == 10 } {
                 idle_watcher.stop();
                 idle_watcher.close();
@@ -426,7 +426,7 @@ fn idle_smoke_test() {
         }
         loop_.run();
         loop_.close();
-        fail_unless!(count == 10);
+        assert!(count == 10);
     }
 }
 
@@ -437,10 +437,10 @@ fn idle_start_stop_start() {
         let mut idle_watcher = { IdleWatcher::new(&mut loop_) };
         do idle_watcher.start |idle_watcher, status| {
             let mut idle_watcher = idle_watcher;
-            fail_unless!(status.is_none());
+            assert!(status.is_none());
             idle_watcher.stop();
             do idle_watcher.start |idle_watcher, status| {
-                fail_unless!(status.is_none());
+                assert!(status.is_none());
                 let mut idle_watcher = idle_watcher;
                 idle_watcher.stop();
                 idle_watcher.close();
diff --git a/src/libcore/rt/uv/net.rs b/src/libcore/rt/uv/net.rs
index 697b4ad94c1..edd3b379fbc 100644
--- a/src/libcore/rt/uv/net.rs
+++ b/src/libcore/rt/uv/net.rs
@@ -104,7 +104,7 @@ pub impl StreamWatcher {
     fn write(&mut self, msg: ~[u8], cb: ConnectionCallback) {
         // XXX: Borrowck
         let data = get_watcher_data(unsafe { transmute_mut_region(self) });
-        fail_unless!(data.write_cb.is_none());
+        assert!(data.write_cb.is_none());
         data.write_cb = Some(cb);
 
         let req = WriteRequest::new();
@@ -112,7 +112,7 @@ pub impl StreamWatcher {
         // XXX: Allocation
         let bufs = ~[buf];
         unsafe {
-            fail_unless!(0 == uvll::write(req.native_handle(),
+            assert!(0 == uvll::write(req.native_handle(),
                                           self.native_handle(),
                                           &bufs, write_cb));
         }
@@ -133,7 +133,7 @@ pub impl StreamWatcher {
         let self_handle = self.native_handle() as *c_void;
         let stream_handle = stream.native_handle() as *c_void;
         unsafe {
-            fail_unless!(0 == uvll::accept(self_handle, stream_handle));
+            assert!(0 == uvll::accept(self_handle, stream_handle));
         }
     }
 
@@ -141,7 +141,7 @@ pub impl StreamWatcher {
         {
             let mut self = self;
             let data = get_watcher_data(&mut self);
-            fail_unless!(data.close_cb.is_none());
+            assert!(data.close_cb.is_none());
             data.close_cb = Some(cb);
         }
 
@@ -184,8 +184,8 @@ pub impl TcpWatcher {
     fn new(loop_: &mut Loop) -> TcpWatcher {
         unsafe {
             let handle = malloc_handle(UV_TCP);
-            fail_unless!(handle.is_not_null());
-            fail_unless!(0 == uvll::tcp_init(loop_.native_handle(), handle));
+            assert!(handle.is_not_null());
+            assert!(0 == uvll::tcp_init(loop_.native_handle(), handle));
             let mut watcher = NativeHandle::from_native_handle(handle);
             install_watcher_data(&mut watcher);
             return watcher;
@@ -200,7 +200,7 @@ pub impl TcpWatcher {
                         uvll::tcp_bind(self.native_handle(), addr)
                     };
                     // XXX: bind is likely to fail. need real error handling
-                    fail_unless!(result == 0);
+                    assert!(result == 0);
                 }
             }
             _ => fail!()
@@ -209,7 +209,7 @@ pub impl TcpWatcher {
 
     fn connect(&mut self, address: IpAddr, cb: ConnectionCallback) {
         unsafe {
-            fail_unless!(get_watcher_data(self).connect_cb.is_none());
+            assert!(get_watcher_data(self).connect_cb.is_none());
             get_watcher_data(self).connect_cb = Some(cb);
 
             let mut connect_watcher = ConnectRequest::new();
@@ -218,7 +218,7 @@ pub impl TcpWatcher {
                 Ipv4(*) => {
                     do ip4_as_uv_ip4(address) |addr| {
                         rtdebug!("connect_t: %x", connect_handle as uint);
-                        fail_unless!(0 == uvll::tcp_connect(connect_handle,
+                        assert!(0 == uvll::tcp_connect(connect_handle,
                                                             self.native_handle(),
                                                             addr, connect_cb));
                     }
@@ -244,13 +244,13 @@ pub impl TcpWatcher {
     fn listen(&mut self, cb: ConnectionCallback) {
         // XXX: Borrowck
         let data = get_watcher_data(unsafe { transmute_mut_region(self) });
-        fail_unless!(data.connect_cb.is_none());
+        assert!(data.connect_cb.is_none());
         data.connect_cb = Some(cb);
 
         unsafe {
             static BACKLOG: c_int = 128; // XXX should be configurable
             // XXX: This can probably fail
-            fail_unless!(0 == uvll::listen(self.native_handle(),
+            assert!(0 == uvll::listen(self.native_handle(),
                                            BACKLOG, connection_cb));
         }
 
@@ -291,7 +291,7 @@ impl ConnectRequest {
         let connect_handle = unsafe {
             malloc_req(UV_CONNECT)
         };
-        fail_unless!(connect_handle.is_not_null());
+        assert!(connect_handle.is_not_null());
         let connect_handle = connect_handle as *uvll::uv_connect_t;
         ConnectRequest(connect_handle)
     }
@@ -328,7 +328,7 @@ pub impl WriteRequest {
         let write_handle = unsafe {
             malloc_req(UV_WRITE)
         };
-        fail_unless!(write_handle.is_not_null());
+        assert!(write_handle.is_not_null());
         let write_handle = write_handle as *uvll::uv_write_t;
         WriteRequest(write_handle)
     }
@@ -365,8 +365,8 @@ fn connect_close() {
         let addr = Ipv4(127, 0, 0, 1, 2923);
         do tcp_watcher.connect(addr) |stream_watcher, status| {
             rtdebug!("tcp_watcher.connect!");
-            fail_unless!(status.is_some());
-            fail_unless!(status.get().name() == ~"ECONNREFUSED");
+            assert!(status.is_some());
+            assert!(status.get().name() == ~"ECONNREFUSED");
             stream_watcher.close(||());
         }
         loop_.run();
@@ -384,7 +384,7 @@ fn connect_read() {
         do tcp_watcher.connect(addr) |stream_watcher, status| {
             let mut stream_watcher = stream_watcher;
             rtdebug!("tcp_watcher.connect!");
-            fail_unless!(status.is_none());
+            assert!(status.is_none());
             let alloc: AllocCallback = |size| {
                 vec_to_uv_buf(vec::from_elem(size, 0))
             };
@@ -421,7 +421,7 @@ fn listen() {
         rtdebug!("listening");
         do server_tcp_watcher.listen |server_stream_watcher, status| {
             rtdebug!("listened!");
-            fail_unless!(status.is_none());
+            assert!(status.is_none());
             let mut server_stream_watcher = server_stream_watcher;
             let mut loop_ = loop_;
             let mut client_tcp_watcher = TcpWatcher::new(&mut loop_);
@@ -443,12 +443,12 @@ fn listen() {
                     rtdebug!("got %d bytes", nread);
                     let buf = buf.unwrap();
                     for buf.slice(0, nread as uint).each |byte| {
-                        fail_unless!(*byte == count as u8);
+                        assert!(*byte == count as u8);
                         rtdebug!("%u", *byte as uint);
                         count += 1;
                     }
                 } else {
-                    fail_unless!(count == MAX);
+                    assert!(count == MAX);
                     do stream_watcher.close {
                         server_stream_watcher.close(||());
                     }
@@ -463,12 +463,12 @@ fn listen() {
             let mut tcp_watcher = { TcpWatcher::new(&mut loop_) };
             do tcp_watcher.connect(addr) |stream_watcher, status| {
                 rtdebug!("connecting");
-                fail_unless!(status.is_none());
+                assert!(status.is_none());
                 let mut stream_watcher = stream_watcher;
                 let msg = ~[0, 1, 2, 3, 4, 5, 6 ,7 ,8, 9];
                 do stream_watcher.write(msg) |stream_watcher, status| {
                     rtdebug!("writing");
-                    fail_unless!(status.is_none());
+                    assert!(status.is_none());
                     stream_watcher.close(||());
                 }
             }
diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs
index bcad67c0c94..37f29d1a5c0 100644
--- a/src/libcore/rt/uvio.rs
+++ b/src/libcore/rt/uvio.rs
@@ -59,7 +59,7 @@ impl EventLoop for UvEventLoop {
     fn callback(&mut self, f: ~fn()) {
         let mut idle_watcher =  IdleWatcher::new(self.uvio.uv_loop());
         do idle_watcher.start |idle_watcher, status| {
-            fail_unless!(status.is_none());
+            assert!(status.is_none());
             let mut idle_watcher = idle_watcher;
             idle_watcher.stop();
             idle_watcher.close();
@@ -82,7 +82,7 @@ fn test_callback_run_once() {
             unsafe { *count_ptr += 1 }
         }
         event_loop.run();
-        fail_unless!(count == 1);
+        assert!(count == 1);
     }
 }
 
@@ -105,13 +105,13 @@ impl IoFactory for UvIoFactory {
         let result_cell_ptr: *Cell<Option<~StreamObject>> = &result_cell;
 
         do Scheduler::local |scheduler| {
-            fail_unless!(scheduler.in_task_context());
+            assert!(scheduler.in_task_context());
 
             // Block this task and take ownership, switch to scheduler context
             do scheduler.block_running_task_and_then |scheduler, task| {
 
                 rtdebug!("connect: entered scheduler context");
-                fail_unless!(!scheduler.in_task_context());
+                assert!(!scheduler.in_task_context());
                 let mut tcp_watcher = TcpWatcher::new(self.uv_loop());
                 let task_cell = Cell(task);
 
@@ -138,7 +138,7 @@ impl IoFactory for UvIoFactory {
             }
         }
 
-        fail_unless!(!result_cell.is_empty());
+        assert!(!result_cell.is_empty());
         return result_cell.take();
     }
 
@@ -179,7 +179,7 @@ impl TcpListener for UvTcpListener {
         let server_tcp_watcher = self.watcher();
 
         do Scheduler::local |scheduler| {
-            fail_unless!(scheduler.in_task_context());
+            assert!(scheduler.in_task_context());
 
             do scheduler.block_running_task_and_then |_, task| {
                 let task_cell = Cell(task);
@@ -208,7 +208,7 @@ impl TcpListener for UvTcpListener {
             }
         }
 
-        fail_unless!(!result_cell.is_empty());
+        assert!(!result_cell.is_empty());
         return result_cell.take();
     }
 }
@@ -244,12 +244,12 @@ impl Stream for UvStream {
         let result_cell_ptr: *Cell<Result<uint, ()>> = &result_cell;
 
         do Scheduler::local |scheduler| {
-            fail_unless!(scheduler.in_task_context());
+            assert!(scheduler.in_task_context());
             let watcher = self.watcher();
             let buf_ptr: *&mut [u8] = &buf;
             do scheduler.block_running_task_and_then |scheduler, task| {
                 rtdebug!("read: entered scheduler context");
-                fail_unless!(!scheduler.in_task_context());
+                assert!(!scheduler.in_task_context());
                 let mut watcher = watcher;
                 let task_cell = Cell(task);
                 // XXX: We shouldn't reallocate these callbacks every
@@ -267,7 +267,7 @@ impl Stream for UvStream {
                     watcher.read_stop();
 
                     let result = if status.is_none() {
-                        fail_unless!(nread >= 0);
+                        assert!(nread >= 0);
                         Ok(nread as uint)
                     } else {
                         Err(())
@@ -282,7 +282,7 @@ impl Stream for UvStream {
             }
         }
 
-        fail_unless!(!result_cell.is_empty());
+        assert!(!result_cell.is_empty());
         return result_cell.take();
     }
 
@@ -290,7 +290,7 @@ impl Stream for UvStream {
         let result_cell = empty_cell();
         let result_cell_ptr: *Cell<Result<(), ()>> = &result_cell;
         do Scheduler::local |scheduler| {
-            fail_unless!(scheduler.in_task_context());
+            assert!(scheduler.in_task_context());
             let watcher = self.watcher();
             let buf_ptr: *&[u8] = &buf;
             do scheduler.block_running_task_and_then |_, task| {
@@ -315,7 +315,7 @@ impl Stream for UvStream {
             }
         }
 
-        fail_unless!(!result_cell.is_empty());
+        assert!(!result_cell.is_empty());
         return result_cell.take();
     }
 }
@@ -330,7 +330,7 @@ fn test_simple_io_no_connect() {
                 let io = sched.event_loop.io().unwrap();
                 let addr = Ipv4(127, 0, 0, 1, 2926);
                 let maybe_chan = io.connect(addr);
-                fail_unless!(maybe_chan.is_none());
+                assert!(maybe_chan.is_none());
             }
         };
         sched.task_queue.push_back(task);
@@ -361,10 +361,10 @@ fn test_simple_tcp_server_and_client() {
                 let mut stream = listener.listen().unwrap();
                 let mut buf = [0, .. 2048];
                 let nread = stream.read(buf).unwrap();
-                fail_unless!(nread == 8);
+                assert!(nread == 8);
                 for uint::range(0, nread) |i| {
                     rtdebug!("%u", buf[i] as uint);
-                    fail_unless!(buf[i] == i as u8);
+                    assert!(buf[i] == i as u8);
                 }
                 stream.close();
                 listener.close();
@@ -411,7 +411,7 @@ fn test_read_and_block() {
                     let nread = stream.read(buf).unwrap();
                     for uint::range(0, nread) |i| {
                         let val = buf[i] as uint;
-                        fail_unless!(val == current % 8);
+                        assert!(val == current % 8);
                         current += 1;
                     }
                     reads += 1;
@@ -427,7 +427,7 @@ fn test_read_and_block() {
                 }
 
                 // Make sure we had multiple reads
-                fail_unless!(reads > 1);
+                assert!(reads > 1);
 
                 stream.close();
                 listener.close();
diff --git a/src/libcore/rt/uvll.rs b/src/libcore/rt/uvll.rs
index 4eaf9dcf40a..640a69743ba 100644
--- a/src/libcore/rt/uvll.rs
+++ b/src/libcore/rt/uvll.rs
@@ -97,10 +97,10 @@ pub enum uv_req_type {
 }
 
 pub unsafe fn malloc_handle(handle: uv_handle_type) -> *c_void {
-    fail_unless!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX);
+    assert!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX);
     let size = unsafe { rust_uv_handle_size(handle as uint) };
     let p = malloc(size);
-    fail_unless!(p.is_not_null());
+    assert!(p.is_not_null());
     return p;
 }
 
@@ -109,10 +109,10 @@ pub unsafe fn free_handle(v: *c_void) {
 }
 
 pub unsafe fn malloc_req(req: uv_req_type) -> *c_void {
-    fail_unless!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX);
+    assert!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX);
     let size = unsafe { rust_uv_req_size(req as uint) };
     let p = malloc(size);
-    fail_unless!(p.is_not_null());
+    assert!(p.is_not_null());
     return p;
 }
 
@@ -123,14 +123,14 @@ pub unsafe fn free_req(v: *c_void) {
 #[test]
 fn handle_sanity_check() {
     unsafe {
-        fail_unless!(UV_HANDLE_TYPE_MAX as uint == rust_uv_handle_type_max());
+        assert!(UV_HANDLE_TYPE_MAX as uint == rust_uv_handle_type_max());
     }
 }
 
 #[test]
 fn request_sanity_check() {
     unsafe {
-        fail_unless!(UV_REQ_TYPE_MAX as uint == rust_uv_req_type_max());
+        assert!(UV_REQ_TYPE_MAX as uint == rust_uv_req_type_max());
     }
 }
 
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index 959ab23a461..8116ea952e4 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -495,7 +495,7 @@ mod tests {
 
         debug!(copy expected);
         debug!(copy actual);
-        fail_unless!((expected == actual));
+        assert!((expected == actual));
     }
 
     #[test]
@@ -504,7 +504,7 @@ mod tests {
                                      &None, &None,
                                      0i32, 0i32, 0i32);
         let status = run::waitpid(pid);
-        fail_unless!(status == 1);
+        assert!(status == 1);
     }
 
 }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index f73202e16ed..c54a1048c46 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -45,7 +45,7 @@ Section: Creating a string
  * Fails if invalid UTF-8
  */
 pub fn from_bytes(vv: &const [u8]) -> ~str {
-    fail_unless!(is_utf8(vv));
+    assert!(is_utf8(vv));
     return unsafe { raw::from_bytes(vv) };
 }
 
@@ -75,7 +75,7 @@ impl ToStr for @str {
  * Fails if invalid UTF-8
  */
 pub fn from_byte(b: u8) -> ~str {
-    fail_unless!(b < 128u8);
+    assert!(b < 128u8);
     unsafe { ::cast::transmute(~[b, 0u8]) }
 }
 
@@ -264,7 +264,7 @@ Section: Adding to and removing from a string
  */
 pub fn pop_char(s: &mut ~str) -> char {
     let end = len(*s);
-    fail_unless!(end > 0u);
+    assert!(end > 0u);
     let CharRange {ch, next} = char_range_at_reverse(*s, end);
     unsafe { raw::set_len(s, next); }
     return ch;
@@ -429,8 +429,8 @@ pub fn substr<'a>(s: &'a str, begin: uint, n: uint) -> &'a str {
  * the last character of the string
  */
 pub fn slice<'a>(s: &'a str, begin: uint, end: uint) -> &'a str {
-    fail_unless!(is_char_boundary(s, begin));
-    fail_unless!(is_char_boundary(s, end));
+    assert!(is_char_boundary(s, begin));
+    assert!(is_char_boundary(s, end));
     unsafe { raw::slice_bytes(s, begin, end) }
 }
 
@@ -554,7 +554,7 @@ fn each_split_inner<'a>(s: &'a str,
 // See Issue #1932 for why this is a naive search
 fn iter_matches<'a,'b>(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
     let sep_len = len(sep), l = len(s);
-    fail_unless!(sep_len > 0u);
+    assert!(sep_len > 0u);
     let mut i = 0u, match_start = 0u, match_i = 0u;
 
     while i < l {
@@ -598,7 +598,7 @@ fn iter_between_matches<'a,'b>(s: &'a str,
  * ~~~
  * let mut v = ~[];
  * for each_split_str(".XXX.YYY.", ".") |subs| { v.push(subs); }
- * fail_unless!(v == ["", "XXX", "YYY", ""]);
+ * assert!(v == ["", "XXX", "YYY", ""]);
  * ~~~
  */
 pub fn each_split_str<'a,'b>(s: &'a str,
@@ -1179,8 +1179,8 @@ pub fn find_char_from(s: &str, c: char, start: uint) -> Option<uint> {
 pub fn find_char_between(s: &str, c: char, start: uint, end: uint)
     -> Option<uint> {
     if c < 128u as char {
-        fail_unless!(start <= end);
-        fail_unless!(end <= len(s));
+        assert!(start <= end);
+        assert!(end <= len(s));
         let mut i = start;
         let b = c as u8;
         while i < end {
@@ -1257,8 +1257,8 @@ pub fn rfind_char_from(s: &str, c: char, start: uint) -> Option<uint> {
  */
 pub fn rfind_char_between(s: &str, c: char, start: uint, end: uint) -> Option<uint> {
     if c < 128u as char {
-        fail_unless!(start >= end);
-        fail_unless!(start <= len(s));
+        assert!(start >= end);
+        assert!(start <= len(s));
         let mut i = start;
         let b = c as u8;
         while i > end {
@@ -1337,9 +1337,9 @@ pub fn find_from(s: &str, start: uint, f: &fn(char)
  * boundary, as defined by `is_char_boundary`.
  */
 pub fn find_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) -> Option<uint> {
-    fail_unless!(start <= end);
-    fail_unless!(end <= len(s));
-    fail_unless!(is_char_boundary(s, start));
+    assert!(start <= end);
+    assert!(end <= len(s));
+    assert!(is_char_boundary(s, start));
     let mut i = start;
     while i < end {
         let CharRange {ch, next} = char_range_at(s, i);
@@ -1414,9 +1414,9 @@ pub fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option<uint> {
  * boundary, as defined by `is_char_boundary`
  */
 pub fn rfind_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) -> Option<uint> {
-    fail_unless!(start >= end);
-    fail_unless!(start <= len(s));
-    fail_unless!(is_char_boundary(s, start));
+    assert!(start >= end);
+    assert!(start <= len(s));
+    assert!(is_char_boundary(s, start));
     let mut i = start;
     while i > end {
         let CharRange {ch, next: prev} = char_range_at_reverse(s, i);
@@ -1502,7 +1502,7 @@ pub fn find_str_between<'a,'b>(haystack: &'a str,
                                end:uint)
                             -> Option<uint> {
     // See Issue #1932 for why this is a naive search
-    fail_unless!(end <= len(haystack));
+    assert!(end <= len(haystack));
     let needle_len = len(needle);
     if needle_len == 0u { return Some(start); }
     if needle_len > end { return None; }
@@ -1664,11 +1664,11 @@ pub fn to_utf16(s: &str) -> ~[u16] {
             if (ch & 0xFFFF_u32) == ch {
                 // The BMP falls through (assuming non-surrogate, as it
                 // should)
-                fail_unless!(ch <= 0xD7FF_u32 || ch >= 0xE000_u32);
+                assert!(ch <= 0xD7FF_u32 || ch >= 0xE000_u32);
                 u.push(ch as u16)
             } else {
                 // Supplementary planes break into surrogates.
-                fail_unless!(ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32);
+                assert!(ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32);
                 ch -= 0x1_0000_u32;
                 let w1 = 0xD800_u16 | ((ch >> 10) as u16);
                 let w2 = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16);
@@ -1691,8 +1691,8 @@ pub fn utf16_chars(v: &[u16], f: &fn(char)) {
 
         } else {
             let u2 = v[i+1u];
-            fail_unless!(u >= 0xD800_u16 && u <= 0xDBFF_u16);
-            fail_unless!(u2 >= 0xDC00_u16 && u2 <= 0xDFFF_u16);
+            assert!(u >= 0xD800_u16 && u <= 0xDBFF_u16);
+            assert!(u2 >= 0xDC00_u16 && u2 <= 0xDFFF_u16);
             let mut c = (u - 0xD800_u16) as char;
             c = c << 10;
             c |= (u2 - 0xDC00_u16) as char;
@@ -1732,8 +1732,8 @@ pub fn with_capacity(capacity: uint) -> ~str {
  * The number of Unicode characters in `s` between the given indices.
  */
 pub fn count_chars(s: &str, start: uint, end: uint) -> uint {
-    fail_unless!(is_char_boundary(s, start));
-    fail_unless!(is_char_boundary(s, end));
+    assert!(is_char_boundary(s, start));
+    assert!(is_char_boundary(s, end));
     let mut i = start, len = 0u;
     while i < end {
         let next = char_range_at(s, i).next;
@@ -1745,11 +1745,11 @@ pub fn count_chars(s: &str, start: uint, end: uint) -> uint {
 
 /// Counts the number of bytes taken by the `n` in `s` starting from `start`.
 pub fn count_bytes<'b>(s: &'b str, start: uint, n: uint) -> uint {
-    fail_unless!(is_char_boundary(s, start));
+    assert!(is_char_boundary(s, start));
     let mut end = start, cnt = n;
     let l = len(s);
     while cnt > 0u {
-        fail_unless!(end < l);
+        assert!(end < l);
         let next = char_range_at(s, end).next;
         cnt -= 1u;
         end = next;
@@ -1832,14 +1832,14 @@ pub fn is_char_boundary(s: &str, index: uint) -> bool {
 pub fn char_range_at(s: &str, i: uint) -> CharRange {
     let b0 = s[i];
     let w = utf8_char_width(b0);
-    fail_unless!((w != 0u));
+    assert!((w != 0u));
     if w == 1u { return CharRange {ch: b0 as char, next: i + 1u}; }
     let mut val = 0u;
     let end = i + w;
     let mut i = i + 1u;
     while i < end {
         let byte = s[i];
-        fail_unless!((byte & 192u8 == tag_cont_u8));
+        assert!((byte & 192u8 == tag_cont_u8));
         val <<= 6u;
         val += (byte & 63u8) as uint;
         i += 1u;
@@ -1910,7 +1910,7 @@ pub fn char_at_reverse(s: &str, i: uint) -> char {
  */
 pub fn all_between(s: &str, start: uint, end: uint,
                     it: &fn(char) -> bool) -> bool {
-    fail_unless!(is_char_boundary(s, start));
+    assert!(is_char_boundary(s, start));
     let mut i = start;
     while i < end {
         let CharRange {ch, next} = char_range_at(s, i);
@@ -2010,7 +2010,7 @@ pub fn as_bytes_slice<'a>(s: &'a str) -> &'a [u8] {
 pub fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T {
     do as_buf(s) |buf, len| {
         // NB: len includes the trailing null.
-        fail_unless!(len > 0);
+        assert!(len > 0);
         if unsafe { *(ptr::offset(buf,len-1)) != 0 } {
             as_c_str(from_slice(s), f)
         } else {
@@ -2090,7 +2090,7 @@ pub fn reserve_at_least(s: &mut ~str, n: uint) {
 pub fn capacity(s: &const ~str) -> uint {
     do as_bytes(s) |buf| {
         let vcap = vec::capacity(buf);
-        fail_unless!(vcap > 0u);
+        assert!(vcap > 0u);
         vcap - 1u
     }
 }
@@ -2147,7 +2147,7 @@ pub mod raw {
         vec::raw::set_len(&mut v, len);
         v.push(0u8);
 
-        fail_unless!(is_utf8(v));
+        assert!(is_utf8(v));
         return ::cast::transmute(v);
     }
 
@@ -2175,7 +2175,7 @@ pub mod raw {
     pub unsafe fn buf_as_slice<T>(buf: *u8, len: uint,
                               f: &fn(v: &str) -> T) -> T {
         let v = (buf, len + 1);
-        fail_unless!(is_utf8(::cast::reinterpret_cast(&v)));
+        assert!(is_utf8(::cast::reinterpret_cast(&v)));
         f(::cast::transmute(v))
     }
 
@@ -2191,8 +2191,8 @@ pub mod raw {
      */
     pub unsafe fn slice_bytes_unique(s: &str, begin: uint, end: uint) -> ~str {
         do as_buf(s) |sbuf, n| {
-            fail_unless!((begin <= end));
-            fail_unless!((end <= n));
+            assert!((begin <= end));
+            assert!((end <= n));
 
             let mut v = vec::with_capacity(end - begin + 1u);
             unsafe {
@@ -2221,8 +2221,8 @@ pub mod raw {
     #[inline]
     pub unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> &str {
         do as_buf(s) |sbuf, n| {
-             fail_unless!((begin <= end));
-             fail_unless!((end <= n));
+             assert!((begin <= end));
+             assert!((end <= n));
 
              let tuple = (ptr::offset(sbuf, begin), end - begin + 1);
              ::cast::reinterpret_cast(&tuple)
@@ -2250,7 +2250,7 @@ pub mod raw {
     /// Removes the last byte from a string and returns it. (Not UTF-8 safe).
     pub unsafe fn pop_byte(s: &mut ~str) -> u8 {
         let len = len(*s);
-        fail_unless!((len > 0u));
+        assert!((len > 0u));
         let b = s[len - 1u];
         unsafe { set_len(s, len - 1u) };
         return b;
@@ -2259,7 +2259,7 @@ pub mod raw {
     /// Removes the first byte from a string and returns it. (Not UTF-8 safe).
     pub unsafe fn shift_byte(s: &mut ~str) -> u8 {
         let len = len(*s);
-        fail_unless!((len > 0u));
+        assert!((len > 0u));
         let b = s[0];
         *s = unsafe { raw::slice_bytes_unique(*s, 1u, len) };
         return b;
@@ -2281,7 +2281,7 @@ pub mod raw {
             let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
             let b = vec::raw::to_ptr(a);
             let c = from_buf_len(b, 3u);
-            fail_unless!((c == ~"AAA"));
+            assert!((c == ~"AAA"));
         }
     }
 
@@ -2572,69 +2572,69 @@ mod tests {
 
     #[test]
     fn test_eq() {
-        fail_unless!((eq(&~"", &~"")));
-        fail_unless!((eq(&~"foo", &~"foo")));
-        fail_unless!((!eq(&~"foo", &~"bar")));
+        assert!((eq(&~"", &~"")));
+        assert!((eq(&~"foo", &~"foo")));
+        assert!((!eq(&~"foo", &~"bar")));
     }
 
     #[test]
     fn test_eq_slice() {
-        fail_unless!((eq_slice(slice("foobar", 0, 3), "foo")));
-        fail_unless!((eq_slice(slice("barfoo", 3, 6), "foo")));
-        fail_unless!((!eq_slice("foo1", "foo2")));
+        assert!((eq_slice(slice("foobar", 0, 3), "foo")));
+        assert!((eq_slice(slice("barfoo", 3, 6), "foo")));
+        assert!((!eq_slice("foo1", "foo2")));
     }
 
     #[test]
     fn test_le() {
-        fail_unless!((le(&"", &"")));
-        fail_unless!((le(&"", &"foo")));
-        fail_unless!((le(&"foo", &"foo")));
-        fail_unless!((!eq(&~"foo", &~"bar")));
+        assert!((le(&"", &"")));
+        assert!((le(&"", &"foo")));
+        assert!((le(&"foo", &"foo")));
+        assert!((!eq(&~"foo", &~"bar")));
     }
 
     #[test]
     fn test_len() {
-        fail_unless!((len(~"") == 0u));
-        fail_unless!((len(~"hello world") == 11u));
-        fail_unless!((len(~"\x63") == 1u));
-        fail_unless!((len(~"\xa2") == 2u));
-        fail_unless!((len(~"\u03c0") == 2u));
-        fail_unless!((len(~"\u2620") == 3u));
-        fail_unless!((len(~"\U0001d11e") == 4u));
+        assert!((len(~"") == 0u));
+        assert!((len(~"hello world") == 11u));
+        assert!((len(~"\x63") == 1u));
+        assert!((len(~"\xa2") == 2u));
+        assert!((len(~"\u03c0") == 2u));
+        assert!((len(~"\u2620") == 3u));
+        assert!((len(~"\U0001d11e") == 4u));
 
-        fail_unless!((char_len(~"") == 0u));
-        fail_unless!((char_len(~"hello world") == 11u));
-        fail_unless!((char_len(~"\x63") == 1u));
-        fail_unless!((char_len(~"\xa2") == 1u));
-        fail_unless!((char_len(~"\u03c0") == 1u));
-        fail_unless!((char_len(~"\u2620") == 1u));
-        fail_unless!((char_len(~"\U0001d11e") == 1u));
-        fail_unless!((char_len(~"ประเทศไทย中华Việt Nam") == 19u));
+        assert!((char_len(~"") == 0u));
+        assert!((char_len(~"hello world") == 11u));
+        assert!((char_len(~"\x63") == 1u));
+        assert!((char_len(~"\xa2") == 1u));
+        assert!((char_len(~"\u03c0") == 1u));
+        assert!((char_len(~"\u2620") == 1u));
+        assert!((char_len(~"\U0001d11e") == 1u));
+        assert!((char_len(~"ประเทศไทย中华Việt Nam") == 19u));
     }
 
     #[test]
     fn test_rfind_char() {
-        fail_unless!(rfind_char(~"hello", 'l') == Some(3u));
-        fail_unless!(rfind_char(~"hello", 'o') == Some(4u));
-        fail_unless!(rfind_char(~"hello", 'h') == Some(0u));
-        fail_unless!(rfind_char(~"hello", 'z').is_none());
-        fail_unless!(rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u));
+        assert!(rfind_char(~"hello", 'l') == Some(3u));
+        assert!(rfind_char(~"hello", 'o') == Some(4u));
+        assert!(rfind_char(~"hello", 'h') == Some(0u));
+        assert!(rfind_char(~"hello", 'z').is_none());
+        assert!(rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u));
     }
 
     #[test]
     fn test_pop_char() {
         let mut data = ~"ประเทศไทย中华";
         let cc = pop_char(&mut data);
-        fail_unless!(~"ประเทศไทย中" == data);
-        fail_unless!('华' == cc);
+        assert!(~"ประเทศไทย中" == data);
+        assert!('华' == cc);
     }
 
     #[test]
     fn test_pop_char_2() {
         let mut data2 = ~"华";
         let cc2 = pop_char(&mut data2);
-        fail_unless!(~"" == data2);
-        fail_unless!('华' == cc2);
+        assert!(~"" == data2);
+        assert!('华' == cc2);
     }
 
     #[test]
@@ -2652,7 +2652,7 @@ mod tests {
             let mut v = ~[];
             for each_split_char(s, c) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]);
         t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]);
@@ -2670,7 +2670,7 @@ mod tests {
             let mut v = ~[];
             for each_split_char(s, c) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         let data = ~"ประเทศไทย中华Việt Nam";
         t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]);
@@ -2685,7 +2685,7 @@ mod tests {
             for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
             debug!("comparing vs. %?", u);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         t(~"abc.hello.there", '.', 0u, ~[~"abc.hello.there"]);
         t(~"abc.hello.there", '.', 1u, ~[~"abc", ~"hello.there"]);
@@ -2712,7 +2712,7 @@ mod tests {
             for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
             debug!("comparing vs. %?", u);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
 
         t(~"ประเทศไทย中华Việt Nam", '华', 1u, ~[~"ประเทศไทย中", ~"Việt Nam"]);
@@ -2731,7 +2731,7 @@ mod tests {
             for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
             debug!("comparing vs. %?", u);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         let data = ~"ประเทศไทย中华Việt Nam";
         t(data, 'V', 1u, ~[~"ประเทศไทย中华", ~"iệt Nam"]);
@@ -2745,7 +2745,7 @@ mod tests {
             let mut v = ~[];
             for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]);
         t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]);
@@ -2764,7 +2764,7 @@ mod tests {
             let mut v = ~[];
             for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) }
             debug!("split_byte to: %?", v);
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         let data = ~"ประเทศไทย中华Việt Nam";
         t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]);
@@ -2776,7 +2776,7 @@ mod tests {
         fn t<'a>(s: &str, sep: &'a str, u: &[~str]) {
             let mut v = ~[];
             for each_split_str(s, sep) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         t(~"--1233345--", ~"12345", ~[~"--1233345--"]);
         t(~"abc::hello::there", ~"::", ~[~"abc", ~"hello", ~"there"]);
@@ -2800,7 +2800,7 @@ mod tests {
         fn t(s: &str, sepf: &fn(char) -> bool, u: &[~str]) {
             let mut v = ~[];
             for each_split(s, sepf) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
 
         t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]);
@@ -2816,7 +2816,7 @@ mod tests {
         fn t(s: &str, sepf: &fn(char) -> bool, u: &[~str]) {
             let mut v = ~[];
             for each_split_no_trailing(s, sepf) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
 
         t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]);
@@ -2835,7 +2835,7 @@ mod tests {
         fn t(s: &str, f: &fn(&str, &fn(&str) -> bool), u: &[~str]) {
             let mut v = ~[];
             for f(s) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
 
         t(lf, each_line ,~[~"", ~"Mary had a little lamb", ~"Little lamb"]);
@@ -2855,7 +2855,7 @@ mod tests {
         fn t(s: &str, f: &fn(&str, &fn(&str) -> bool), u: &[~str]) {
             let mut v = ~[];
             for f(s) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         let data = ~"\nMary had a little lamb\nLittle lamb\n";
 
@@ -2869,7 +2869,7 @@ mod tests {
         fn t(s: &str, i: uint, u: &[~str]) {
             let mut v = ~[];
             for each_split_within(s, i) |s| { v.push(s.to_owned()) }
-            fail_unless!(vec::all2(v, u, |a,b| a == b));
+            assert!(vec::all2(v, u, |a,b| a == b));
         }
         t(~"", 0, ~[]);
         t(~"", 15, ~[]);
@@ -2881,59 +2881,59 @@ mod tests {
     #[test]
     fn test_find_str() {
         // byte positions
-        fail_unless!(find_str(~"banana", ~"apple pie").is_none());
-        fail_unless!(find_str(~"", ~"") == Some(0u));
+        assert!(find_str(~"banana", ~"apple pie").is_none());
+        assert!(find_str(~"", ~"") == Some(0u));
 
         let data = ~"ประเทศไทย中华Việt Nam";
-        fail_unless!(find_str(data, ~"")     == Some(0u));
-        fail_unless!(find_str(data, ~"ประเ") == Some( 0u));
-        fail_unless!(find_str(data, ~"ะเ")   == Some( 6u));
-        fail_unless!(find_str(data, ~"中华") == Some(27u));
-        fail_unless!(find_str(data, ~"ไท华").is_none());
+        assert!(find_str(data, ~"")     == Some(0u));
+        assert!(find_str(data, ~"ประเ") == Some( 0u));
+        assert!(find_str(data, ~"ะเ")   == Some( 6u));
+        assert!(find_str(data, ~"中华") == Some(27u));
+        assert!(find_str(data, ~"ไท华").is_none());
     }
 
     #[test]
     fn test_find_str_between() {
         // byte positions
-        fail_unless!(find_str_between(~"", ~"", 0u, 0u) == Some(0u));
+        assert!(find_str_between(~"", ~"", 0u, 0u) == Some(0u));
 
         let data = ~"abcabc";
-        fail_unless!(find_str_between(data, ~"ab", 0u, 6u) == Some(0u));
-        fail_unless!(find_str_between(data, ~"ab", 2u, 6u) == Some(3u));
-        fail_unless!(find_str_between(data, ~"ab", 2u, 4u).is_none());
+        assert!(find_str_between(data, ~"ab", 0u, 6u) == Some(0u));
+        assert!(find_str_between(data, ~"ab", 2u, 6u) == Some(3u));
+        assert!(find_str_between(data, ~"ab", 2u, 4u).is_none());
 
         let mut data = ~"ประเทศไทย中华Việt Nam";
         data = data + data;
-        fail_unless!(find_str_between(data, ~"", 0u, 43u) == Some(0u));
-        fail_unless!(find_str_between(data, ~"", 6u, 43u) == Some(6u));
+        assert!(find_str_between(data, ~"", 0u, 43u) == Some(0u));
+        assert!(find_str_between(data, ~"", 6u, 43u) == Some(6u));
 
-        fail_unless!(find_str_between(data, ~"ประ", 0u, 43u) == Some( 0u));
-        fail_unless!(find_str_between(data, ~"ทศไ", 0u, 43u) == Some(12u));
-        fail_unless!(find_str_between(data, ~"ย中", 0u, 43u) == Some(24u));
-        fail_unless!(find_str_between(data, ~"iệt", 0u, 43u) == Some(34u));
-        fail_unless!(find_str_between(data, ~"Nam", 0u, 43u) == Some(40u));
+        assert!(find_str_between(data, ~"ประ", 0u, 43u) == Some( 0u));
+        assert!(find_str_between(data, ~"ทศไ", 0u, 43u) == Some(12u));
+        assert!(find_str_between(data, ~"ย中", 0u, 43u) == Some(24u));
+        assert!(find_str_between(data, ~"iệt", 0u, 43u) == Some(34u));
+        assert!(find_str_between(data, ~"Nam", 0u, 43u) == Some(40u));
 
-        fail_unless!(find_str_between(data, ~"ประ", 43u, 86u) == Some(43u));
-        fail_unless!(find_str_between(data, ~"ทศไ", 43u, 86u) == Some(55u));
-        fail_unless!(find_str_between(data, ~"ย中", 43u, 86u) == Some(67u));
-        fail_unless!(find_str_between(data, ~"iệt", 43u, 86u) == Some(77u));
-        fail_unless!(find_str_between(data, ~"Nam", 43u, 86u) == Some(83u));
+        assert!(find_str_between(data, ~"ประ", 43u, 86u) == Some(43u));
+        assert!(find_str_between(data, ~"ทศไ", 43u, 86u) == Some(55u));
+        assert!(find_str_between(data, ~"ย中", 43u, 86u) == Some(67u));
+        assert!(find_str_between(data, ~"iệt", 43u, 86u) == Some(77u));
+        assert!(find_str_between(data, ~"Nam", 43u, 86u) == Some(83u));
     }
 
     #[test]
     fn test_substr() {
         fn t(a: &str, b: &str, start: int) {
-            fail_unless!(substr(a, start as uint, len(b)) == b);
+            assert!(substr(a, start as uint, len(b)) == b);
         }
         t("hello", "llo", 2);
         t("hello", "el", 1);
-        fail_unless!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u));
+        assert!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u));
     }
 
     #[test]
     fn test_concat() {
         fn t(v: &[~str], s: &str) {
-            fail_unless!(concat(v) == s.to_str());
+            assert!(concat(v) == s.to_str());
         }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood");
         let v: ~[~str] = ~[];
@@ -2944,7 +2944,7 @@ mod tests {
     #[test]
     fn test_connect() {
         fn t(v: &[~str], sep: &str, s: &str) {
-            fail_unless!(connect(v, sep) == s.to_str());
+            assert!(connect(v, sep) == s.to_str());
         }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"],
           ~" ", ~"you know I'm no good");
@@ -2956,7 +2956,7 @@ mod tests {
     #[test]
     fn test_connect_slices() {
         fn t(v: &[&str], sep: &str, s: &str) {
-            fail_unless!(connect_slices(v, sep) == s.to_str());
+            assert!(connect_slices(v, sep) == s.to_str());
         }
         t(["you", "know", "I'm", "no", "good"],
           " ", "you know I'm no good");
@@ -2966,11 +2966,11 @@ mod tests {
 
     #[test]
     fn test_repeat() {
-        fail_unless!(repeat(~"x", 4) == ~"xxxx");
-        fail_unless!(repeat(~"hi", 4) == ~"hihihihi");
-        fail_unless!(repeat(~"ไท华", 3) == ~"ไท华ไท华ไท华");
-        fail_unless!(repeat(~"", 4) == ~"");
-        fail_unless!(repeat(~"hi", 0) == ~"");
+        assert!(repeat(~"x", 4) == ~"xxxx");
+        assert!(repeat(~"hi", 4) == ~"hihihihi");
+        assert!(repeat(~"ไท华", 3) == ~"ไท华ไท华ไท华");
+        assert!(repeat(~"", 4) == ~"");
+        assert!(repeat(~"hi", 0) == ~"");
     }
 
     #[test]
@@ -2982,24 +2982,24 @@ mod tests {
         let input = ~"abcDEF" + unicode + ~"xyz:.;";
         let expected = ~"ABCDEF" + unicode + ~"XYZ:.;";
         let actual = to_upper(input);
-        fail_unless!(expected == actual);
+        assert!(expected == actual);
     }
 
     #[test]
     fn test_to_lower() {
         unsafe {
-            fail_unless!(~"" == map(~"",
+            assert!(~"" == map(~"",
                 |c| libc::tolower(c as c_char) as char));
-            fail_unless!(~"ymca" == map(~"YMCA",
+            assert!(~"ymca" == map(~"YMCA",
                 |c| libc::tolower(c as c_char) as char));
         }
     }
 
     #[test]
     fn test_unsafe_slice() {
-        fail_unless!("ab" == unsafe {raw::slice_bytes("abc", 0, 2)});
-        fail_unless!("bc" == unsafe {raw::slice_bytes("abc", 1, 3)});
-        fail_unless!("" == unsafe {raw::slice_bytes("abc", 1, 1)});
+        assert!("ab" == unsafe {raw::slice_bytes("abc", 0, 2)});
+        assert!("bc" == unsafe {raw::slice_bytes("abc", 1, 3)});
+        assert!("" == unsafe {raw::slice_bytes("abc", 1, 1)});
         fn a_million_letter_a() -> ~str {
             let mut i = 0;
             let mut rs = ~"";
@@ -3013,44 +3013,44 @@ mod tests {
             rs
         }
         let letters = a_million_letter_a();
-        fail_unless!(half_a_million_letter_a() ==
+        assert!(half_a_million_letter_a() ==
             unsafe {raw::slice_bytes(letters, 0u, 500000)}.to_owned());
     }
 
     #[test]
     fn test_starts_with() {
-        fail_unless!((starts_with(~"", ~"")));
-        fail_unless!((starts_with(~"abc", ~"")));
-        fail_unless!((starts_with(~"abc", ~"a")));
-        fail_unless!((!starts_with(~"a", ~"abc")));
-        fail_unless!((!starts_with(~"", ~"abc")));
+        assert!((starts_with(~"", ~"")));
+        assert!((starts_with(~"abc", ~"")));
+        assert!((starts_with(~"abc", ~"a")));
+        assert!((!starts_with(~"a", ~"abc")));
+        assert!((!starts_with(~"", ~"abc")));
     }
 
     #[test]
     fn test_ends_with() {
-        fail_unless!((ends_with(~"", ~"")));
-        fail_unless!((ends_with(~"abc", ~"")));
-        fail_unless!((ends_with(~"abc", ~"c")));
-        fail_unless!((!ends_with(~"a", ~"abc")));
-        fail_unless!((!ends_with(~"", ~"abc")));
+        assert!((ends_with(~"", ~"")));
+        assert!((ends_with(~"abc", ~"")));
+        assert!((ends_with(~"abc", ~"c")));
+        assert!((!ends_with(~"a", ~"abc")));
+        assert!((!ends_with(~"", ~"abc")));
     }
 
     #[test]
     fn test_is_empty() {
-        fail_unless!((is_empty(~"")));
-        fail_unless!((!is_empty(~"a")));
+        assert!((is_empty(~"")));
+        assert!((!is_empty(~"a")));
     }
 
     #[test]
     fn test_replace() {
         let a = ~"a";
-        fail_unless!(replace(~"", a, ~"b") == ~"");
-        fail_unless!(replace(~"a", a, ~"b") == ~"b");
-        fail_unless!(replace(~"ab", a, ~"b") == ~"bb");
+        assert!(replace(~"", a, ~"b") == ~"");
+        assert!(replace(~"a", a, ~"b") == ~"b");
+        assert!(replace(~"ab", a, ~"b") == ~"bb");
         let test = ~"test";
-        fail_unless!(replace(~" test test ", test, ~"toast") ==
+        assert!(replace(~" test test ", test, ~"toast") ==
             ~" toast toast ");
-        fail_unless!(replace(~" test test ", test, ~"") == ~"   ");
+        assert!(replace(~" test test ", test, ~"") == ~"   ");
     }
 
     #[test]
@@ -3060,7 +3060,7 @@ mod tests {
 
         let a = ~"ประเ";
         let A = ~"دولة الكويتทศไทย中华";
-        fail_unless!((replace(data, a, repl) ==  A));
+        assert!((replace(data, a, repl) ==  A));
     }
 
     #[test]
@@ -3070,7 +3070,7 @@ mod tests {
 
         let b = ~"ะเ";
         let B = ~"ปรدولة الكويتทศไทย中华";
-        fail_unless!((replace(data, b,   repl) ==  B));
+        assert!((replace(data, b,   repl) ==  B));
     }
 
     #[test]
@@ -3080,7 +3080,7 @@ mod tests {
 
         let c = ~"中华";
         let C = ~"ประเทศไทยدولة الكويت";
-        fail_unless!((replace(data, c, repl) ==  C));
+        assert!((replace(data, c, repl) ==  C));
     }
 
     #[test]
@@ -3089,21 +3089,21 @@ mod tests {
         let repl = ~"دولة الكويت";
 
         let d = ~"ไท华";
-        fail_unless!((replace(data, d, repl) == data));
+        assert!((replace(data, d, repl) == data));
     }
 
     #[test]
     fn test_slice() {
-        fail_unless!("ab" == slice("abc", 0, 2));
-        fail_unless!("bc" == slice("abc", 1, 3));
-        fail_unless!("" == slice("abc", 1, 1));
-        fail_unless!("\u65e5" == slice("\u65e5\u672c", 0, 3));
+        assert!("ab" == slice("abc", 0, 2));
+        assert!("bc" == slice("abc", 1, 3));
+        assert!("" == slice("abc", 1, 1));
+        assert!("\u65e5" == slice("\u65e5\u672c", 0, 3));
 
         let data = "ประเทศไทย中华";
-        fail_unless!("ป" == slice(data, 0, 3));
-        fail_unless!("ร" == slice(data, 3, 6));
-        fail_unless!("" == slice(data, 3, 3));
-        fail_unless!("华" == slice(data, 30, 33));
+        assert!("ป" == slice(data, 0, 3));
+        assert!("ร" == slice(data, 3, 6));
+        assert!("" == slice(data, 3, 3));
+        assert!("华" == slice(data, 30, 33));
 
         fn a_million_letter_X() -> ~str {
             let mut i = 0;
@@ -3121,7 +3121,7 @@ mod tests {
             rs
         }
         let letters = a_million_letter_X();
-        fail_unless!(half_a_million_letter_X() ==
+        assert!(half_a_million_letter_X() ==
             slice(letters, 0u, 3u * 500000u).to_owned());
     }
 
@@ -3129,16 +3129,16 @@ mod tests {
     fn test_slice_2() {
         let ss = "中华Việt Nam";
 
-        fail_unless!("华" == slice(ss, 3u, 6u));
-        fail_unless!("Việt Nam" == slice(ss, 6u, 16u));
+        assert!("华" == slice(ss, 3u, 6u));
+        assert!("Việt Nam" == slice(ss, 6u, 16u));
 
-        fail_unless!("ab" == slice("abc", 0u, 2u));
-        fail_unless!("bc" == slice("abc", 1u, 3u));
-        fail_unless!("" == slice("abc", 1u, 1u));
+        assert!("ab" == slice("abc", 0u, 2u));
+        assert!("bc" == slice("abc", 1u, 3u));
+        assert!("" == slice("abc", 1u, 1u));
 
-        fail_unless!("中" == slice(ss, 0u, 3u));
-        fail_unless!("华V" == slice(ss, 3u, 7u));
-        fail_unless!("" == slice(ss, 3u, 3u));
+        assert!("中" == slice(ss, 0u, 3u));
+        assert!("华V" == slice(ss, 3u, 7u));
+        assert!("" == slice(ss, 3u, 3u));
         /*0: 中
           3: 华
           6: V
@@ -3160,101 +3160,101 @@ mod tests {
 
     #[test]
     fn test_trim_left_chars() {
-        fail_unless!(trim_left_chars(" *** foo *** ", ~[]) ==
+        assert!(trim_left_chars(" *** foo *** ", ~[]) ==
                      " *** foo *** ");
-        fail_unless!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
+        assert!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
                      "foo *** ");
-        fail_unless!(trim_left_chars(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_left_chars("foo *** ", ~['*', ' ']) ==
+        assert!(trim_left_chars(" ***  *** ", ~['*', ' ']) == "");
+        assert!(trim_left_chars("foo *** ", ~['*', ' ']) ==
                      "foo *** ");
     }
 
     #[test]
     fn test_trim_right_chars() {
-        fail_unless!(trim_right_chars(" *** foo *** ", ~[]) ==
+        assert!(trim_right_chars(" *** foo *** ", ~[]) ==
                      " *** foo *** ");
-        fail_unless!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
+        assert!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
                      " *** foo");
-        fail_unless!(trim_right_chars(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_right_chars(" *** foo", ~['*', ' ']) ==
+        assert!(trim_right_chars(" ***  *** ", ~['*', ' ']) == "");
+        assert!(trim_right_chars(" *** foo", ~['*', ' ']) ==
                      " *** foo");
     }
 
     #[test]
     fn test_trim_chars() {
-        fail_unless!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** ");
-        fail_unless!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo");
-        fail_unless!(trim_chars(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_chars("foo", ~['*', ' ']) == "foo");
+        assert!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** ");
+        assert!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo");
+        assert!(trim_chars(" ***  *** ", ~['*', ' ']) == "");
+        assert!(trim_chars("foo", ~['*', ' ']) == "foo");
     }
 
     #[test]
     fn test_trim_left() {
-        fail_unless!((trim_left("") == ""));
-        fail_unless!((trim_left("a") == "a"));
-        fail_unless!((trim_left("    ") == ""));
-        fail_unless!((trim_left("     blah") == "blah"));
-        fail_unless!((trim_left("   \u3000  wut") == "wut"));
-        fail_unless!((trim_left("hey ") == "hey "));
+        assert!((trim_left("") == ""));
+        assert!((trim_left("a") == "a"));
+        assert!((trim_left("    ") == ""));
+        assert!((trim_left("     blah") == "blah"));
+        assert!((trim_left("   \u3000  wut") == "wut"));
+        assert!((trim_left("hey ") == "hey "));
     }
 
     #[test]
     fn test_trim_right() {
-        fail_unless!((trim_right("") == ""));
-        fail_unless!((trim_right("a") == "a"));
-        fail_unless!((trim_right("    ") == ""));
-        fail_unless!((trim_right("blah     ") == "blah"));
-        fail_unless!((trim_right("wut   \u3000  ") == "wut"));
-        fail_unless!((trim_right(" hey") == " hey"));
+        assert!((trim_right("") == ""));
+        assert!((trim_right("a") == "a"));
+        assert!((trim_right("    ") == ""));
+        assert!((trim_right("blah     ") == "blah"));
+        assert!((trim_right("wut   \u3000  ") == "wut"));
+        assert!((trim_right(" hey") == " hey"));
     }
 
     #[test]
     fn test_trim() {
-        fail_unless!((trim("") == ""));
-        fail_unless!((trim("a") == "a"));
-        fail_unless!((trim("    ") == ""));
-        fail_unless!((trim("    blah     ") == "blah"));
-        fail_unless!((trim("\nwut   \u3000  ") == "wut"));
-        fail_unless!((trim(" hey dude ") == "hey dude"));
+        assert!((trim("") == ""));
+        assert!((trim("a") == "a"));
+        assert!((trim("    ") == ""));
+        assert!((trim("    blah     ") == "blah"));
+        assert!((trim("\nwut   \u3000  ") == "wut"));
+        assert!((trim(" hey dude ") == "hey dude"));
     }
 
     #[test]
     fn test_is_whitespace() {
-        fail_unless!((is_whitespace(~"")));
-        fail_unless!((is_whitespace(~" ")));
-        fail_unless!((is_whitespace(~"\u2009"))); // Thin space
-        fail_unless!((is_whitespace(~"  \n\t   ")));
-        fail_unless!((!is_whitespace(~"   _   ")));
+        assert!((is_whitespace(~"")));
+        assert!((is_whitespace(~" ")));
+        assert!((is_whitespace(~"\u2009"))); // Thin space
+        assert!((is_whitespace(~"  \n\t   ")));
+        assert!((!is_whitespace(~"   _   ")));
     }
 
     #[test]
     fn test_is_ascii() {
-        fail_unless!((is_ascii(~"")));
-        fail_unless!((is_ascii(~"a")));
-        fail_unless!((!is_ascii(~"\u2009")));
+        assert!((is_ascii(~"")));
+        assert!((is_ascii(~"a")));
+        assert!((!is_ascii(~"\u2009")));
     }
 
     #[test]
     fn test_shift_byte() {
         let mut s = ~"ABC";
         let b = unsafe { raw::shift_byte(&mut s) };
-        fail_unless!((s == ~"BC"));
-        fail_unless!((b == 65u8));
+        assert!((s == ~"BC"));
+        assert!((b == 65u8));
     }
 
     #[test]
     fn test_pop_byte() {
         let mut s = ~"ABC";
         let b = unsafe { raw::pop_byte(&mut s) };
-        fail_unless!((s == ~"AB"));
-        fail_unless!((b == 67u8));
+        assert!((s == ~"AB"));
+        assert!((b == 67u8));
     }
 
     #[test]
     fn test_unsafe_from_bytes() {
         let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
         let b = unsafe { raw::from_bytes(a) };
-        fail_unless!((b == ~"AAAAAAA"));
+        assert!((b == ~"AAAAAAA"));
     }
 
     #[test]
@@ -3271,7 +3271,7 @@ mod tests {
                   0x20_u8, 0x4e_u8, 0x61_u8,
                   0x6d_u8];
 
-        fail_unless!(ss == from_bytes(bb));
+        assert!(ss == from_bytes(bb));
     }
 
     #[test]
@@ -3298,7 +3298,7 @@ mod tests {
             let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
             let b = vec::raw::to_ptr(a);
             let c = raw::from_buf(b);
-            fail_unless!((c == ~"AAAAAAA"));
+            assert!((c == ~"AAAAAAA"));
         }
     }
 
@@ -3314,20 +3314,20 @@ mod tests {
     fn test_as_buf() {
         let a = ~"Abcdefg";
         let b = as_buf(a, |buf, _l| {
-            fail_unless!(unsafe { *buf } == 65u8);
+            assert!(unsafe { *buf } == 65u8);
             100
         });
-        fail_unless!((b == 100));
+        assert!((b == 100));
     }
 
     #[test]
     fn test_as_buf_small() {
         let a = ~"A";
         let b = as_buf(a, |buf, _l| {
-            fail_unless!(unsafe { *buf } == 65u8);
+            assert!(unsafe { *buf } == 65u8);
             100
         });
-        fail_unless!((b == 100));
+        assert!((b == 100));
     }
 
     #[test]
@@ -3336,7 +3336,7 @@ mod tests {
             let s = ~"hello";
             let sb = as_buf(s, |b, _l| b);
             let s_cstr = raw::from_buf(sb);
-            fail_unless!(s_cstr == s);
+            assert!(s_cstr == s);
         }
     }
 
@@ -3345,11 +3345,11 @@ mod tests {
         let a = ~"hello";
         do as_buf(a) |buf, len| {
             unsafe {
-                fail_unless!(a[0] == 'h' as u8);
-                fail_unless!(*buf == 'h' as u8);
-                fail_unless!(len == 6u);
-                fail_unless!(*ptr::offset(buf,4u) == 'o' as u8);
-                fail_unless!(*ptr::offset(buf,5u) == 0u8);
+                assert!(a[0] == 'h' as u8);
+                assert!(*buf == 'h' as u8);
+                assert!(len == 6u);
+                assert!(*ptr::offset(buf,4u) == 'o' as u8);
+                assert!(*ptr::offset(buf,5u) == 0u8);
             }
         }
     }
@@ -3363,40 +3363,40 @@ mod tests {
         let mut i: uint = 0u;
         let n1: uint = len(s1);
         let n2: uint = vec::len::<u8>(v);
-        fail_unless!((n1 == n2));
+        assert!((n1 == n2));
         while i < n1 {
             let a: u8 = s1[i];
             let b: u8 = s2[i];
             debug!(a);
             debug!(b);
-            fail_unless!((a == b));
+            assert!((a == b));
             i += 1u;
         }
     }
 
     #[test]
     fn test_contains() {
-        fail_unless!(contains(~"abcde", ~"bcd"));
-        fail_unless!(contains(~"abcde", ~"abcd"));
-        fail_unless!(contains(~"abcde", ~"bcde"));
-        fail_unless!(contains(~"abcde", ~""));
-        fail_unless!(contains(~"", ~""));
-        fail_unless!(!contains(~"abcde", ~"def"));
-        fail_unless!(!contains(~"", ~"a"));
+        assert!(contains(~"abcde", ~"bcd"));
+        assert!(contains(~"abcde", ~"abcd"));
+        assert!(contains(~"abcde", ~"bcde"));
+        assert!(contains(~"abcde", ~""));
+        assert!(contains(~"", ~""));
+        assert!(!contains(~"abcde", ~"def"));
+        assert!(!contains(~"", ~"a"));
 
         let data = ~"ประเทศไทย中华Việt Nam";
-        fail_unless!(contains(data, ~"ประเ"));
-        fail_unless!(contains(data, ~"ะเ"));
-        fail_unless!(contains(data, ~"中华"));
-        fail_unless!(!contains(data, ~"ไท华"));
+        assert!(contains(data, ~"ประเ"));
+        assert!(contains(data, ~"ะเ"));
+        assert!(contains(data, ~"中华"));
+        assert!(!contains(data, ~"ไท华"));
     }
 
     #[test]
     fn test_contains_char() {
-        fail_unless!(contains_char(~"abc", 'b'));
-        fail_unless!(contains_char(~"a", 'a'));
-        fail_unless!(!contains_char(~"abc", 'd'));
-        fail_unless!(!contains_char(~"", 'a'));
+        assert!(contains_char(~"abc", 'b'));
+        assert!(contains_char(~"a", 'a'));
+        assert!(!contains_char(~"abc", 'd'));
+        assert!(!contains_char(~"", 'a'));
     }
 
     #[test]
@@ -3407,10 +3407,10 @@ mod tests {
 
         for each_split_char(data, ' ') |xx| {
             match ii {
-              0 => fail_unless!("\nMary" == xx),
-              1 => fail_unless!("had"    == xx),
-              2 => fail_unless!("a"      == xx),
-              3 => fail_unless!("little" == xx),
+              0 => assert!("\nMary" == xx),
+              1 => assert!("had"    == xx),
+              2 => assert!("a"      == xx),
+              3 => assert!("little" == xx),
               _ => ()
             }
             ii += 1;
@@ -3425,9 +3425,9 @@ mod tests {
 
         for each_splitn_char(data, ' ', 2u) |xx| {
             match ii {
-              0 => fail_unless!("\nMary" == xx),
-              1 => fail_unless!("had"    == xx),
-              2 => fail_unless!("a little lamb\nLittle lamb\n" == xx),
+              0 => assert!("\nMary" == xx),
+              1 => assert!("had"    == xx),
+              2 => assert!("a little lamb\nLittle lamb\n" == xx),
               _ => ()
             }
             ii += 1;
@@ -3442,10 +3442,10 @@ mod tests {
 
         for each_word(data) |ww| {
             match ii {
-              0 => fail_unless!("Mary"   == ww),
-              1 => fail_unless!("had"    == ww),
-              2 => fail_unless!("a"      == ww),
-              3 => fail_unless!("little" == ww),
+              0 => assert!("Mary"   == ww),
+              1 => assert!("had"    == ww),
+              2 => assert!("a"      == ww),
+              3 => assert!("little" == ww),
               _ => ()
             }
             ii += 1;
@@ -3462,9 +3462,9 @@ mod tests {
 
         for each_line(lf) |x| {
             match ii {
-                0 => fail_unless!("" == x),
-                1 => fail_unless!("Mary had a little lamb" == x),
-                2 => fail_unless!("Little lamb" == x),
+                0 => assert!("" == x),
+                1 => assert!("Mary had a little lamb" == x),
+                2 => assert!("Little lamb" == x),
                 _ => ()
             }
             ii += 1;
@@ -3474,35 +3474,35 @@ mod tests {
     #[test]
     fn test_map() {
         unsafe {
-            fail_unless!(~"" == map(~"", |c|
+            assert!(~"" == map(~"", |c|
                 libc::toupper(c as c_char) as char));
-            fail_unless!(~"YMCA" == map(~"ymca",
+            assert!(~"YMCA" == map(~"ymca",
                                   |c| libc::toupper(c as c_char) as char));
         }
     }
 
     #[test]
     fn test_all() {
-        fail_unless!(true  == all(~"", char::is_uppercase));
-        fail_unless!(false == all(~"ymca", char::is_uppercase));
-        fail_unless!(true  == all(~"YMCA", char::is_uppercase));
-        fail_unless!(false == all(~"yMCA", char::is_uppercase));
-        fail_unless!(false == all(~"YMCy", char::is_uppercase));
+        assert!(true  == all(~"", char::is_uppercase));
+        assert!(false == all(~"ymca", char::is_uppercase));
+        assert!(true  == all(~"YMCA", char::is_uppercase));
+        assert!(false == all(~"yMCA", char::is_uppercase));
+        assert!(false == all(~"YMCy", char::is_uppercase));
     }
 
     #[test]
     fn test_any() {
-        fail_unless!(false  == any(~"", char::is_uppercase));
-        fail_unless!(false == any(~"ymca", char::is_uppercase));
-        fail_unless!(true  == any(~"YMCA", char::is_uppercase));
-        fail_unless!(true == any(~"yMCA", char::is_uppercase));
-        fail_unless!(true == any(~"Ymcy", char::is_uppercase));
+        assert!(false  == any(~"", char::is_uppercase));
+        assert!(false == any(~"ymca", char::is_uppercase));
+        assert!(true  == any(~"YMCA", char::is_uppercase));
+        assert!(true == any(~"yMCA", char::is_uppercase));
+        assert!(true == any(~"Ymcy", char::is_uppercase));
     }
 
     #[test]
     fn test_chars() {
         let ss = ~"ศไทย中华Việt Nam";
-        fail_unless!(~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a',
+        assert!(~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a',
                        'm']
             == to_chars(ss));
     }
@@ -3548,10 +3548,10 @@ mod tests {
 
         for vec::each(pairs) |p| {
             let (s, u) = copy *p;
-            fail_unless!(to_utf16(s) == u);
-            fail_unless!(from_utf16(u) == s);
-            fail_unless!(from_utf16(to_utf16(s)) == s);
-            fail_unless!(to_utf16(from_utf16(u)) == u);
+            assert!(to_utf16(s) == u);
+            assert!(from_utf16(u) == s);
+            assert!(from_utf16(to_utf16(s)) == s);
+            assert!(to_utf16(from_utf16(u)) == u);
         }
     }
 
@@ -3561,7 +3561,7 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
         for v.each |ch| {
-            fail_unless!(s.char_at(pos) == *ch);
+            assert!(s.char_at(pos) == *ch);
             pos += from_char(*ch).len();
         }
     }
@@ -3572,7 +3572,7 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = s.len();
         for v.each_reverse |ch| {
-            fail_unless!(s.char_at_reverse(pos) == *ch);
+            assert!(s.char_at_reverse(pos) == *ch);
             pos -= from_char(*ch).len();
         }
     }
@@ -3588,7 +3588,7 @@ mod tests {
         let mut pos = 0;
 
         for s.each |b| {
-            fail_unless!(b == v[pos]);
+            assert!(b == v[pos]);
             pos += 1;
         }
     }
@@ -3596,7 +3596,7 @@ mod tests {
     #[test]
     fn test_each_empty() {
         for "".each |b| {
-            fail_unless!(b == 0u8);
+            assert!(b == 0u8);
         }
     }
 
@@ -3611,8 +3611,8 @@ mod tests {
         let mut pos = 0;
 
         for s.eachi |i, b| {
-            fail_unless!(pos == i);
-            fail_unless!(b == v[pos]);
+            assert!(pos == i);
+            assert!(b == v[pos]);
             pos += 1;
         }
     }
@@ -3620,8 +3620,8 @@ mod tests {
     #[test]
     fn test_eachi_empty() {
         for "".eachi |i, b| {
-            fail_unless!(i == 0);
-            fail_unless!(b == 0);
+            assert!(i == 0);
+            assert!(b == 0);
         }
     }
 
@@ -3637,14 +3637,14 @@ mod tests {
 
         for s.each_reverse |b| {
             pos -= 1;
-            fail_unless!(b == v[pos]);
+            assert!(b == v[pos]);
         }
     }
 
     #[test]
     fn test_each_empty_reverse() {
         for "".each_reverse |b| {
-            fail_unless!(b == 0u8);
+            assert!(b == 0u8);
         }
     }
 
@@ -3660,16 +3660,16 @@ mod tests {
 
         for s.eachi_reverse |i, b| {
             pos -= 1;
-            fail_unless!(pos == i);
-            fail_unless!(b == v[pos]);
+            assert!(pos == i);
+            assert!(b == v[pos]);
         }
     }
 
     #[test]
     fn test_eachi_reverse_empty() {
         for "".eachi_reverse |i, b| {
-            fail_unless!(i == 0);
-            fail_unless!(b == 0);
+            assert!(i == 0);
+            assert!(b == 0);
         }
     }
 
@@ -3679,7 +3679,7 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
         for s.each_char |ch| {
-            fail_unless!(ch == v[pos]);
+            assert!(ch == v[pos]);
             pos += 1;
         }
     }
@@ -3690,8 +3690,8 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
         for s.each_chari |i, ch| {
-            fail_unless!(pos == i);
-            fail_unless!(ch == v[pos]);
+            assert!(pos == i);
+            assert!(ch == v[pos]);
             pos += 1;
         }
     }
@@ -3703,7 +3703,7 @@ mod tests {
         let mut pos = v.len();
         for s.each_char_reverse |ch| {
             pos -= 1;
-            fail_unless!(ch == v[pos]);
+            assert!(ch == v[pos]);
         }
     }
 
@@ -3714,43 +3714,43 @@ mod tests {
         let mut pos = v.len();
         for s.each_chari_reverse |i, ch| {
             pos -= 1;
-            fail_unless!(pos == i);
-            fail_unless!(ch == v[pos]);
+            assert!(pos == i);
+            assert!(ch == v[pos]);
         }
     }
 
     #[test]
     fn test_escape_unicode() {
-        fail_unless!(escape_unicode(~"abc") == ~"\\x61\\x62\\x63");
-        fail_unless!(escape_unicode(~"a c") == ~"\\x61\\x20\\x63");
-        fail_unless!(escape_unicode(~"\r\n\t") == ~"\\x0d\\x0a\\x09");
-        fail_unless!(escape_unicode(~"'\"\\") == ~"\\x27\\x22\\x5c");
-        fail_unless!(escape_unicode(~"\x00\x01\xfe\xff") ==
+        assert!(escape_unicode(~"abc") == ~"\\x61\\x62\\x63");
+        assert!(escape_unicode(~"a c") == ~"\\x61\\x20\\x63");
+        assert!(escape_unicode(~"\r\n\t") == ~"\\x0d\\x0a\\x09");
+        assert!(escape_unicode(~"'\"\\") == ~"\\x27\\x22\\x5c");
+        assert!(escape_unicode(~"\x00\x01\xfe\xff") ==
                      ~"\\x00\\x01\\xfe\\xff");
-        fail_unless!(escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff");
-        fail_unless!(escape_unicode(~"\U00010000\U0010ffff") ==
+        assert!(escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff");
+        assert!(escape_unicode(~"\U00010000\U0010ffff") ==
             ~"\\U00010000\\U0010ffff");
-        fail_unless!(escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00");
-        fail_unless!(escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d");
+        assert!(escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00");
+        assert!(escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d");
     }
 
     #[test]
     fn test_escape_default() {
-        fail_unless!(escape_default(~"abc") == ~"abc");
-        fail_unless!(escape_default(~"a c") == ~"a c");
-        fail_unless!(escape_default(~"\r\n\t") == ~"\\r\\n\\t");
-        fail_unless!(escape_default(~"'\"\\") == ~"\\'\\\"\\\\");
-        fail_unless!(escape_default(~"\u0100\uffff") == ~"\\u0100\\uffff");
-        fail_unless!(escape_default(~"\U00010000\U0010ffff") ==
+        assert!(escape_default(~"abc") == ~"abc");
+        assert!(escape_default(~"a c") == ~"a c");
+        assert!(escape_default(~"\r\n\t") == ~"\\r\\n\\t");
+        assert!(escape_default(~"'\"\\") == ~"\\'\\\"\\\\");
+        assert!(escape_default(~"\u0100\uffff") == ~"\\u0100\\uffff");
+        assert!(escape_default(~"\U00010000\U0010ffff") ==
             ~"\\U00010000\\U0010ffff");
-        fail_unless!(escape_default(~"ab\ufb00") == ~"ab\\ufb00");
-        fail_unless!(escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r");
+        assert!(escape_default(~"ab\ufb00") == ~"ab\\ufb00");
+        assert!(escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r");
     }
 
     #[test]
     fn test_to_managed() {
-        fail_unless!((~"abc").to_managed() == @"abc");
-        fail_unless!(slice("abcdef", 1, 5).to_managed() == @"bcde");
+        assert!((~"abc").to_managed() == @"abc");
+        assert!(slice("abcdef", 1, 5).to_managed() == @"bcde");
     }
 
     #[test]
diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index f8905e4faa7..338893d2388 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -170,10 +170,10 @@ pub mod tests {
 
     #[test]
     pub fn size_of_basic() {
-        fail_unless!(size_of::<u8>() == 1u);
-        fail_unless!(size_of::<u16>() == 2u);
-        fail_unless!(size_of::<u32>() == 4u);
-        fail_unless!(size_of::<u64>() == 8u);
+        assert!(size_of::<u8>() == 1u);
+        assert!(size_of::<u16>() == 2u);
+        assert!(size_of::<u32>() == 4u);
+        assert!(size_of::<u64>() == 8u);
     }
 
     #[test]
@@ -181,30 +181,30 @@ pub mod tests {
     #[cfg(target_arch = "arm")]
     #[cfg(target_arch = "mips")]
     pub fn size_of_32() {
-        fail_unless!(size_of::<uint>() == 4u);
-        fail_unless!(size_of::<*uint>() == 4u);
+        assert!(size_of::<uint>() == 4u);
+        assert!(size_of::<*uint>() == 4u);
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
     pub fn size_of_64() {
-        fail_unless!(size_of::<uint>() == 8u);
-        fail_unless!(size_of::<*uint>() == 8u);
+        assert!(size_of::<uint>() == 8u);
+        assert!(size_of::<*uint>() == 8u);
     }
 
     #[test]
     pub fn nonzero_size_of_basic() {
         type Z = [i8, ..0];
-        fail_unless!(size_of::<Z>() == 0u);
-        fail_unless!(nonzero_size_of::<Z>() == 1u);
-        fail_unless!(nonzero_size_of::<uint>() == size_of::<uint>());
+        assert!(size_of::<Z>() == 0u);
+        assert!(nonzero_size_of::<Z>() == 1u);
+        assert!(nonzero_size_of::<uint>() == size_of::<uint>());
     }
 
     #[test]
     pub fn align_of_basic() {
-        fail_unless!(pref_align_of::<u8>() == 1u);
-        fail_unless!(pref_align_of::<u16>() == 2u);
-        fail_unless!(pref_align_of::<u32>() == 4u);
+        assert!(pref_align_of::<u8>() == 1u);
+        assert!(pref_align_of::<u16>() == 2u);
+        assert!(pref_align_of::<u32>() == 4u);
     }
 
     #[test]
@@ -212,15 +212,15 @@ pub mod tests {
     #[cfg(target_arch = "arm")]
     #[cfg(target_arch = "mips")]
     pub fn align_of_32() {
-        fail_unless!(pref_align_of::<uint>() == 4u);
-        fail_unless!(pref_align_of::<*uint>() == 4u);
+        assert!(pref_align_of::<uint>() == 4u);
+        assert!(pref_align_of::<*uint>() == 4u);
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
     pub fn align_of_64() {
-        fail_unless!(pref_align_of::<uint>() == 8u);
-        fail_unless!(pref_align_of::<*uint>() == 8u);
+        assert!(pref_align_of::<uint>() == 8u);
+        assert!(pref_align_of::<*uint>() == 8u);
     }
 
     #[test]
@@ -229,7 +229,7 @@ pub mod tests {
             let x = 10;
             let f: &fn(int) -> int = |y| x + y;
 
-            fail_unless!(f(20) == 30);
+            assert!(f(20) == 30);
 
             let original_closure: Closure = cast::transmute(f);
 
@@ -242,7 +242,7 @@ pub mod tests {
             };
 
             let new_f: &fn(int) -> int = cast::transmute(new_closure);
-            fail_unless!(new_f(20) == 30);
+            assert!(new_f(20) == 30);
         }
     }
 }
diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs
index e386f93a429..261671f6de9 100644
--- a/src/libcore/task/local_data.rs
+++ b/src/libcore/task/local_data.rs
@@ -92,17 +92,17 @@ fn test_tls_multitask() {
         do task::spawn {
             unsafe {
                 // TLS shouldn't carry over.
-                fail_unless!(local_data_get(my_key).is_none());
+                assert!(local_data_get(my_key).is_none());
                 local_data_set(my_key, @~"child data");
-                fail_unless!(*(local_data_get(my_key).get()) ==
+                assert!(*(local_data_get(my_key).get()) ==
                     ~"child data");
                 // should be cleaned up for us
             }
         }
         // Must work multiple times
-        fail_unless!(*(local_data_get(my_key).get()) == ~"parent data");
-        fail_unless!(*(local_data_get(my_key).get()) == ~"parent data");
-        fail_unless!(*(local_data_get(my_key).get()) == ~"parent data");
+        assert!(*(local_data_get(my_key).get()) == ~"parent data");
+        assert!(*(local_data_get(my_key).get()) == ~"parent data");
+        assert!(*(local_data_get(my_key).get()) == ~"parent data");
     }
 }
 
@@ -112,7 +112,7 @@ fn test_tls_overwrite() {
         fn my_key(_x: @~str) { }
         local_data_set(my_key, @~"first data");
         local_data_set(my_key, @~"next data"); // Shouldn't leak.
-        fail_unless!(*(local_data_get(my_key).get()) == ~"next data");
+        assert!(*(local_data_get(my_key).get()) == ~"next data");
     }
 }
 
@@ -121,9 +121,9 @@ fn test_tls_pop() {
     unsafe {
         fn my_key(_x: @~str) { }
         local_data_set(my_key, @~"weasel");
-        fail_unless!(*(local_data_pop(my_key).get()) == ~"weasel");
+        assert!(*(local_data_pop(my_key).get()) == ~"weasel");
         // Pop must remove the data from the map.
-        fail_unless!(local_data_pop(my_key).is_none());
+        assert!(local_data_pop(my_key).is_none());
     }
 }
 
@@ -144,7 +144,7 @@ fn test_tls_modify() {
                 None                 => fail!(~"missing value")
             }
         });
-        fail_unless!(*(local_data_pop(my_key).get()) == ~"next data");
+        assert!(*(local_data_pop(my_key).get()) == ~"next data");
     }
 }
 
diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index a4fd18ec094..43f5fa4654b 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -41,7 +41,7 @@ type TaskLocalMap = @mut ~[Option<TaskLocalElement>];
 
 extern fn cleanup_task_local_map(map_ptr: *libc::c_void) {
     unsafe {
-        fail_unless!(!map_ptr.is_null());
+        assert!(!map_ptr.is_null());
         // Get and keep the single reference that was created at the
         // beginning.
         let _map: TaskLocalMap = cast::reinterpret_cast(&map_ptr);
diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs
index 0cd78d4b847..ee454312e04 100644
--- a/src/libcore/task/mod.rs
+++ b/src/libcore/task/mod.rs
@@ -840,14 +840,14 @@ fn test_add_wrapper() {
 fn test_future_result() {
     let mut result = None;
     do task().future_result(|+r| { result = Some(r); }).spawn { }
-    fail_unless!(result.unwrap().recv() == Success);
+    assert!(result.unwrap().recv() == Success);
 
     result = None;
     do task().future_result(|+r|
         { result = Some(r); }).unlinked().spawn {
         fail!();
     }
-    fail_unless!(result.unwrap().recv() == Failure);
+    assert!(result.unwrap().recv() == Failure);
 }
 
 #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -893,7 +893,7 @@ fn test_spawn_sched() {
 
         do spawn_sched(SingleThreaded) {
             let child_sched_id = unsafe { rt::rust_get_sched_id() };
-            fail_unless!(parent_sched_id != child_sched_id);
+            assert!(parent_sched_id != child_sched_id);
 
             if (i == 0) {
                 ch.send(());
@@ -921,8 +921,8 @@ fn test_spawn_sched_childs_on_default_sched() {
         do spawn {
             let ch = ch.f.swap_unwrap();
             let child_sched_id = unsafe { rt::rust_get_sched_id() };
-            fail_unless!(parent_sched_id != child_sched_id);
-            fail_unless!(child_sched_id == default_id);
+            assert!(parent_sched_id != child_sched_id);
+            assert!(child_sched_id == default_id);
             ch.send(());
         };
     };
@@ -1016,7 +1016,7 @@ fn avoid_copying_the_body(spawnfn: &fn(v: ~fn())) {
     }
 
     let x_in_child = p.recv();
-    fail_unless!(x_in_parent == x_in_child);
+    assert!(x_in_parent == x_in_child);
 }
 
 #[test]
@@ -1171,7 +1171,7 @@ fn test_sched_thread_per_core() {
         unsafe {
             let cores = rt::rust_num_threads();
             let reported_threads = rt::rust_sched_threads();
-            fail_unless!((cores as uint == reported_threads as uint));
+            assert!((cores as uint == reported_threads as uint));
             chan.send(());
         }
     }
@@ -1186,9 +1186,9 @@ fn test_spawn_thread_on_demand() {
     do spawn_sched(ManualThreads(2)) || {
         unsafe {
             let max_threads = rt::rust_sched_threads();
-            fail_unless!((max_threads as int == 2));
+            assert!((max_threads as int == 2));
             let running_threads = rt::rust_sched_current_nonlazy_threads();
-            fail_unless!((running_threads as int == 1));
+            assert!((running_threads as int == 1));
 
             let (port2, chan2) = comm::stream();
 
@@ -1197,7 +1197,7 @@ fn test_spawn_thread_on_demand() {
             }
 
             let running_threads2 = rt::rust_sched_current_nonlazy_threads();
-            fail_unless!((running_threads2 as int == 2));
+            assert!((running_threads2 as int == 2));
 
             port2.recv();
             chan.send(());
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index fcd5ac7cdbb..39e43ba6fc5 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -103,11 +103,11 @@ fn new_taskset() -> TaskSet {
 }
 fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) {
     let didnt_overwrite = tasks.insert(task);
-    fail_unless!(didnt_overwrite);
+    assert!(didnt_overwrite);
 }
 fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     let was_present = tasks.remove(&task);
-    fail_unless!(was_present);
+    assert!(was_present);
 }
 pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) {
     tasks.each(|k| blk(*k))
@@ -231,7 +231,7 @@ fn each_ancestor(list:        &mut AncestorList,
             // NB: Takes a lock! (this ancestor node)
             do access_ancestors(ancestor_arc) |nobe| {
                 // Check monotonicity
-                fail_unless!(last_generation > nobe.generation);
+                assert!(last_generation > nobe.generation);
                 /*##########################################################*
                  * Step 1: Look at this ancestor group (call iterator block).
                  *##########################################################*/
@@ -423,7 +423,7 @@ fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) {
                 }
             }
             for taskset_each(&group.descendants) |child| {
-                fail_unless!(child != me);
+                assert!(child != me);
                 rt::rust_task_kill_other(child);
             }
             // Only one task should ever do this.
@@ -498,7 +498,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
                         }
                         None => 0 // the actual value doesn't really matter.
                     };
-                fail_unless!(new_generation < uint::max_value);
+                assert!(new_generation < uint::max_value);
                 // Build a new node in the ancestor list.
                 AncestorList(Some(unstable::exclusive(AncestorNode {
                     generation: new_generation,
@@ -545,7 +545,7 @@ pub fn spawn_raw(opts: TaskOpts, f: ~fn()) {
                 DefaultScheduler => rt::new_task(),
                 _ => new_task_in_sched(opts.sched)
             };
-            fail_unless!(!new_task.is_null());
+            assert!(!new_task.is_null());
             // Getting killed after here would leak the task.
             let mut notify_chan = if opts.notify_chan.is_none() {
                 None
@@ -717,7 +717,7 @@ fn test_spawn_raw_notify_success() {
     };
     do spawn_raw(opts) {
     }
-    fail_unless!(notify_po.recv() == Success);
+    assert!(notify_po.recv() == Success);
 }
 
 #[test]
@@ -734,5 +734,5 @@ fn test_spawn_raw_notify_failure() {
     do spawn_raw(opts) {
         fail!();
     }
-    fail_unless!(notify_po.recv() == Failure);
+    assert!(notify_po.recv() == Failure);
 }
diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs
index fa4074047b9..a6004ed1241 100644
--- a/src/libcore/to_str.rs
+++ b/src/libcore/to_str.rs
@@ -137,31 +137,31 @@ impl<A:ToStr> ToStr for @[A] {
 mod tests {
     #[test]
     fn test_simple_types() {
-        fail_unless!(1i.to_str() == ~"1");
-        fail_unless!((-1i).to_str() == ~"-1");
-        fail_unless!(200u.to_str() == ~"200");
-        fail_unless!(2u8.to_str() == ~"2");
-        fail_unless!(true.to_str() == ~"true");
-        fail_unless!(false.to_str() == ~"false");
-        fail_unless!(().to_str() == ~"()");
-        fail_unless!((~"hi").to_str() == ~"hi");
-        fail_unless!((@"hi").to_str() == ~"hi");
+        assert!(1i.to_str() == ~"1");
+        assert!((-1i).to_str() == ~"-1");
+        assert!(200u.to_str() == ~"200");
+        assert!(2u8.to_str() == ~"2");
+        assert!(true.to_str() == ~"true");
+        assert!(false.to_str() == ~"false");
+        assert!(().to_str() == ~"()");
+        assert!((~"hi").to_str() == ~"hi");
+        assert!((@"hi").to_str() == ~"hi");
     }
 
     #[test]
     fn test_tuple_types() {
-        fail_unless!((1, 2).to_str() == ~"(1, 2)");
-        fail_unless!((~"a", ~"b", false).to_str() == ~"(a, b, false)");
-        fail_unless!(((), ((), 100)).to_str() == ~"((), ((), 100))");
+        assert!((1, 2).to_str() == ~"(1, 2)");
+        assert!((~"a", ~"b", false).to_str() == ~"(a, b, false)");
+        assert!(((), ((), 100)).to_str() == ~"((), ((), 100))");
     }
 
     #[test]
     fn test_vectors() {
         let x: ~[int] = ~[];
-        fail_unless!(x.to_str() == ~"[]");
-        fail_unless!((~[1]).to_str() == ~"[1]");
-        fail_unless!((~[1, 2, 3]).to_str() == ~"[1, 2, 3]");
-        fail_unless!((~[~[], ~[1], ~[1, 1]]).to_str() ==
+        assert!(x.to_str() == ~"[]");
+        assert!((~[1]).to_str() == ~"[1]");
+        assert!((~[1, 2, 3]).to_str() == ~"[1, 2, 3]");
+        assert!((~[~[], ~[1], ~[1, 1]]).to_str() ==
                ~"[[], [1], [1, 1]]");
     }
 }
diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs
index 52298992bd1..5d87e2a296d 100644
--- a/src/libcore/trie.rs
+++ b/src/libcore/trie.rs
@@ -354,7 +354,7 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
 
 #[cfg(test)]
 pub fn check_integrity<T>(trie: &TrieNode<T>) {
-    fail_unless!(trie.count != 0);
+    assert!(trie.count != 0);
 
     let mut sum = 0;
 
@@ -369,7 +369,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
         }
     }
 
-    fail_unless!(sum == trie.count);
+    assert!(sum == trie.count);
 }
 
 #[cfg(test)]
@@ -381,9 +381,9 @@ mod tests {
     #[test]
     fn test_find_mut() {
         let mut m = TrieMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
+        assert!(m.insert(1, 12));
+        assert!(m.insert(2, 8));
+        assert!(m.insert(5, 14));
         let new = 100;
         match m.find_mut(&5) {
             None => fail!(), Some(x) => *x = new
@@ -397,32 +397,32 @@ mod tests {
         let n = 300;
 
         for uint::range_step(1, n, 2) |x| {
-            fail_unless!(trie.insert(x, x + 1));
-            fail_unless!(trie.contains_key(&x));
+            assert!(trie.insert(x, x + 1));
+            assert!(trie.contains_key(&x));
             check_integrity(&trie.root);
         }
 
         for uint::range_step(0, n, 2) |x| {
-            fail_unless!(!trie.contains_key(&x));
-            fail_unless!(trie.insert(x, x + 1));
+            assert!(!trie.contains_key(&x));
+            assert!(trie.insert(x, x + 1));
             check_integrity(&trie.root);
         }
 
         for uint::range(0, n) |x| {
-            fail_unless!(trie.contains_key(&x));
-            fail_unless!(!trie.insert(x, x + 1));
+            assert!(trie.contains_key(&x));
+            assert!(!trie.insert(x, x + 1));
             check_integrity(&trie.root);
         }
 
         for uint::range_step(1, n, 2) |x| {
-            fail_unless!(trie.remove(&x));
-            fail_unless!(!trie.contains_key(&x));
+            assert!(trie.remove(&x));
+            assert!(!trie.contains_key(&x));
             check_integrity(&trie.root);
         }
 
         for uint::range_step(0, n, 2) |x| {
-            fail_unless!(trie.contains_key(&x));
-            fail_unless!(!trie.insert(x, x + 1));
+            assert!(trie.contains_key(&x));
+            assert!(!trie.insert(x, x + 1));
             check_integrity(&trie.root);
         }
     }
@@ -431,16 +431,16 @@ mod tests {
     fn test_each() {
         let mut m = TrieMap::new();
 
-        fail_unless!(m.insert(3, 6));
-        fail_unless!(m.insert(0, 0));
-        fail_unless!(m.insert(4, 8));
-        fail_unless!(m.insert(2, 4));
-        fail_unless!(m.insert(1, 2));
+        assert!(m.insert(3, 6));
+        assert!(m.insert(0, 0));
+        assert!(m.insert(4, 8));
+        assert!(m.insert(2, 4));
+        assert!(m.insert(1, 2));
 
         let mut n = 0;
         for m.each |&(k, v)| {
-            fail_unless!(k == n);
-            fail_unless!(*v == n * 2);
+            assert!(k == n);
+            assert!(*v == n * 2);
             n += 1;
         }
     }
@@ -456,10 +456,10 @@ mod tests {
         let mut n = uint::max_value - 9999;
         for m.each |&(k, v)| {
             if n == uint::max_value - 5000 { break }
-            fail_unless!(n < uint::max_value - 5000);
+            assert!(n < uint::max_value - 5000);
 
-            fail_unless!(k == n);
-            fail_unless!(*v == n / 2);
+            assert!(k == n);
+            assert!(*v == n / 2);
             n += 1;
         }
     }
@@ -468,16 +468,16 @@ mod tests {
     fn test_each_reverse() {
         let mut m = TrieMap::new();
 
-        fail_unless!(m.insert(3, 6));
-        fail_unless!(m.insert(0, 0));
-        fail_unless!(m.insert(4, 8));
-        fail_unless!(m.insert(2, 4));
-        fail_unless!(m.insert(1, 2));
+        assert!(m.insert(3, 6));
+        assert!(m.insert(0, 0));
+        assert!(m.insert(4, 8));
+        assert!(m.insert(2, 4));
+        assert!(m.insert(1, 2));
 
         let mut n = 4;
         for m.each_reverse |&(k, v)| {
-            fail_unless!(k == n);
-            fail_unless!(*v == n * 2);
+            assert!(k == n);
+            assert!(*v == n * 2);
             n -= 1;
         }
     }
@@ -493,10 +493,10 @@ mod tests {
         let mut n = uint::max_value;
         for m.each_reverse |&(k, v)| {
             if n == uint::max_value - 5000 { break }
-            fail_unless!(n > uint::max_value - 5000);
+            assert!(n > uint::max_value - 5000);
 
-            fail_unless!(k == n);
-            fail_unless!(*v == n / 2);
+            assert!(k == n);
+            assert!(*v == n / 2);
             n -= 1;
         }
     }
@@ -508,17 +508,17 @@ mod tests {
 
         let mut trie = TrieSet::new();
 
-        fail_unless!(trie.insert(x));
-        fail_unless!(trie.insert(y));
+        assert!(trie.insert(x));
+        assert!(trie.insert(y));
 
-        fail_unless!(trie.len() == 2);
+        assert!(trie.len() == 2);
 
         let expected = [x, y];
 
         let mut i = 0;
 
         for trie.each |x| {
-            fail_unless!(expected[i] == *x);
+            assert!(expected[i] == *x);
             i += 1;
         }
     }
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index 6fbcee959ce..a5c86d592c6 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -240,15 +240,15 @@ impl<A:Ord,B:Ord,C:Ord> Ord for (A, B, C) {
 #[test]
 fn test_tuple_ref() {
     let x = (~"foo", ~"bar");
-    fail_unless!(x.first_ref() == &~"foo");
-    fail_unless!(x.second_ref() == &~"bar");
+    assert!(x.first_ref() == &~"foo");
+    assert!(x.second_ref() == &~"bar");
 }
 
 #[test]
 #[allow(non_implicitly_copyable_typarams)]
 fn test_tuple() {
-    fail_unless!((948, 4039.48).first() == 948);
-    fail_unless!((34.5, ~"foo").second() == ~"foo");
-    fail_unless!(('a', 2).swap() == (2, 'a'));
+    assert!((948, 4039.48).first() == 948);
+    assert!((34.5, ~"foo").second() == ~"foo");
+    assert!(('a', 2).swap() == (2, 'a'));
 }
 
diff --git a/src/libcore/unstable.rs b/src/libcore/unstable.rs
index 6da3dfc2628..665a3e1b6b6 100644
--- a/src/libcore/unstable.rs
+++ b/src/libcore/unstable.rs
@@ -81,7 +81,7 @@ pub fn run_in_bare_thread(f: ~fn()) {
 fn test_run_in_bare_thread() {
     let i = 100;
     do run_in_bare_thread {
-        fail_unless!(i == 100);
+        assert!(i == 100);
     }
 }
 
@@ -90,7 +90,7 @@ fn test_run_in_bare_thread_exchange() {
     // Does the exchange heap work without the runtime?
     let i = ~100;
     do run_in_bare_thread {
-        fail_unless!(i == ~100);
+        assert!(i == ~100);
     }
 }
 
@@ -123,7 +123,7 @@ impl<T> Drop for ArcDestruct<T>{
                 let data: ~ArcData<T> = cast::reinterpret_cast(&self.data);
                 let new_count =
                     intrinsics::atomic_xsub(&mut data.count, 1) - 1;
-                fail_unless!(new_count >= 0);
+                assert!(new_count >= 0);
                 if new_count == 0 {
                     // drop glue takes over.
                 } else {
@@ -163,7 +163,7 @@ pub unsafe fn get_shared_mutable_state<T:Owned>(
 {
     unsafe {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
-        fail_unless!(ptr.count > 0);
+        assert!(ptr.count > 0);
         let r = cast::transmute(ptr.data.get_ref());
         cast::forget(ptr);
         return r;
@@ -174,7 +174,7 @@ pub unsafe fn get_shared_immutable_state<'a,T:Owned>(
         rc: &'a SharedMutableState<T>) -> &'a T {
     unsafe {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
-        fail_unless!(ptr.count > 0);
+        assert!(ptr.count > 0);
         // Cast us back into the correct region
         let r = cast::transmute_region(ptr.data.get_ref());
         cast::forget(ptr);
@@ -187,7 +187,7 @@ pub unsafe fn clone_shared_mutable_state<T:Owned>(rc: &SharedMutableState<T>)
     unsafe {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         let new_count = intrinsics::atomic_xadd(&mut ptr.count, 1) + 1;
-        fail_unless!(new_count >= 2);
+        assert!(new_count >= 2);
         cast::forget(ptr);
     }
     ArcDestruct((*rc).data)
@@ -338,7 +338,7 @@ pub mod tests {
         for futures.each |f| { f.recv() }
 
         do total.with |total| {
-            fail_unless!(**total == num_tasks * count)
+            assert!(**total == num_tasks * count)
         };
     }
 
@@ -350,11 +350,11 @@ pub mod tests {
         let x2 = x.clone();
         do task::try || {
             do x2.with |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do x.with |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
 }
diff --git a/src/libcore/unstable/at_exit.rs b/src/libcore/unstable/at_exit.rs
index f85f6201107..83f0c3695e8 100644
--- a/src/libcore/unstable/at_exit.rs
+++ b/src/libcore/unstable/at_exit.rs
@@ -80,7 +80,7 @@ fn test_at_exit() {
     let i = 10;
     do at_exit {
         debug!("at_exit1");
-        fail_unless!(i == 10);
+        assert!(i == 10);
     }
 }
 
@@ -90,8 +90,8 @@ fn test_at_exit_many() {
     for uint::range(20, 100) |j| {
         do at_exit {
             debug!("at_exit2");
-            fail_unless!(i == 10);
-            fail_unless!(j > i);
+            assert!(i == 10);
+            assert!(j > i);
         }
     }
 }
diff --git a/src/libcore/unstable/exchange_alloc.rs b/src/libcore/unstable/exchange_alloc.rs
index 7863d5d241c..fdf99e9dffe 100644
--- a/src/libcore/unstable/exchange_alloc.rs
+++ b/src/libcore/unstable/exchange_alloc.rs
@@ -20,11 +20,11 @@ use intrinsic::TyDesc;
 
 pub unsafe fn malloc(td: *TypeDesc, size: uint) -> *c_void {
     unsafe {
-        fail_unless!(td.is_not_null());
+        assert!(td.is_not_null());
 
         let total_size = get_box_size(size, (*td).align);
         let p = c_malloc(total_size as size_t);
-        fail_unless!(p.is_not_null());
+        assert!(p.is_not_null());
 
         // FIXME #3475: Converting between our two different tydesc types
         let td: *TyDesc = transmute(td);
@@ -57,7 +57,7 @@ pub unsafe fn free(ptr: *c_void) {
     let exchange_count = &mut *rust_get_exchange_count_ptr();
     atomic_xsub(exchange_count, 1);
 
-    fail_unless!(ptr.is_not_null());
+    assert!(ptr.is_not_null());
     c_free(ptr);
 }
 ///Thin wrapper around libc::free, as with exchange_alloc::malloc_raw
@@ -75,7 +75,7 @@ fn get_box_size(body_size: uint, body_align: uint) -> uint {
 // Rounds |size| to the nearest |alignment|. Invariant: |alignment| is a power
 // of two.
 fn align_to(size: uint, align: uint) -> uint {
-    fail_unless!(align != 0);
+    assert!(align != 0);
     (size + align - 1) & !(align - 1)
 }
 
diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs
index d9fd6d87b72..be2aecf0c2a 100644
--- a/src/libcore/unstable/extfmt.rs
+++ b/src/libcore/unstable/extfmt.rs
@@ -340,11 +340,11 @@ pub mod ct {
             parse_count(s, 0, s.len()) == Parsed::new(count, next)
         }
 
-        fail_unless!(test("", CountImplied, 0));
-        fail_unless!(test("*", CountIsNextParam, 1));
-        fail_unless!(test("*1", CountIsNextParam, 1));
-        fail_unless!(test("*1$", CountIsParam(1), 3));
-        fail_unless!(test("123", CountIs(123), 3));
+        assert!(test("", CountImplied, 0));
+        assert!(test("*", CountIsNextParam, 1));
+        assert!(test("*1", CountIsNextParam, 1));
+        assert!(test("*1$", CountIsParam(1), 3));
+        assert!(test("123", CountIs(123), 3));
     }
 
     #[test]
@@ -355,8 +355,8 @@ pub mod ct {
 
         fn test(s: &str, flags: &[Flag], next: uint) {
             let f = parse_flags(s, 0, s.len());
-            fail_unless!(pack(f.val) == pack(flags));
-            fail_unless!(f.next == next);
+            assert!(pack(f.val) == pack(flags));
+            assert!(f.next == next);
         }
 
         test("", [], 0);
@@ -367,7 +367,7 @@ pub mod ct {
 
     #[test]
     fn test_parse_fmt_string() {
-        fail_unless!(parse_fmt_string("foo %s bar", die) == ~[
+        assert!(parse_fmt_string("foo %s bar", die) == ~[
             PieceString(~"foo "),
             PieceConv(Conv {
                 param: None,
@@ -378,7 +378,7 @@ pub mod ct {
             }),
             PieceString(~" bar")]);
 
-        fail_unless!(parse_fmt_string("%s", die) == ~[
+        assert!(parse_fmt_string("%s", die) == ~[
             PieceConv(Conv {
                 param: None,
                 flags: ~[],
@@ -387,7 +387,7 @@ pub mod ct {
                 ty: TyStr,
             })]);
 
-        fail_unless!(parse_fmt_string("%%%%", die) == ~[
+        assert!(parse_fmt_string("%%%%", die) == ~[
             PieceString(~"%"), PieceString(~"%")]);
     }
 
@@ -397,10 +397,10 @@ pub mod ct {
             parse_parameter(s, 0, s.len()) == Parsed::new(param, next)
         }
 
-        fail_unless!(test("", None, 0));
-        fail_unless!(test("foo", None, 0));
-        fail_unless!(test("123", None, 0));
-        fail_unless!(test("123$", Some(123), 4));
+        assert!(test("", None, 0));
+        assert!(test("foo", None, 0));
+        assert!(test("123", None, 0));
+        assert!(test("123$", Some(123), 4));
     }
 
     #[test]
@@ -409,12 +409,12 @@ pub mod ct {
             parse_precision(s, 0, s.len()) == Parsed::new(count, next)
         }
 
-        fail_unless!(test("", CountImplied, 0));
-        fail_unless!(test(".", CountIs(0), 1));
-        fail_unless!(test(".*", CountIsNextParam, 2));
-        fail_unless!(test(".*1", CountIsNextParam, 2));
-        fail_unless!(test(".*1$", CountIsParam(1), 4));
-        fail_unless!(test(".123", CountIs(123), 4));
+        assert!(test("", CountImplied, 0));
+        assert!(test(".", CountIs(0), 1));
+        assert!(test(".*", CountIsNextParam, 2));
+        assert!(test(".*1", CountIsNextParam, 2));
+        assert!(test(".*1$", CountIsParam(1), 4));
+        assert!(test(".123", CountIs(123), 4));
     }
 
     #[test]
@@ -423,17 +423,17 @@ pub mod ct {
             parse_type(s, 0, s.len(), die) == Parsed::new(ty, 1)
         }
 
-        fail_unless!(test("b", TyBool));
-        fail_unless!(test("c", TyChar));
-        fail_unless!(test("d", TyInt(Signed)));
-        fail_unless!(test("f", TyFloat));
-        fail_unless!(test("i", TyInt(Signed)));
-        fail_unless!(test("o", TyOctal));
-        fail_unless!(test("s", TyStr));
-        fail_unless!(test("t", TyBits));
-        fail_unless!(test("x", TyHex(CaseLower)));
-        fail_unless!(test("X", TyHex(CaseUpper)));
-        fail_unless!(test("?", TyPoly));
+        assert!(test("b", TyBool));
+        assert!(test("c", TyChar));
+        assert!(test("d", TyInt(Signed)));
+        assert!(test("f", TyFloat));
+        assert!(test("i", TyInt(Signed)));
+        assert!(test("o", TyOctal));
+        assert!(test("s", TyStr));
+        assert!(test("t", TyBits));
+        assert!(test("x", TyHex(CaseLower)));
+        assert!(test("X", TyHex(CaseUpper)));
+        assert!(test("?", TyPoly));
     }
 
     #[test]
@@ -453,16 +453,16 @@ pub mod ct {
     #[test]
     fn test_peek_num() {
         let s1 = "";
-        fail_unless!(peek_num(s1, 0, s1.len()).is_none());
+        assert!(peek_num(s1, 0, s1.len()).is_none());
 
         let s2 = "foo";
-        fail_unless!(peek_num(s2, 0, s2.len()).is_none());
+        assert!(peek_num(s2, 0, s2.len()).is_none());
 
         let s3 = "123";
-        fail_unless!(peek_num(s3, 0, s3.len()) == Some(Parsed::new(123, 3)));
+        assert!(peek_num(s3, 0, s3.len()) == Some(Parsed::new(123, 3)));
 
         let s4 = "123foo";
-        fail_unless!(peek_num(s4, 0, s4.len()) == Some(Parsed::new(123, 3)));
+        assert!(peek_num(s4, 0, s4.len()) == Some(Parsed::new(123, 3)));
     }
 }
 
diff --git a/src/libcore/unstable/finally.rs b/src/libcore/unstable/finally.rs
index 93cc4a4342d..4d2daa6f150 100644
--- a/src/libcore/unstable/finally.rs
+++ b/src/libcore/unstable/finally.rs
@@ -58,11 +58,11 @@ fn test_success() {
     do (|| {
         i = 10;
     }).finally {
-        fail_unless!(!failing());
-        fail_unless!(i == 10);
+        assert!(!failing());
+        assert!(i == 10);
         i = 20;
     }
-    fail_unless!(i == 20);
+    assert!(i == 20);
 }
 
 #[test]
@@ -74,8 +74,8 @@ fn test_fail() {
         i = 10;
         fail!();
     }).finally {
-        fail_unless!(failing());
-        fail_unless!(i == 10);
+        assert!(failing());
+        assert!(i == 10);
     }
 }
 
@@ -83,7 +83,7 @@ fn test_fail() {
 fn test_retval() {
     let closure: &fn() -> int = || 10;
     let i = do closure.finally { };
-    fail_unless!(i == 10);
+    assert!(i == 10);
 }
 
 #[test]
diff --git a/src/libcore/unstable/global.rs b/src/libcore/unstable/global.rs
index 794ac0c85af..ef5970658a1 100644
--- a/src/libcore/unstable/global.rs
+++ b/src/libcore/unstable/global.rs
@@ -187,7 +187,7 @@ fn get_global_state() -> Exclusive<GlobalState> {
         let prev_i = unsafe { atomic_cxchg(&mut *global_ptr, 0, state_i) };
 
         // Sanity check that we're not trying to reinitialize after shutdown
-        fail_unless!(prev_i != POISON);
+        assert!(prev_i != POISON);
 
         if prev_i == 0 {
             // Successfully installed the global pointer
@@ -201,7 +201,7 @@ fn get_global_state() -> Exclusive<GlobalState> {
                 let prev_i = unsafe {
                     atomic_cxchg(&mut *global_ptr, state_i, POISON)
                 };
-                fail_unless!(prev_i == state_i);
+                assert!(prev_i == state_i);
 
                 // Capture the global state object in the at_exit closure
                 // so that it is destroyed at the right time
@@ -245,7 +245,7 @@ fn test_clone_rc() {
                     ~shared_mutable_state(10)
                 };
 
-                fail_unless!(get_shared_immutable_state(&val) == &10);
+                assert!(get_shared_immutable_state(&val) == &10);
             }
         }
     }
@@ -273,7 +273,7 @@ fn test_modify() {
             match v {
                 Some(sms) => {
                     let v = get_shared_immutable_state(sms);
-                    fail_unless!(*v == 10);
+                    assert!(*v == 10);
                     None
                 },
                 _ => fail!()
diff --git a/src/libcore/unstable/weak_task.rs b/src/libcore/unstable/weak_task.rs
index 6de324f3101..8b24c2fa6f6 100644
--- a/src/libcore/unstable/weak_task.rs
+++ b/src/libcore/unstable/weak_task.rs
@@ -42,7 +42,7 @@ pub unsafe fn weaken_task(f: &fn(Port<ShutdownMsg>)) {
     let shutdown_port = Cell(shutdown_port);
     let task = get_task_id();
     // Expect the weak task service to be alive
-    fail_unless!(service.try_send(RegisterWeakTask(task, shutdown_chan)));
+    assert!(service.try_send(RegisterWeakTask(task, shutdown_chan)));
     unsafe { rust_dec_kernel_live_count(); }
     do (|| {
         f(shutdown_port.take())
@@ -104,7 +104,7 @@ fn run_weak_task_service(port: Port<ServiceMsg>) {
             RegisterWeakTask(task, shutdown_chan) => {
                 let previously_unregistered =
                     shutdown_map.insert(task, shutdown_chan);
-                fail_unless!(previously_unregistered);
+                assert!(previously_unregistered);
             }
             UnregisterWeakTask(task) => {
                 match shutdown_map.pop(&task) {
diff --git a/src/libcore/util.rs b/src/libcore/util.rs
index 739314bf619..a08e38c021f 100644
--- a/src/libcore/util.rs
+++ b/src/libcore/util.rs
@@ -82,7 +82,7 @@ terminate normally, but instead directly return from a function.
 
 ~~~
 fn choose_weighted_item(v: &[Item]) -> Item {
-    fail_unless!(!v.is_empty());
+    assert!(!v.is_empty());
     let mut so_far = 0u;
     for v.each |item| {
         so_far += item.weight;
@@ -110,23 +110,23 @@ mod tests {
     pub fn identity_crisis() {
         // Writing a test for the identity function. How did it come to this?
         let x = ~[(5, false)];
-        //FIXME #3387 fail_unless!(x.eq(id(copy x)));
+        //FIXME #3387 assert!(x.eq(id(copy x)));
         let y = copy x;
-        fail_unless!(x.eq(&id(y)));
+        assert!(x.eq(&id(y)));
     }
     #[test]
     pub fn test_swap() {
         let mut x = 31337;
         let mut y = 42;
         swap(&mut x, &mut y);
-        fail_unless!(x == 42);
-        fail_unless!(y == 31337);
+        assert!(x == 42);
+        assert!(y == 31337);
     }
     #[test]
     pub fn test_replace() {
         let mut x = Some(NonCopyable());
         let y = replace(&mut x, None);
-        fail_unless!(x.is_none());
-        fail_unless!(y.is_some());
+        assert!(x.is_none());
+        assert!(y.is_some());
     }
 }
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 6b312c48d15..566bceaa86f 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -267,8 +267,8 @@ pub fn last_opt<'r,T>(v: &'r [T]) -> Option<&'r T> {
 /// Return a slice that points into another slice.
 #[inline(always)]
 pub fn slice<'r,T>(v: &'r [T], start: uint, end: uint) -> &'r [T] {
-    fail_unless!(start <= end);
-    fail_unless!(end <= len(v));
+    assert!(start <= end);
+    assert!(end <= len(v));
     do as_imm_buf(v) |p, _len| {
         unsafe {
             ::cast::reinterpret_cast(
@@ -282,8 +282,8 @@ pub fn slice<'r,T>(v: &'r [T], start: uint, end: uint) -> &'r [T] {
 #[inline(always)]
 pub fn mut_slice<'r,T>(v: &'r mut [T], start: uint, end: uint)
                     -> &'r mut [T] {
-    fail_unless!(start <= end);
-    fail_unless!(end <= v.len());
+    assert!(start <= end);
+    assert!(end <= v.len());
     do as_mut_buf(v) |p, _len| {
         unsafe {
             ::cast::reinterpret_cast(
@@ -297,8 +297,8 @@ pub fn mut_slice<'r,T>(v: &'r mut [T], start: uint, end: uint)
 #[inline(always)]
 pub fn const_slice<'r,T>(v: &'r const [T], start: uint, end: uint)
                       -> &'r const [T] {
-    fail_unless!(start <= end);
-    fail_unless!(end <= len(v));
+    assert!(start <= end);
+    assert!(end <= len(v));
     do as_const_buf(v) |p, _len| {
         unsafe {
             ::cast::reinterpret_cast(
@@ -454,7 +454,7 @@ pub fn partitioned<T:Copy>(v: &[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) {
 /// Removes the first element from a vector and return it
 pub fn shift<T>(v: &mut ~[T]) -> T {
     unsafe {
-        fail_unless!(!v.is_empty());
+        assert!(!v.is_empty());
 
         if v.len() == 1 { return v.pop() }
 
@@ -471,7 +471,7 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
         // Save the last element. We're going to overwrite its position
         let mut work_elt = v.pop();
         // We still should have room to work where what last element was
-        fail_unless!(capacity(v) >= ln);
+        assert!(capacity(v) >= ln);
         // Pretend like we have the original length so we can use
         // the vector copy_memory to overwrite the hole we just made
         raw::set_len(&mut *v, ln);
@@ -517,7 +517,7 @@ pub fn unshift<T>(v: &mut ~[T], x: T) {
 /// elements after position i one position to the right.
 pub fn insert<T>(v: &mut ~[T], i: uint, x: T) {
     let len = v.len();
-    fail_unless!(i <= len);
+    assert!(i <= len);
 
     v.push(x);
     let mut j = len;
@@ -531,7 +531,7 @@ pub fn insert<T>(v: &mut ~[T], i: uint, x: T) {
 /// all elements after position i one position to the left.
 pub fn remove<T>(v: &mut ~[T], i: uint) -> T {
     let len = v.len();
-    fail_unless!(i < len);
+    assert!(i < len);
 
     let mut j = i;
     while j < len - 1 {
@@ -656,7 +656,7 @@ pub fn push_all_move<T>(v: &mut ~[T], mut rhs: ~[T]) {
 /// Shorten a vector, dropping excess elements.
 pub fn truncate<T>(v: &mut ~[T], newlen: uint) {
     do as_mut_buf(*v) |p, oldlen| {
-        fail_unless!(newlen <= oldlen);
+        assert!(newlen <= oldlen);
         unsafe {
             // This loop is optimized out for non-drop types.
             for uint::range(newlen, oldlen) |i| {
@@ -1160,8 +1160,8 @@ pub fn position_between<T>(v: &[T],
                            end: uint,
                            f: &fn(t: &T) -> bool)
                         -> Option<uint> {
-    fail_unless!(start <= end);
-    fail_unless!(end <= len(v));
+    assert!(start <= end);
+    assert!(end <= len(v));
     let mut i = start;
     while i < end { if f(&v[i]) { return Some::<uint>(i); } i += 1u; }
     None
@@ -1193,8 +1193,8 @@ pub fn rposition<T>(v: &[T], f: &fn(t: &T) -> bool) -> Option<uint> {
  */
 pub fn rposition_between<T>(v: &[T], start: uint, end: uint,
                              f: &fn(t: &T) -> bool) -> Option<uint> {
-    fail_unless!(start <= end);
-    fail_unless!(end <= len(v));
+    assert!(start <= end);
+    assert!(end <= len(v));
     let mut i = end;
     while i > start {
         if f(&v[i - 1u]) { return Some::<uint>(i - 1u); }
@@ -1250,7 +1250,7 @@ pub fn zip_slice<T:Copy,U:Copy>(v: &const [T], u: &const [U])
     let mut zipped = ~[];
     let sz = len(v);
     let mut i = 0u;
-    fail_unless!(sz == len(u));
+    assert!(sz == len(u));
     while i < sz {
         unsafe { zipped.push((v[i], u[i])); i += 1u; }
     }
@@ -1265,7 +1265,7 @@ pub fn zip_slice<T:Copy,U:Copy>(v: &const [T], u: &const [U])
  */
 pub fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] {
     let mut i = len(v);
-    fail_unless!(i == len(u));
+    assert!(i == len(u));
     let mut w = with_capacity(i);
     while i > 0 {
         unsafe { w.push((v.pop(),u.pop())); }
@@ -1444,7 +1444,7 @@ pub fn eachi_reverse<'r,T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
  */
 #[inline]
 pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) {
-    fail_unless!(len(v1) == len(v2));
+    assert!(len(v1) == len(v2));
     for uint::range(0u, len(v1)) |i| {
         if !f(&v1[i], &v2[i]) {
             return;
@@ -1488,7 +1488,7 @@ pub fn each_permutation<T:Copy>(v: &[T], put: &fn(ts: &[T]) -> bool) {
 
 pub fn windowed<TT:Copy>(nn: uint, xx: &[TT]) -> ~[~[TT]] {
     let mut ww = ~[];
-    fail_unless!(1u <= nn);
+    assert!(1u <= nn);
     for vec::eachi (xx) |ii, _x| {
         let len = xx.len();
         if ii+nn <= len {
@@ -2267,8 +2267,8 @@ pub mod raw {
     #[inline(always)]
     pub unsafe fn copy_memory<T>(dst: &mut [T], src: &const [T],
                                  count: uint) {
-        fail_unless!(dst.len() >= count);
-        fail_unless!(src.len() >= count);
+        assert!(dst.len() >= count);
+        assert!(src.len() >= count);
 
         do as_mut_buf(dst) |p_dst, _len_dst| {
             do as_const_buf(src) |p_src, _len_src| {
@@ -2604,21 +2604,21 @@ mod tests {
             let a = ~[1, 2, 3];
             let mut ptr = raw::to_ptr(a);
             let b = from_buf(ptr, 3u);
-            fail_unless!(b.len() == 3u);
-            fail_unless!(b[0] == 1);
-            fail_unless!(b[1] == 2);
-            fail_unless!(b[2] == 3);
+            assert!(b.len() == 3u);
+            assert!(b[0] == 1);
+            assert!(b[1] == 2);
+            assert!(b[2] == 3);
 
             // Test on-heap copy-from-buf.
             let c = ~[1, 2, 3, 4, 5];
             ptr = raw::to_ptr(c);
             let d = from_buf(ptr, 5u);
-            fail_unless!(d.len() == 5u);
-            fail_unless!(d[0] == 1);
-            fail_unless!(d[1] == 2);
-            fail_unless!(d[2] == 3);
-            fail_unless!(d[3] == 4);
-            fail_unless!(d[4] == 5);
+            assert!(d.len() == 5u);
+            assert!(d[0] == 1);
+            assert!(d[1] == 2);
+            assert!(d[2] == 3);
+            assert!(d[3] == 4);
+            assert!(d[4] == 5);
         }
     }
 
@@ -2626,43 +2626,43 @@ mod tests {
     fn test_from_fn() {
         // Test on-stack from_fn.
         let mut v = from_fn(3u, square);
-        fail_unless!(v.len() == 3u);
-        fail_unless!(v[0] == 0u);
-        fail_unless!(v[1] == 1u);
-        fail_unless!(v[2] == 4u);
+        assert!(v.len() == 3u);
+        assert!(v[0] == 0u);
+        assert!(v[1] == 1u);
+        assert!(v[2] == 4u);
 
         // Test on-heap from_fn.
         v = from_fn(5u, square);
-        fail_unless!(v.len() == 5u);
-        fail_unless!(v[0] == 0u);
-        fail_unless!(v[1] == 1u);
-        fail_unless!(v[2] == 4u);
-        fail_unless!(v[3] == 9u);
-        fail_unless!(v[4] == 16u);
+        assert!(v.len() == 5u);
+        assert!(v[0] == 0u);
+        assert!(v[1] == 1u);
+        assert!(v[2] == 4u);
+        assert!(v[3] == 9u);
+        assert!(v[4] == 16u);
     }
 
     #[test]
     fn test_from_elem() {
         // Test on-stack from_elem.
         let mut v = from_elem(2u, 10u);
-        fail_unless!(v.len() == 2u);
-        fail_unless!(v[0] == 10u);
-        fail_unless!(v[1] == 10u);
+        assert!(v.len() == 2u);
+        assert!(v[0] == 10u);
+        assert!(v[1] == 10u);
 
         // Test on-heap from_elem.
         v = from_elem(6u, 20u);
-        fail_unless!(v[0] == 20u);
-        fail_unless!(v[1] == 20u);
-        fail_unless!(v[2] == 20u);
-        fail_unless!(v[3] == 20u);
-        fail_unless!(v[4] == 20u);
-        fail_unless!(v[5] == 20u);
+        assert!(v[0] == 20u);
+        assert!(v[1] == 20u);
+        assert!(v[2] == 20u);
+        assert!(v[3] == 20u);
+        assert!(v[4] == 20u);
+        assert!(v[5] == 20u);
     }
 
     #[test]
     fn test_is_empty() {
-        fail_unless!(is_empty::<int>(~[]));
-        fail_unless!(!is_empty(~[0]));
+        assert!(is_empty::<int>(~[]));
+        assert!(!is_empty(~[0]));
     }
 
     #[test]
@@ -2671,18 +2671,18 @@ mod tests {
         let v0 : &[Z] = &[];
         let v1 : &[Z] = &[[]];
         let v2 : &[Z] = &[[], []];
-        fail_unless!(sys::size_of::<Z>() == 0);
-        fail_unless!(v0.len() == 0);
-        fail_unless!(v1.len() == 1);
-        fail_unless!(v2.len() == 2);
+        assert!(sys::size_of::<Z>() == 0);
+        assert!(v0.len() == 0);
+        assert!(v1.len() == 1);
+        assert!(v2.len() == 2);
     }
 
     #[test]
     fn test_head() {
         let mut a = ~[11];
-        fail_unless!(a.head() == &11);
+        assert!(a.head() == &11);
         a = ~[11, 12];
-        fail_unless!(a.head() == &11);
+        assert!(a.head() == &11);
     }
 
     #[test]
@@ -2696,19 +2696,19 @@ mod tests {
     #[test]
     fn test_head_opt() {
         let mut a = ~[];
-        fail_unless!(a.head_opt() == None);
+        assert!(a.head_opt() == None);
         a = ~[11];
-        fail_unless!(a.head_opt().unwrap() == &11);
+        assert!(a.head_opt().unwrap() == &11);
         a = ~[11, 12];
-        fail_unless!(a.head_opt().unwrap() == &11);
+        assert!(a.head_opt().unwrap() == &11);
     }
 
     #[test]
     fn test_tail() {
         let mut a = ~[11];
-        fail_unless!(a.tail() == &[]);
+        assert!(a.tail() == &[]);
         a = ~[11, 12];
-        fail_unless!(a.tail() == &[12]);
+        assert!(a.tail() == &[12]);
     }
 
     #[test]
@@ -2722,9 +2722,9 @@ mod tests {
     #[test]
     fn test_tailn() {
         let mut a = ~[11, 12, 13];
-        fail_unless!(a.tailn(0) == &[11, 12, 13]);
+        assert!(a.tailn(0) == &[11, 12, 13]);
         a = ~[11, 12, 13];
-        fail_unless!(a.tailn(2) == &[13]);
+        assert!(a.tailn(2) == &[13]);
     }
 
     #[test]
@@ -2738,9 +2738,9 @@ mod tests {
     #[test]
     fn test_init() {
         let mut a = ~[11];
-        fail_unless!(a.init() == &[]);
+        assert!(a.init() == &[]);
         a = ~[11, 12];
-        fail_unless!(a.init() == &[11]);
+        assert!(a.init() == &[11]);
     }
 
     #[init]
@@ -2754,9 +2754,9 @@ mod tests {
     #[test]
     fn test_initn() {
         let mut a = ~[11, 12, 13];
-        fail_unless!(a.initn(0) == &[11, 12, 13]);
+        assert!(a.initn(0) == &[11, 12, 13]);
         a = ~[11, 12, 13];
-        fail_unless!(a.initn(2) == &[11]);
+        assert!(a.initn(2) == &[11]);
     }
 
     #[init]
@@ -2770,9 +2770,9 @@ mod tests {
     #[test]
     fn test_last() {
         let mut a = ~[11];
-        fail_unless!(a.last() == &11);
+        assert!(a.last() == &11);
         a = ~[11, 12];
-        fail_unless!(a.last() == &12);
+        assert!(a.last() == &12);
     }
 
     #[test]
@@ -2786,11 +2786,11 @@ mod tests {
     #[test]
     fn test_last_opt() {
         let mut a = ~[];
-        fail_unless!(a.last_opt() == None);
+        assert!(a.last_opt() == None);
         a = ~[11];
-        fail_unless!(a.last_opt().unwrap() == &11);
+        assert!(a.last_opt().unwrap() == &11);
         a = ~[11, 12];
-        fail_unless!(a.last_opt().unwrap() == &12);
+        assert!(a.last_opt().unwrap() == &12);
     }
 
     #[test]
@@ -2798,35 +2798,35 @@ mod tests {
         // Test fixed length vector.
         let vec_fixed = [1, 2, 3, 4];
         let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_vec();
-        fail_unless!(v_a.len() == 3u);
-        fail_unless!(v_a[0] == 2);
-        fail_unless!(v_a[1] == 3);
-        fail_unless!(v_a[2] == 4);
+        assert!(v_a.len() == 3u);
+        assert!(v_a[0] == 2);
+        assert!(v_a[1] == 3);
+        assert!(v_a[2] == 4);
 
         // Test on stack.
         let vec_stack = &[1, 2, 3];
         let v_b = slice(vec_stack, 1u, 3u).to_vec();
-        fail_unless!(v_b.len() == 2u);
-        fail_unless!(v_b[0] == 2);
-        fail_unless!(v_b[1] == 3);
+        assert!(v_b.len() == 2u);
+        assert!(v_b[0] == 2);
+        assert!(v_b[1] == 3);
 
         // Test on managed heap.
         let vec_managed = @[1, 2, 3, 4, 5];
         let v_c = slice(vec_managed, 0u, 3u).to_vec();
-        fail_unless!(v_c.len() == 3u);
-        fail_unless!(v_c[0] == 1);
-        fail_unless!(v_c[1] == 2);
-        fail_unless!(v_c[2] == 3);
+        assert!(v_c.len() == 3u);
+        assert!(v_c[0] == 1);
+        assert!(v_c[1] == 2);
+        assert!(v_c[2] == 3);
 
         // Test on exchange heap.
         let vec_unique = ~[1, 2, 3, 4, 5, 6];
         let v_d = slice(vec_unique, 1u, 6u).to_vec();
-        fail_unless!(v_d.len() == 5u);
-        fail_unless!(v_d[0] == 2);
-        fail_unless!(v_d[1] == 3);
-        fail_unless!(v_d[2] == 4);
-        fail_unless!(v_d[3] == 5);
-        fail_unless!(v_d[4] == 6);
+        assert!(v_d.len() == 5u);
+        assert!(v_d[0] == 2);
+        assert!(v_d[1] == 3);
+        assert!(v_d[2] == 4);
+        assert!(v_d[3] == 5);
+        assert!(v_d[4] == 6);
     }
 
     #[test]
@@ -2834,27 +2834,27 @@ mod tests {
         // Test on-heap pop.
         let mut v = ~[1, 2, 3, 4, 5];
         let e = v.pop();
-        fail_unless!(v.len() == 4u);
-        fail_unless!(v[0] == 1);
-        fail_unless!(v[1] == 2);
-        fail_unless!(v[2] == 3);
-        fail_unless!(v[3] == 4);
-        fail_unless!(e == 5);
+        assert!(v.len() == 4u);
+        assert!(v[0] == 1);
+        assert!(v[1] == 2);
+        assert!(v[2] == 3);
+        assert!(v[3] == 4);
+        assert!(e == 5);
     }
 
     #[test]
     fn test_swap_remove() {
         let mut v = ~[1, 2, 3, 4, 5];
         let mut e = v.swap_remove(0);
-        fail_unless!(v.len() == 4);
-        fail_unless!(e == 1);
-        fail_unless!(v[0] == 5);
+        assert!(v.len() == 4);
+        assert!(e == 1);
+        assert!(v[0] == 5);
         e = v.swap_remove(3);
-        fail_unless!(v.len() == 3);
-        fail_unless!(e == 4);
-        fail_unless!(v[0] == 5);
-        fail_unless!(v[1] == 2);
-        fail_unless!(v[2] == 3);
+        assert!(v.len() == 3);
+        assert!(e == 4);
+        assert!(v[0] == 5);
+        assert!(v[1] == 2);
+        assert!(v[2] == 3);
     }
 
     #[test]
@@ -2863,11 +2863,11 @@ mod tests {
         let mut v = ~[::unstable::exclusive(()), ::unstable::exclusive(()),
                       ::unstable::exclusive(())];
         let mut _e = v.swap_remove(0);
-        fail_unless!(v.len() == 2);
+        assert!(v.len() == 2);
         _e = v.swap_remove(1);
-        fail_unless!(v.len() == 1);
+        assert!(v.len() == 1);
         _e = v.swap_remove(0);
-        fail_unless!(v.len() == 0);
+        assert!(v.len() == 0);
     }
 
     #[test]
@@ -2875,14 +2875,14 @@ mod tests {
         // Test on-stack push().
         let mut v = ~[];
         v.push(1);
-        fail_unless!(v.len() == 1u);
-        fail_unless!(v[0] == 1);
+        assert!(v.len() == 1u);
+        assert!(v[0] == 1);
 
         // Test on-heap push().
         v.push(2);
-        fail_unless!(v.len() == 2u);
-        fail_unless!(v[0] == 1);
-        fail_unless!(v[1] == 2);
+        assert!(v.len() == 2u);
+        assert!(v[0] == 1);
+        assert!(v[1] == 2);
     }
 
     #[test]
@@ -2890,48 +2890,48 @@ mod tests {
         // Test on-stack grow().
         let mut v = ~[];
         v.grow(2u, &1);
-        fail_unless!(v.len() == 2u);
-        fail_unless!(v[0] == 1);
-        fail_unless!(v[1] == 1);
+        assert!(v.len() == 2u);
+        assert!(v[0] == 1);
+        assert!(v[1] == 1);
 
         // Test on-heap grow().
         v.grow(3u, &2);
-        fail_unless!(v.len() == 5u);
-        fail_unless!(v[0] == 1);
-        fail_unless!(v[1] == 1);
-        fail_unless!(v[2] == 2);
-        fail_unless!(v[3] == 2);
-        fail_unless!(v[4] == 2);
+        assert!(v.len() == 5u);
+        assert!(v[0] == 1);
+        assert!(v[1] == 1);
+        assert!(v[2] == 2);
+        assert!(v[3] == 2);
+        assert!(v[4] == 2);
     }
 
     #[test]
     fn test_grow_fn() {
         let mut v = ~[];
         v.grow_fn(3u, square);
-        fail_unless!(v.len() == 3u);
-        fail_unless!(v[0] == 0u);
-        fail_unless!(v[1] == 1u);
-        fail_unless!(v[2] == 4u);
+        assert!(v.len() == 3u);
+        assert!(v[0] == 0u);
+        assert!(v[1] == 1u);
+        assert!(v[2] == 4u);
     }
 
     #[test]
     fn test_grow_set() {
         let mut v = ~[1, 2, 3];
         v.grow_set(4u, &4, 5);
-        fail_unless!(v.len() == 5u);
-        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.len() == 5u);
+        assert!(v[0] == 1);
+        assert!(v[1] == 2);
+        assert!(v[2] == 3);
+        assert!(v[3] == 4);
+        assert!(v[4] == 5);
     }
 
     #[test]
     fn test_truncate() {
         let mut v = ~[@6,@5,@4];
         v.truncate(1);
-        fail_unless!(v.len() == 1);
-        fail_unless!(*(v[0]) == 6);
+        assert!(v.len() == 1);
+        assert!(*(v[0]) == 6);
         // If the unsafe block didn't drop things properly, we blow up here.
     }
 
@@ -2939,7 +2939,7 @@ mod tests {
     fn test_clear() {
         let mut v = ~[@6,@5,@4];
         v.clear();
-        fail_unless!(v.len() == 0);
+        assert!(v.len() == 0);
         // If the unsafe block didn't drop things properly, we blow up here.
     }
 
@@ -2948,7 +2948,7 @@ mod tests {
         fn case(a: ~[uint], b: ~[uint]) {
             let mut v = a;
             v.dedup();
-            fail_unless!(v == b);
+            assert!(v == b);
         }
         case(~[], ~[]);
         case(~[1], ~[1]);
@@ -2993,20 +2993,20 @@ mod tests {
         // Test on-stack map.
         let mut v = ~[1u, 2u, 3u];
         let mut w = map(v, square_ref);
-        fail_unless!(w.len() == 3u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 4u);
-        fail_unless!(w[2] == 9u);
+        assert!(w.len() == 3u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 4u);
+        assert!(w[2] == 9u);
 
         // Test on-heap map.
         v = ~[1u, 2u, 3u, 4u, 5u];
         w = map(v, square_ref);
-        fail_unless!(w.len() == 5u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 4u);
-        fail_unless!(w[2] == 9u);
-        fail_unless!(w[3] == 16u);
-        fail_unless!(w[4] == 25u);
+        assert!(w.len() == 5u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 4u);
+        assert!(w[2] == 9u);
+        assert!(w[3] == 16u);
+        assert!(w[4] == 25u);
     }
 
     #[test]
@@ -3017,7 +3017,7 @@ mod tests {
         let v1 = ~[5, 4, 3, 2, 1];
         let u = map2::<int, int, int>(v0, v1, f);
         let mut i = 0;
-        while i < 5 { fail_unless!(v0[i] * v1[i] == u[i]); i += 1; }
+        while i < 5 { assert!(v0[i] * v1[i] == u[i]); i += 1; }
     }
 
     #[test]
@@ -3025,17 +3025,17 @@ mod tests {
         // Test on-stack filter-map.
         let mut v = ~[1u, 2u, 3u];
         let mut w = filter_mapped(v, square_if_odd_r);
-        fail_unless!(w.len() == 2u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 9u);
+        assert!(w.len() == 2u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 9u);
 
         // Test on-heap filter-map.
         v = ~[1u, 2u, 3u, 4u, 5u];
         w = filter_mapped(v, square_if_odd_r);
-        fail_unless!(w.len() == 3u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 9u);
-        fail_unless!(w[2] == 25u);
+        assert!(w.len() == 3u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 9u);
+        assert!(w[2] == 25u);
 
         fn halve(i: &int) -> Option<int> {
             if *i % 2 == 0 {
@@ -3050,11 +3050,11 @@ mod tests {
         let all_odd2: ~[int] = ~[];
         let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3];
         let mix_dest: ~[int] = ~[1, 3, 0, 0];
-        fail_unless!(filter_mapped(all_even, halve) ==
+        assert!(filter_mapped(all_even, halve) ==
                      map(all_even, halve_for_sure));
-        fail_unless!(filter_mapped(all_odd1, halve) == ~[]);
-        fail_unless!(filter_mapped(all_odd2, halve) == ~[]);
-        fail_unless!(filter_mapped(mix, halve) == mix_dest);
+        assert!(filter_mapped(all_odd1, halve) == ~[]);
+        assert!(filter_mapped(all_odd2, halve) == ~[]);
+        assert!(filter_mapped(mix, halve) == mix_dest);
     }
 
     #[test]
@@ -3062,17 +3062,17 @@ mod tests {
         // Test on-stack filter-map.
         let mut v = ~[1u, 2u, 3u];
         let mut w = filter_map(v, square_if_odd_v);
-        fail_unless!(w.len() == 2u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 9u);
+        assert!(w.len() == 2u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 9u);
 
         // Test on-heap filter-map.
         v = ~[1u, 2u, 3u, 4u, 5u];
         w = filter_map(v, square_if_odd_v);
-        fail_unless!(w.len() == 3u);
-        fail_unless!(w[0] == 1u);
-        fail_unless!(w[1] == 9u);
-        fail_unless!(w[2] == 25u);
+        assert!(w.len() == 3u);
+        assert!(w[0] == 1u);
+        assert!(w[1] == 9u);
+        assert!(w[2] == 25u);
 
         fn halve(i: int) -> Option<int> {
             if i % 2 == 0 {
@@ -3088,24 +3088,24 @@ mod tests {
         let all_odd2: ~[int] = ~[];
         let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3];
         let mix_dest: ~[int] = ~[1, 3, 0, 0];
-        fail_unless!(filter_map(all_even, halve) ==
+        assert!(filter_map(all_even, halve) ==
                      map(all_even0, halve_for_sure));
-        fail_unless!(filter_map(all_odd1, halve) == ~[]);
-        fail_unless!(filter_map(all_odd2, halve) == ~[]);
-        fail_unless!(filter_map(mix, halve) == mix_dest);
+        assert!(filter_map(all_odd1, halve) == ~[]);
+        assert!(filter_map(all_odd2, halve) == ~[]);
+        assert!(filter_map(mix, halve) == mix_dest);
     }
 
     #[test]
     fn test_filter() {
-        fail_unless!(filter(~[1u, 2u, 3u], is_odd) == ~[1u, 3u]);
-        fail_unless!(filter(~[1u, 2u, 4u, 8u, 16u], is_three) == ~[]);
+        assert!(filter(~[1u, 2u, 3u], is_odd) == ~[1u, 3u]);
+        assert!(filter(~[1u, 2u, 4u, 8u, 16u], is_three) == ~[]);
     }
 
     #[test]
     fn test_retain() {
         let mut v = ~[1, 2, 3, 4, 5];
         v.retain(is_odd);
-        fail_unless!(v == ~[1, 3, 5]);
+        assert!(v == ~[1, 3, 5]);
     }
 
     #[test]
@@ -3113,12 +3113,12 @@ mod tests {
         // Test on-stack fold.
         let mut v = ~[1u, 2u, 3u];
         let mut sum = foldl(0u, v, add);
-        fail_unless!(sum == 6u);
+        assert!(sum == 6u);
 
         // Test on-heap fold.
         v = ~[1u, 2u, 3u, 4u, 5u];
         sum = foldl(0u, v, add);
-        fail_unless!(sum == 15u);
+        assert!(sum == 15u);
     }
 
     #[test]
@@ -3128,7 +3128,7 @@ mod tests {
         }
         let mut v = ~[1, 2, 3, 4];
         let sum = foldl(0, v, sub);
-        fail_unless!(sum == -10);
+        assert!(sum == -10);
     }
 
     #[test]
@@ -3138,7 +3138,7 @@ mod tests {
         }
         let mut v = ~[1, 2, 3, 4];
         let sum = foldr(v, 0, sub);
-        fail_unless!(sum == -2);
+        assert!(sum == -2);
     }
 
     #[test]
@@ -3154,18 +3154,18 @@ mod tests {
         for each(~[1, 2, 3]) |v| {
             i += *v;
         }
-        fail_unless!(i == 6);
+        assert!(i == 6);
     }
 
     #[test]
     fn test_iteri() {
         let mut i = 0;
         for eachi(~[1, 2, 3]) |j, v| {
-            if i == 0 { fail_unless!(*v == 1); }
-            fail_unless!(j + 1u == *v as uint);
+            if i == 0 { assert!(*v == 1); }
+            assert!(j + 1u == *v as uint);
             i += *v;
         }
-        fail_unless!(i == 6);
+        assert!(i == 6);
     }
 
     #[test]
@@ -3180,21 +3180,21 @@ mod tests {
     fn test_each_reverse_nonempty() {
         let mut i = 0;
         for each_reverse(~[1, 2, 3]) |v| {
-            if i == 0 { fail_unless!(*v == 3); }
+            if i == 0 { assert!(*v == 3); }
             i += *v
         }
-        fail_unless!(i == 6);
+        assert!(i == 6);
     }
 
     #[test]
     fn test_eachi_reverse() {
         let mut i = 0;
         for eachi_reverse(~[0, 1, 2]) |j, v| {
-            if i == 0 { fail_unless!(*v == 2); }
-            fail_unless!(j == *v as uint);
+            if i == 0 { assert!(*v == 2); }
+            assert!(j == *v as uint);
             i += *v;
         }
-        fail_unless!(i == 3);
+        assert!(i == 3);
     }
 
     #[test]
@@ -3211,47 +3211,47 @@ mod tests {
 
         results = ~[];
         for each_permutation(~[]) |v| { results.push(from_slice(v)); }
-        fail_unless!(results == ~[~[]]);
+        assert!(results == ~[~[]]);
 
         results = ~[];
         for each_permutation(~[7]) |v| { results.push(from_slice(v)); }
-        fail_unless!(results == ~[~[7]]);
+        assert!(results == ~[~[7]]);
 
         results = ~[];
         for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); }
-        fail_unless!(results == ~[~[1,1],~[1,1]]);
+        assert!(results == ~[~[1,1],~[1,1]]);
 
         results = ~[];
         for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); }
-        fail_unless!(results ==
+        assert!(results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]);
     }
 
     #[test]
     fn test_any_and_all() {
-        fail_unless!(any(~[1u, 2u, 3u], is_three));
-        fail_unless!(!any(~[0u, 1u, 2u], is_three));
-        fail_unless!(any(~[1u, 2u, 3u, 4u, 5u], is_three));
-        fail_unless!(!any(~[1u, 2u, 4u, 5u, 6u], is_three));
+        assert!(any(~[1u, 2u, 3u], is_three));
+        assert!(!any(~[0u, 1u, 2u], is_three));
+        assert!(any(~[1u, 2u, 3u, 4u, 5u], is_three));
+        assert!(!any(~[1u, 2u, 4u, 5u, 6u], is_three));
 
-        fail_unless!(all(~[3u, 3u, 3u], is_three));
-        fail_unless!(!all(~[3u, 3u, 2u], is_three));
-        fail_unless!(all(~[3u, 3u, 3u, 3u, 3u], is_three));
-        fail_unless!(!all(~[3u, 3u, 0u, 1u, 2u], is_three));
+        assert!(all(~[3u, 3u, 3u], is_three));
+        assert!(!all(~[3u, 3u, 2u], is_three));
+        assert!(all(~[3u, 3u, 3u, 3u, 3u], is_three));
+        assert!(!all(~[3u, 3u, 0u, 1u, 2u], is_three));
     }
 
     #[test]
     fn test_any2_and_all2() {
 
-        fail_unless!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
-        fail_unless!(any2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
-        fail_unless!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
-        fail_unless!(any2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
+        assert!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
+        assert!(any2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
+        assert!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
+        assert!(any2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
 
-        fail_unless!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
-        fail_unless!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
-        fail_unless!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
-        fail_unless!(!all2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
+        assert!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal));
+        assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal));
+        assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal));
+        assert!(!all2(~[2u, 4u, 6u], ~[2u, 4u], is_equal));
     }
 
     #[test]
@@ -3261,26 +3261,26 @@ mod tests {
 
         let z1 = zip(v1, v2);
 
-        fail_unless!((1, 4) == z1[0]);
-        fail_unless!((2, 5) == z1[1]);
-        fail_unless!((3, 6) == z1[2]);
+        assert!((1, 4) == z1[0]);
+        assert!((2, 5) == z1[1]);
+        assert!((3, 6) == z1[2]);
 
         let (left, right) = unzip(z1);
 
-        fail_unless!((1, 4) == (left[0], right[0]));
-        fail_unless!((2, 5) == (left[1], right[1]));
-        fail_unless!((3, 6) == (left[2], right[2]));
+        assert!((1, 4) == (left[0], right[0]));
+        assert!((2, 5) == (left[1], right[1]));
+        assert!((3, 6) == (left[2], right[2]));
     }
 
     #[test]
     fn test_position_elem() {
-        fail_unless!(position_elem(~[], &1).is_none());
+        assert!(position_elem(~[], &1).is_none());
 
         let v1 = ~[1, 2, 3, 3, 2, 5];
-        fail_unless!(position_elem(v1, &1) == Some(0u));
-        fail_unless!(position_elem(v1, &2) == Some(1u));
-        fail_unless!(position_elem(v1, &5) == Some(5u));
-        fail_unless!(position_elem(v1, &4).is_none());
+        assert!(position_elem(v1, &1) == Some(0u));
+        assert!(position_elem(v1, &2) == Some(1u));
+        assert!(position_elem(v1, &5) == Some(5u));
+        assert!(position_elem(v1, &4).is_none());
     }
 
     #[test]
@@ -3288,178 +3288,178 @@ mod tests {
         fn less_than_three(i: &int) -> bool { *i < 3 }
         fn is_eighteen(i: &int) -> bool { *i == 18 }
 
-        fail_unless!(position(~[], less_than_three).is_none());
+        assert!(position(~[], less_than_three).is_none());
 
         let v1 = ~[5, 4, 3, 2, 1];
-        fail_unless!(position(v1, less_than_three) == Some(3u));
-        fail_unless!(position(v1, is_eighteen).is_none());
+        assert!(position(v1, less_than_three) == Some(3u));
+        assert!(position(v1, is_eighteen).is_none());
     }
 
     #[test]
     fn test_position_between() {
-        fail_unless!(position_between(~[], 0u, 0u, f).is_none());
+        assert!(position_between(~[], 0u, 0u, f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(position_between(v, 0u, 0u, f).is_none());
-        fail_unless!(position_between(v, 0u, 1u, f).is_none());
-        fail_unless!(position_between(v, 0u, 2u, f) == Some(1u));
-        fail_unless!(position_between(v, 0u, 3u, f) == Some(1u));
-        fail_unless!(position_between(v, 0u, 4u, f) == Some(1u));
+        assert!(position_between(v, 0u, 0u, f).is_none());
+        assert!(position_between(v, 0u, 1u, f).is_none());
+        assert!(position_between(v, 0u, 2u, f) == Some(1u));
+        assert!(position_between(v, 0u, 3u, f) == Some(1u));
+        assert!(position_between(v, 0u, 4u, f) == Some(1u));
 
-        fail_unless!(position_between(v, 1u, 1u, f).is_none());
-        fail_unless!(position_between(v, 1u, 2u, f) == Some(1u));
-        fail_unless!(position_between(v, 1u, 3u, f) == Some(1u));
-        fail_unless!(position_between(v, 1u, 4u, f) == Some(1u));
+        assert!(position_between(v, 1u, 1u, f).is_none());
+        assert!(position_between(v, 1u, 2u, f) == Some(1u));
+        assert!(position_between(v, 1u, 3u, f) == Some(1u));
+        assert!(position_between(v, 1u, 4u, f) == Some(1u));
 
-        fail_unless!(position_between(v, 2u, 2u, f).is_none());
-        fail_unless!(position_between(v, 2u, 3u, f).is_none());
-        fail_unless!(position_between(v, 2u, 4u, f) == Some(3u));
+        assert!(position_between(v, 2u, 2u, f).is_none());
+        assert!(position_between(v, 2u, 3u, f).is_none());
+        assert!(position_between(v, 2u, 4u, f) == Some(3u));
 
-        fail_unless!(position_between(v, 3u, 3u, f).is_none());
-        fail_unless!(position_between(v, 3u, 4u, f) == Some(3u));
+        assert!(position_between(v, 3u, 3u, f).is_none());
+        assert!(position_between(v, 3u, 4u, f) == Some(3u));
 
-        fail_unless!(position_between(v, 4u, 4u, f).is_none());
+        assert!(position_between(v, 4u, 4u, f).is_none());
     }
 
     #[test]
     fn test_find() {
-        fail_unless!(find(~[], f).is_none());
+        assert!(find(~[], f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(find(v, f) == Some((1, 'b')));
-        fail_unless!(find(v, g).is_none());
+        assert!(find(v, f) == Some((1, 'b')));
+        assert!(find(v, g).is_none());
     }
 
     #[test]
     fn test_find_between() {
-        fail_unless!(find_between(~[], 0u, 0u, f).is_none());
+        assert!(find_between(~[], 0u, 0u, f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(find_between(v, 0u, 0u, f).is_none());
-        fail_unless!(find_between(v, 0u, 1u, f).is_none());
-        fail_unless!(find_between(v, 0u, 2u, f) == Some((1, 'b')));
-        fail_unless!(find_between(v, 0u, 3u, f) == Some((1, 'b')));
-        fail_unless!(find_between(v, 0u, 4u, f) == Some((1, 'b')));
+        assert!(find_between(v, 0u, 0u, f).is_none());
+        assert!(find_between(v, 0u, 1u, f).is_none());
+        assert!(find_between(v, 0u, 2u, f) == Some((1, 'b')));
+        assert!(find_between(v, 0u, 3u, f) == Some((1, 'b')));
+        assert!(find_between(v, 0u, 4u, f) == Some((1, 'b')));
 
-        fail_unless!(find_between(v, 1u, 1u, f).is_none());
-        fail_unless!(find_between(v, 1u, 2u, f) == Some((1, 'b')));
-        fail_unless!(find_between(v, 1u, 3u, f) == Some((1, 'b')));
-        fail_unless!(find_between(v, 1u, 4u, f) == Some((1, 'b')));
+        assert!(find_between(v, 1u, 1u, f).is_none());
+        assert!(find_between(v, 1u, 2u, f) == Some((1, 'b')));
+        assert!(find_between(v, 1u, 3u, f) == Some((1, 'b')));
+        assert!(find_between(v, 1u, 4u, f) == Some((1, 'b')));
 
-        fail_unless!(find_between(v, 2u, 2u, f).is_none());
-        fail_unless!(find_between(v, 2u, 3u, f).is_none());
-        fail_unless!(find_between(v, 2u, 4u, f) == Some((3, 'b')));
+        assert!(find_between(v, 2u, 2u, f).is_none());
+        assert!(find_between(v, 2u, 3u, f).is_none());
+        assert!(find_between(v, 2u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(find_between(v, 3u, 3u, f).is_none());
-        fail_unless!(find_between(v, 3u, 4u, f) == Some((3, 'b')));
+        assert!(find_between(v, 3u, 3u, f).is_none());
+        assert!(find_between(v, 3u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(find_between(v, 4u, 4u, f).is_none());
+        assert!(find_between(v, 4u, 4u, f).is_none());
     }
 
     #[test]
     fn test_rposition() {
-        fail_unless!(find(~[], f).is_none());
+        assert!(find(~[], f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(position(v, f) == Some(1u));
-        fail_unless!(position(v, g).is_none());
+        assert!(position(v, f) == Some(1u));
+        assert!(position(v, g).is_none());
     }
 
     #[test]
     fn test_rposition_between() {
-        fail_unless!(rposition_between(~[], 0u, 0u, f).is_none());
+        assert!(rposition_between(~[], 0u, 0u, f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(rposition_between(v, 0u, 0u, f).is_none());
-        fail_unless!(rposition_between(v, 0u, 1u, f).is_none());
-        fail_unless!(rposition_between(v, 0u, 2u, f) == Some(1u));
-        fail_unless!(rposition_between(v, 0u, 3u, f) == Some(1u));
-        fail_unless!(rposition_between(v, 0u, 4u, f) == Some(3u));
+        assert!(rposition_between(v, 0u, 0u, f).is_none());
+        assert!(rposition_between(v, 0u, 1u, f).is_none());
+        assert!(rposition_between(v, 0u, 2u, f) == Some(1u));
+        assert!(rposition_between(v, 0u, 3u, f) == Some(1u));
+        assert!(rposition_between(v, 0u, 4u, f) == Some(3u));
 
-        fail_unless!(rposition_between(v, 1u, 1u, f).is_none());
-        fail_unless!(rposition_between(v, 1u, 2u, f) == Some(1u));
-        fail_unless!(rposition_between(v, 1u, 3u, f) == Some(1u));
-        fail_unless!(rposition_between(v, 1u, 4u, f) == Some(3u));
+        assert!(rposition_between(v, 1u, 1u, f).is_none());
+        assert!(rposition_between(v, 1u, 2u, f) == Some(1u));
+        assert!(rposition_between(v, 1u, 3u, f) == Some(1u));
+        assert!(rposition_between(v, 1u, 4u, f) == Some(3u));
 
-        fail_unless!(rposition_between(v, 2u, 2u, f).is_none());
-        fail_unless!(rposition_between(v, 2u, 3u, f).is_none());
-        fail_unless!(rposition_between(v, 2u, 4u, f) == Some(3u));
+        assert!(rposition_between(v, 2u, 2u, f).is_none());
+        assert!(rposition_between(v, 2u, 3u, f).is_none());
+        assert!(rposition_between(v, 2u, 4u, f) == Some(3u));
 
-        fail_unless!(rposition_between(v, 3u, 3u, f).is_none());
-        fail_unless!(rposition_between(v, 3u, 4u, f) == Some(3u));
+        assert!(rposition_between(v, 3u, 3u, f).is_none());
+        assert!(rposition_between(v, 3u, 4u, f) == Some(3u));
 
-        fail_unless!(rposition_between(v, 4u, 4u, f).is_none());
+        assert!(rposition_between(v, 4u, 4u, f).is_none());
     }
 
     #[test]
     fn test_rfind() {
-        fail_unless!(rfind(~[], f).is_none());
+        assert!(rfind(~[], f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(rfind(v, f) == Some((3, 'b')));
-        fail_unless!(rfind(v, g).is_none());
+        assert!(rfind(v, f) == Some((3, 'b')));
+        assert!(rfind(v, g).is_none());
     }
 
     #[test]
     fn test_rfind_between() {
-        fail_unless!(rfind_between(~[], 0u, 0u, f).is_none());
+        assert!(rfind_between(~[], 0u, 0u, f).is_none());
 
         fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        fail_unless!(rfind_between(v, 0u, 0u, f).is_none());
-        fail_unless!(rfind_between(v, 0u, 1u, f).is_none());
-        fail_unless!(rfind_between(v, 0u, 2u, f) == Some((1, 'b')));
-        fail_unless!(rfind_between(v, 0u, 3u, f) == Some((1, 'b')));
-        fail_unless!(rfind_between(v, 0u, 4u, f) == Some((3, 'b')));
+        assert!(rfind_between(v, 0u, 0u, f).is_none());
+        assert!(rfind_between(v, 0u, 1u, f).is_none());
+        assert!(rfind_between(v, 0u, 2u, f) == Some((1, 'b')));
+        assert!(rfind_between(v, 0u, 3u, f) == Some((1, 'b')));
+        assert!(rfind_between(v, 0u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(rfind_between(v, 1u, 1u, f).is_none());
-        fail_unless!(rfind_between(v, 1u, 2u, f) == Some((1, 'b')));
-        fail_unless!(rfind_between(v, 1u, 3u, f) == Some((1, 'b')));
-        fail_unless!(rfind_between(v, 1u, 4u, f) == Some((3, 'b')));
+        assert!(rfind_between(v, 1u, 1u, f).is_none());
+        assert!(rfind_between(v, 1u, 2u, f) == Some((1, 'b')));
+        assert!(rfind_between(v, 1u, 3u, f) == Some((1, 'b')));
+        assert!(rfind_between(v, 1u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(rfind_between(v, 2u, 2u, f).is_none());
-        fail_unless!(rfind_between(v, 2u, 3u, f).is_none());
-        fail_unless!(rfind_between(v, 2u, 4u, f) == Some((3, 'b')));
+        assert!(rfind_between(v, 2u, 2u, f).is_none());
+        assert!(rfind_between(v, 2u, 3u, f).is_none());
+        assert!(rfind_between(v, 2u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(rfind_between(v, 3u, 3u, f).is_none());
-        fail_unless!(rfind_between(v, 3u, 4u, f) == Some((3, 'b')));
+        assert!(rfind_between(v, 3u, 3u, f).is_none());
+        assert!(rfind_between(v, 3u, 4u, f) == Some((3, 'b')));
 
-        fail_unless!(rfind_between(v, 4u, 4u, f).is_none());
+        assert!(rfind_between(v, 4u, 4u, f).is_none());
     }
 
     #[test]
     fn reverse_and_reversed() {
         let mut v: ~[int] = ~[10, 20];
-        fail_unless!(v[0] == 10);
-        fail_unless!(v[1] == 20);
+        assert!(v[0] == 10);
+        assert!(v[1] == 20);
         reverse(v);
-        fail_unless!(v[0] == 20);
-        fail_unless!(v[1] == 10);
+        assert!(v[0] == 20);
+        assert!(v[1] == 10);
         let v2 = reversed::<int>(~[10, 20]);
-        fail_unless!(v2[0] == 20);
-        fail_unless!(v2[1] == 10);
+        assert!(v2[0] == 20);
+        assert!(v2[1] == 10);
         v[0] = 30;
-        fail_unless!(v2[0] == 20);
+        assert!(v2[0] == 20);
         // Make sure they work with 0-length vectors too.
 
         let v4 = reversed::<int>(~[]);
-        fail_unless!(v4 == ~[]);
+        assert!(v4 == ~[]);
         let mut v3: ~[int] = ~[];
         reverse::<int>(v3);
     }
@@ -3467,30 +3467,30 @@ mod tests {
     #[test]
     fn reversed_mut() {
         let mut v2 = reversed::<int>(~[10, 20]);
-        fail_unless!(v2[0] == 20);
-        fail_unless!(v2[1] == 10);
+        assert!(v2[0] == 20);
+        assert!(v2[1] == 10);
     }
 
     #[test]
     fn test_split() {
         fn f(x: &int) -> bool { *x == 3 }
 
-        fail_unless!(split(~[], f) == ~[]);
-        fail_unless!(split(~[1, 2], f) == ~[~[1, 2]]);
-        fail_unless!(split(~[3, 1, 2], f) == ~[~[], ~[1, 2]]);
-        fail_unless!(split(~[1, 2, 3], f) == ~[~[1, 2], ~[]]);
-        fail_unless!(split(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]);
+        assert!(split(~[], f) == ~[]);
+        assert!(split(~[1, 2], f) == ~[~[1, 2]]);
+        assert!(split(~[3, 1, 2], f) == ~[~[], ~[1, 2]]);
+        assert!(split(~[1, 2, 3], f) == ~[~[1, 2], ~[]]);
+        assert!(split(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]);
     }
 
     #[test]
     fn test_splitn() {
         fn f(x: &int) -> bool { *x == 3 }
 
-        fail_unless!(splitn(~[], 1u, f) == ~[]);
-        fail_unless!(splitn(~[1, 2], 1u, f) == ~[~[1, 2]]);
-        fail_unless!(splitn(~[3, 1, 2], 1u, f) == ~[~[], ~[1, 2]]);
-        fail_unless!(splitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]);
-        fail_unless!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
+        assert!(splitn(~[], 1u, f) == ~[]);
+        assert!(splitn(~[1, 2], 1u, f) == ~[~[1, 2]]);
+        assert!(splitn(~[3, 1, 2], 1u, f) == ~[~[], ~[1, 2]]);
+        assert!(splitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]);
+        assert!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
                       ~[~[1, 2], ~[4, 3, 5]]);
     }
 
@@ -3498,10 +3498,10 @@ mod tests {
     fn test_rsplit() {
         fn f(x: &int) -> bool { *x == 3 }
 
-        fail_unless!(rsplit(~[], f) == ~[]);
-        fail_unless!(rsplit(~[1, 2], f) == ~[~[1, 2]]);
-        fail_unless!(rsplit(~[1, 2, 3], f) == ~[~[1, 2], ~[]]);
-        fail_unless!(rsplit(~[1, 2, 3, 4, 3, 5], f) ==
+        assert!(rsplit(~[], f) == ~[]);
+        assert!(rsplit(~[1, 2], f) == ~[~[1, 2]]);
+        assert!(rsplit(~[1, 2, 3], f) == ~[~[1, 2], ~[]]);
+        assert!(rsplit(~[1, 2, 3, 4, 3, 5], f) ==
             ~[~[1, 2], ~[4], ~[5]]);
     }
 
@@ -3509,57 +3509,57 @@ mod tests {
     fn test_rsplitn() {
         fn f(x: &int) -> bool { *x == 3 }
 
-        fail_unless!(rsplitn(~[], 1u, f) == ~[]);
-        fail_unless!(rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]);
-        fail_unless!(rsplitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]);
-        fail_unless!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
+        assert!(rsplitn(~[], 1u, f) == ~[]);
+        assert!(rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]);
+        assert!(rsplitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]);
+        assert!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) ==
                        ~[~[1, 2, 3, 4], ~[5]]);
     }
 
     #[test]
     fn test_partition() {
         // FIXME (#4355 maybe): using v.partition here crashes
-        fail_unless!(partition(~[], |x: &int| *x < 3) == (~[], ~[]));
-        fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 4) ==
+        assert!(partition(~[], |x: &int| *x < 3) == (~[], ~[]));
+        assert!(partition(~[1, 2, 3], |x: &int| *x < 4) ==
             (~[1, 2, 3], ~[]));
-        fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 2) ==
+        assert!(partition(~[1, 2, 3], |x: &int| *x < 2) ==
             (~[1], ~[2, 3]));
-        fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 0) ==
+        assert!(partition(~[1, 2, 3], |x: &int| *x < 0) ==
             (~[], ~[1, 2, 3]));
     }
 
     #[test]
     fn test_partitioned() {
-        fail_unless!((~[]).partitioned(|x: &int| *x < 3) == (~[], ~[]));
-        fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) ==
+        assert!((~[]).partitioned(|x: &int| *x < 3) == (~[], ~[]));
+        assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) ==
                      (~[1, 2, 3], ~[]));
-        fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) ==
+        assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) ==
                      (~[1], ~[2, 3]));
-        fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) ==
+        assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) ==
                      (~[], ~[1, 2, 3]));
     }
 
     #[test]
     fn test_concat() {
-        fail_unless!(concat(~[~[1], ~[2,3]]) == ~[1, 2, 3]);
+        assert!(concat(~[~[1], ~[2,3]]) == ~[1, 2, 3]);
     }
 
     #[test]
     fn test_connect() {
-        fail_unless!(connect(~[], &0) == ~[]);
-        fail_unless!(connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]);
-        fail_unless!(connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]);
+        assert!(connect(~[], &0) == ~[]);
+        assert!(connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]);
+        assert!(connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]);
     }
 
     #[test]
     fn test_windowed () {
-        fail_unless!(~[~[1u,2u,3u],~[2u,3u,4u],~[3u,4u,5u],~[4u,5u,6u]]
+        assert!(~[~[1u,2u,3u],~[2u,3u,4u],~[3u,4u,5u],~[4u,5u,6u]]
                      == windowed (3u, ~[1u,2u,3u,4u,5u,6u]));
 
-        fail_unless!(~[~[1u,2u,3u,4u],~[2u,3u,4u,5u],~[3u,4u,5u,6u]]
+        assert!(~[~[1u,2u,3u,4u],~[2u,3u,4u,5u],~[3u,4u,5u,6u]]
                      == windowed (4u, ~[1u,2u,3u,4u,5u,6u]));
 
-        fail_unless!(~[] == windowed (7u, ~[1u,2u,3u,4u,5u,6u]));
+        assert!(~[] == windowed (7u, ~[1u,2u,3u,4u,5u,6u]));
     }
 
     #[test]
@@ -3573,26 +3573,26 @@ mod tests {
     fn test_unshift() {
         let mut x = ~[1, 2, 3];
         x.unshift(0);
-        fail_unless!(x == ~[0, 1, 2, 3]);
+        assert!(x == ~[0, 1, 2, 3]);
     }
 
     #[test]
     fn test_insert() {
         let mut a = ~[1, 2, 4];
         a.insert(2, 3);
-        fail_unless!(a == ~[1, 2, 3, 4]);
+        assert!(a == ~[1, 2, 3, 4]);
 
         let mut a = ~[1, 2, 3];
         a.insert(0, 0);
-        fail_unless!(a == ~[0, 1, 2, 3]);
+        assert!(a == ~[0, 1, 2, 3]);
 
         let mut a = ~[1, 2, 3];
         a.insert(3, 4);
-        fail_unless!(a == ~[1, 2, 3, 4]);
+        assert!(a == ~[1, 2, 3, 4]);
 
         let mut a = ~[];
         a.insert(0, 1);
-        fail_unless!(a == ~[1]);
+        assert!(a == ~[1]);
     }
 
     #[test]
@@ -3607,15 +3607,15 @@ mod tests {
     fn test_remove() {
         let mut a = ~[1, 2, 3, 4];
         a.remove(2);
-        fail_unless!(a == ~[1, 2, 4]);
+        assert!(a == ~[1, 2, 4]);
 
         let mut a = ~[1, 2, 3];
         a.remove(0);
-        fail_unless!(a == ~[2, 3]);
+        assert!(a == ~[2, 3]);
 
         let mut a = ~[1];
         a.remove(0);
-        fail_unless!(a == ~[]);
+        assert!(a == ~[]);
     }
 
     #[test]
@@ -3630,19 +3630,19 @@ mod tests {
     fn test_capacity() {
         let mut v = ~[0u64];
         reserve(&mut v, 10u);
-        fail_unless!(capacity(&v) == 10u);
+        assert!(capacity(&v) == 10u);
         let mut v = ~[0u32];
         reserve(&mut v, 10u);
-        fail_unless!(capacity(&v) == 10u);
+        assert!(capacity(&v) == 10u);
     }
 
     #[test]
     fn test_slice_2() {
         let v = ~[1, 2, 3, 4, 5];
         let v = v.slice(1u, 3u);
-        fail_unless!(v.len() == 2u);
-        fail_unless!(v[0] == 2);
-        fail_unless!(v[1] == 3);
+        assert!(v.len() == 2u);
+        assert!(v[0] == 2);
+        assert!(v[1] == 3);
     }
 
 
diff --git a/src/libfuzzer/ast_match.rs b/src/libfuzzer/ast_match.rs
index eedd3bebedf..806a7aedd31 100644
--- a/src/libfuzzer/ast_match.rs
+++ b/src/libfuzzer/ast_match.rs
@@ -29,13 +29,13 @@ fn builtin_equal<T>(&&a: T, &&b: T) -> bool { return a == b; }
 fn builtin_equal_int(&&a: int, &&b: int) -> bool { return a == b; }
 
 fn main() {
-    fail_unless!((builtin_equal(5, 5)));
-    fail_unless!((!builtin_equal(5, 4)));
-    fail_unless!((!vec_equal(~[5, 5], ~[5], bind builtin_equal(_, _))));
-    fail_unless!((!vec_equal(~[5, 5], ~[5], builtin_equal_int)));
-    fail_unless!((!vec_equal(~[5, 5], ~[5, 4], builtin_equal_int)));
-    fail_unless!((!vec_equal(~[5, 5], ~[4, 5], builtin_equal_int)));
-    fail_unless!((vec_equal(~[5, 5], ~[5, 5], builtin_equal_int)));
+    assert!((builtin_equal(5, 5)));
+    assert!((!builtin_equal(5, 4)));
+    assert!((!vec_equal(~[5, 5], ~[5], bind builtin_equal(_, _))));
+    assert!((!vec_equal(~[5, 5], ~[5], builtin_equal_int)));
+    assert!((!vec_equal(~[5, 5], ~[5, 4], builtin_equal_int)));
+    assert!((!vec_equal(~[5, 5], ~[4, 5], builtin_equal_int)));
+    assert!((vec_equal(~[5, 5], ~[5, 5], builtin_equal_int)));
 
     error!("Pass");
 }
diff --git a/src/libfuzzer/cycles.rs b/src/libfuzzer/cycles.rs
index dcf9a493c55..c18d1f43b56 100644
--- a/src/libfuzzer/cycles.rs
+++ b/src/libfuzzer/cycles.rs
@@ -14,12 +14,12 @@ use uint::range;
 
 // random uint less than n
 fn under(r : rand::rng, n : uint) -> uint {
-    fail_unless!(n != 0u); r.next() as uint % n
+    assert!(n != 0u); r.next() as uint % n
 }
 
 // random choice from a vec
 fn choice<T:copy>(r : rand::rng, v : ~[const T]) -> T {
-    fail_unless!(vec::len(v) != 0u); v[under(r, vec::len(v))]
+    assert!(vec::len(v) != 0u); v[under(r, vec::len(v))]
 }
 
 // k in n chance of being true
diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc
index 1c85536d195..aad48bbb8e6 100644
--- a/src/libfuzzer/fuzzer.rc
+++ b/src/libfuzzer/fuzzer.rc
@@ -377,13 +377,13 @@ pub fn check_whole_compiler(code: ~str, suggested_filename_prefix: &Path,
 
 pub fn removeIfExists(filename: &Path) {
     // So sketchy!
-    fail_unless!(!contains(filename.to_str(), ~" "));
+    assert!(!contains(filename.to_str(), ~" "));
     run::program_output(~"bash", ~[~"-c", ~"rm " + filename.to_str()]);
 }
 
 pub fn removeDirIfExists(filename: &Path) {
     // So sketchy!
-    fail_unless!(!contains(filename.to_str(), ~" "));
+    assert!(!contains(filename.to_str(), ~" "));
     run::program_output(~"bash", ~[~"-c", ~"rm -r " + filename.to_str()]);
 }
 
diff --git a/src/libfuzzer/rand_util.rs b/src/libfuzzer/rand_util.rs
index 25b1669d86f..2422c146e24 100644
--- a/src/libfuzzer/rand_util.rs
+++ b/src/libfuzzer/rand_util.rs
@@ -13,12 +13,12 @@ use std::rand;
 
 // random uint less than n
 fn under(r : rand::rng, n : uint) -> uint {
-    fail_unless!(n != 0u); r.next() as uint % n
+    assert!(n != 0u); r.next() as uint % n
 }
 
 // random choice from a vec
 fn choice<T:copy>(r : rand::rng, v : ~[T]) -> T {
-    fail_unless!(vec::len(v) != 0u); v[under(r, vec::len(v))]
+    assert!(vec::len(v) != 0u); v[under(r, vec::len(v))]
 }
 
 // 1 in n chance of being true
@@ -49,12 +49,12 @@ fn shuffled<T:copy>(r : rand::rng, v : ~[T]) -> ~[T] {
 // * weighted_vec is O(total weight) space
 type weighted<T> = { weight: uint, item: T };
 fn weighted_choice<T:copy>(r : rand::rng, v : ~[weighted<T>]) -> T {
-    fail_unless!(vec::len(v) != 0u);
+    assert!(vec::len(v) != 0u);
     let total = 0u;
     for {weight: weight, item: _} in v {
         total += weight;
     }
-    fail_unless!(total >= 0u);
+    assert!(total >= 0u);
     let chosen = under(r, total);
     let so_far = 0u;
     for {weight: weight, item: item} in v {
diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs
index 1137b2a2c08..6c485df84b4 100644
--- a/src/librustc/back/rpath.rs
+++ b/src/librustc/back/rpath.rs
@@ -118,7 +118,7 @@ pub fn get_rpath_relative_to_output(os: session::os,
                                  -> Path {
     use core::os;
 
-    fail_unless!(not_win32(os));
+    assert!(not_win32(os));
 
     // Mac doesn't appear to support $ORIGIN
     let prefix = match os {
@@ -134,8 +134,8 @@ pub fn get_rpath_relative_to_output(os: session::os,
 
 // Find the relative path from one file to another
 pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
-    fail_unless!(abs1.is_absolute);
-    fail_unless!(abs2.is_absolute);
+    assert!(abs1.is_absolute);
+    assert!(abs2.is_absolute);
     let abs1 = abs1.normalize();
     let abs2 = abs2.normalize();
     debug!("finding relative path from %s to %s",
@@ -144,8 +144,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     let split2: &[~str] = abs2.components;
     let len1 = vec::len(split1);
     let len2 = vec::len(split2);
-    fail_unless!(len1 > 0);
-    fail_unless!(len2 > 0);
+    assert!(len1 > 0);
+    assert!(len2 > 0);
 
     let max_common_path = uint::min(len1, len2) - 1;
     let mut start_idx = 0;
@@ -215,7 +215,7 @@ mod test {
     pub fn test_rpaths_to_flags() {
         let flags = rpaths_to_flags(~[Path("path1"),
                                       Path("path2")]);
-        fail_unless!(flags == ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]);
+        assert!(flags == ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]);
     }
 
     #[test]
@@ -226,13 +226,13 @@ mod test {
         debug!("test_prefix_path: %s vs. %s",
                res.to_str(),
                d.to_str());
-        fail_unless!(str::ends_with(res.to_str(), d.to_str()));
+        assert!(str::ends_with(res.to_str(), d.to_str()));
     }
 
     #[test]
     pub fn test_prefix_rpath_abs() {
         let res = get_install_prefix_rpath("triple");
-        fail_unless!(res.is_absolute);
+        assert!(res.is_absolute);
     }
 
     #[test]
@@ -240,7 +240,7 @@ mod test {
         let res = minimize_rpaths([Path("rpath1"),
                                    Path("rpath2"),
                                    Path("rpath1")]);
-        fail_unless!(res == ~[Path("rpath1"), Path("rpath2")]);
+        assert!(res == ~[Path("rpath1"), Path("rpath2")]);
     }
 
     #[test]
@@ -249,7 +249,7 @@ mod test {
                                     Path("1a"), Path("4a"),Path("1a"),
                                     Path("2"), Path("3"), Path("4a"),
                                     Path("3")]);
-        fail_unless!(res == ~[Path("1a"), Path("2"), Path("4a"), Path("3")]);
+        assert!(res == ~[Path("1a"), Path("2"), Path("4a"), Path("3")]);
     }
 
     #[test]
@@ -257,7 +257,7 @@ mod test {
         let p1 = Path("/usr/bin/rustc");
         let p2 = Path("/usr/lib/mylib");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("../lib"));
+        assert!(res == Path("../lib"));
     }
 
     #[test]
@@ -265,7 +265,7 @@ mod test {
         let p1 = Path("/usr/bin/rustc");
         let p2 = Path("/usr/bin/../lib/mylib");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("../lib"));
+        assert!(res == Path("../lib"));
     }
 
     #[test]
@@ -273,7 +273,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/rustc");
         let p2 = Path("/usr/lib/whatever/mylib");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("../../lib/whatever"));
+        assert!(res == Path("../../lib/whatever"));
     }
 
     #[test]
@@ -281,7 +281,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/../rustc");
         let p2 = Path("/usr/lib/whatever/mylib");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("../lib/whatever"));
+        assert!(res == Path("../lib/whatever"));
     }
 
     #[test]
@@ -289,7 +289,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/../rustc");
         let p2 = Path("/usr/lib/whatever/../mylib");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("../lib"));
+        assert!(res == Path("../lib"));
     }
 
     #[test]
@@ -297,7 +297,7 @@ mod test {
         let p1 = Path("/1");
         let p2 = Path("/2/3");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path("2"));
+        assert!(res == Path("2"));
     }
 
     #[test]
@@ -305,7 +305,7 @@ mod test {
         let p1 = Path("/1/2");
         let p2 = Path("/3");
         let res = get_relative_to(&p1, &p2);
-        fail_unless!(res == Path(".."));
+        assert!(res == Path(".."));
     }
 
     #[test]
@@ -318,7 +318,7 @@ mod test {
         debug!("test_relative_tu8: %s vs. %s",
                res.to_str(),
                Path(".").to_str());
-        fail_unless!(res == Path("."));
+        assert!(res == Path("."));
     }
 
     #[test]
@@ -328,7 +328,7 @@ mod test {
       let o = session::os_linux;
       let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
-      fail_unless!(res.to_str() == ~"$ORIGIN/../lib");
+      assert!(res.to_str() == ~"$ORIGIN/../lib");
     }
 
     #[test]
@@ -337,7 +337,7 @@ mod test {
         let o = session::os_freebsd;
         let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
-        fail_unless!(res.to_str() == ~"$ORIGIN/../lib");
+        assert!(res.to_str() == ~"$ORIGIN/../lib");
     }
 
     #[test]
@@ -348,7 +348,7 @@ mod test {
         let res = get_rpath_relative_to_output(o,
                                                &Path("bin/rustc"),
                                                &Path("lib/libstd.so"));
-        fail_unless!(res.to_str() == ~"@executable_path/../lib");
+        assert!(res.to_str() == ~"@executable_path/../lib");
     }
 
     #[test]
@@ -358,6 +358,6 @@ mod test {
                res.to_str(),
                os::make_absolute(&Path("lib")).to_str());
 
-        fail_unless!(res == os::make_absolute(&Path("lib")));
+        assert!(res == os::make_absolute(&Path("lib")));
     }
 }
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 3aa0959317a..93bc64eafa3 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -899,7 +899,7 @@ pub mod test {
             ~"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
         let cfg = build_configuration(sess, ~"whatever", str_input(~""));
-        fail_unless!((attr::contains_name(cfg, ~"test")));
+        assert!((attr::contains_name(cfg, ~"test")));
     }
 
     // When the user supplies --test and --cfg test, don't implicitly add
@@ -919,7 +919,7 @@ pub mod test {
         let sess = build_session(sessopts, diagnostic::emit);
         let cfg = build_configuration(sess, ~"whatever", str_input(~""));
         let test_items = attr::find_meta_items_by_name(cfg, ~"test");
-        fail_unless!((vec::len(test_items) == 1u));
+        assert!((vec::len(test_items) == 1u));
     }
 }
 
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
index 28ebc3f424e..d1f95dbeacc 100644
--- a/src/librustc/driver/session.rs
+++ b/src/librustc/driver/session.rs
@@ -378,43 +378,43 @@ pub mod test {
     #[test]
     pub fn bin_crate_type_attr_results_in_bin_output() {
         let crate = make_crate(true, false);
-        fail_unless!(!building_library(unknown_crate, crate, false));
+        assert!(!building_library(unknown_crate, crate, false));
     }
 
     #[test]
     pub fn lib_crate_type_attr_results_in_lib_output() {
         let crate = make_crate(false, true);
-        fail_unless!(building_library(unknown_crate, crate, false));
+        assert!(building_library(unknown_crate, crate, false));
     }
 
     #[test]
     pub fn bin_option_overrides_lib_crate_type() {
         let crate = make_crate(false, true);
-        fail_unless!(!building_library(bin_crate, crate, false));
+        assert!(!building_library(bin_crate, crate, false));
     }
 
     #[test]
     pub fn lib_option_overrides_bin_crate_type() {
         let crate = make_crate(true, false);
-        fail_unless!(building_library(lib_crate, crate, false));
+        assert!(building_library(lib_crate, crate, false));
     }
 
     #[test]
     pub fn bin_crate_type_is_default() {
         let crate = make_crate(false, false);
-        fail_unless!(!building_library(unknown_crate, crate, false));
+        assert!(!building_library(unknown_crate, crate, false));
     }
 
     #[test]
     pub fn test_option_overrides_lib_crate_type() {
         let crate = make_crate(false, true);
-        fail_unless!(!building_library(unknown_crate, crate, true));
+        assert!(!building_library(unknown_crate, crate, true));
     }
 
     #[test]
     pub fn test_option_does_not_override_requested_lib_type() {
         let crate = make_crate(false, false);
-        fail_unless!(building_library(lib_crate, crate, true));
+        assert!(building_library(lib_crate, crate, true));
     }
 }
 
diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs
index fa79217619d..34678d1803c 100644
--- a/src/librustc/lib/llvm.rs
+++ b/src/librustc/lib/llvm.rs
@@ -1472,8 +1472,8 @@ pub struct TypeNames {
 }
 
 pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) {
-    fail_unless!(tn.type_names.insert(t, s));
-    fail_unless!(tn.named_types.insert(s, t));
+    assert!(tn.type_names.insert(t, s));
+    assert!(tn.named_types.insert(s, t));
 }
 
 pub fn type_has_name(tn: @TypeNames, t: TypeRef) -> Option<@str> {
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 3a6e567cdbc..b8bf27d7627 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -97,7 +97,7 @@ fn warn_if_multiple_versions(e: @mut Env,
                 }
             }));
 
-        fail_unless!(!matches.is_empty());
+        assert!(!matches.is_empty());
 
         if matches.len() != 1u {
             diag.handler().warn(
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index 51cc964e460..c836538e1e6 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -102,7 +102,7 @@ pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] {
 }
 
 pub fn add_used_library(cstore: &mut CStore, lib: @~str) -> bool {
-    fail_unless!(*lib != ~"");
+    assert!(*lib != ~"");
 
     if cstore.used_libraries.contains(&*lib) { return false; }
     cstore.used_libraries.push(/*bad*/ copy *lib);
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 29161a6db64..dcea22b09d6 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -1003,7 +1003,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
             let meta_items = get_meta_items(attr_doc);
             // Currently it's only possible to have a single meta item on
             // an attribute
-            fail_unless!((vec::len(meta_items) == 1u));
+            assert!((vec::len(meta_items) == 1u));
             let meta_item = meta_items[0];
             attrs.push(
                 codemap::spanned {
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 8c90ec3f7f3..af9ab7d94f1 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -1082,7 +1082,7 @@ fn encode_index<T>(ebml_w: writer::Encoder, buckets: ~[@~[entry<T>]],
         ebml_w.start_tag(tag_index_buckets_bucket);
         for vec::each(**bucket) |elt| {
             ebml_w.start_tag(tag_index_buckets_bucket_elt);
-            fail_unless!(elt.pos < 0xffff_ffff);
+            assert!(elt.pos < 0xffff_ffff);
             writer.write_be_u32(elt.pos as u32);
             write_fn(writer, elt.val);
             ebml_w.end_tag();
@@ -1092,7 +1092,7 @@ fn encode_index<T>(ebml_w: writer::Encoder, buckets: ~[@~[entry<T>]],
     ebml_w.end_tag();
     ebml_w.start_tag(tag_index_table);
     for bucket_locs.each |pos| {
-        fail_unless!(*pos < 0xffff_ffff);
+        assert!(*pos < 0xffff_ffff);
         writer.write_be_u32(*pos as u32);
     }
     ebml_w.end_tag();
@@ -1102,7 +1102,7 @@ fn encode_index<T>(ebml_w: writer::Encoder, buckets: ~[@~[entry<T>]],
 fn write_str(writer: @io::Writer, &&s: ~str) { writer.write_str(s); }
 
 fn write_int(writer: @io::Writer, &&n: int) {
-    fail_unless!(n < 0x7fff_ffff);
+    assert!(n < 0x7fff_ffff);
     writer.write_be_u32(n as u32);
 }
 
@@ -1163,8 +1163,8 @@ fn synthesize_crate_attrs(ecx: @EncodeContext,
     fn synthesize_link_attr(ecx: @EncodeContext, +items: ~[@meta_item]) ->
        attribute {
 
-        fail_unless!(!ecx.link_meta.name.is_empty());
-        fail_unless!(!ecx.link_meta.vers.is_empty());
+        assert!(!ecx.link_meta.name.is_empty());
+        assert!(!ecx.link_meta.vers.is_empty());
 
         let name_item =
             attr::mk_name_value_item_str(@~"name",
@@ -1230,7 +1230,7 @@ fn encode_crate_deps(ecx: @EncodeContext,
         // Sanity-check the crate numbers
         let mut expected_cnum = 1;
         for deps.each |n| {
-            fail_unless!((n.cnum == expected_cnum));
+            assert!((n.cnum == expected_cnum));
             expected_cnum += 1;
         }
 
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index 823d8e58d11..e233bf78d78 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -142,12 +142,12 @@ fn parse_sigil(st: @mut PState) -> ast::Sigil {
 }
 
 fn parse_vstore(st: @mut PState) -> ty::vstore {
-    fail_unless!(next(st) == '/');
+    assert!(next(st) == '/');
 
     let c = peek(st);
     if '0' <= c && c <= '9' {
         let n = parse_int(st) as uint;
-        fail_unless!(next(st) == '|');
+        assert!(next(st) == '|');
         return ty::vstore_fixed(n);
     }
 
@@ -174,7 +174,7 @@ fn parse_substs(st: @mut PState, conv: conv_did) -> ty::substs {
 
     let self_ty = parse_opt(st, || parse_ty(st, conv) );
 
-    fail_unless!(next(st) == '[');
+    assert!(next(st) == '[');
     let mut params: ~[ty::t] = ~[];
     while peek(st) != ']' { params.push(parse_ty(st, conv)); }
     st.pos = st.pos + 1u;
@@ -191,13 +191,13 @@ fn parse_bound_region(st: @mut PState) -> ty::bound_region {
       's' => ty::br_self,
       'a' => {
         let id = parse_int(st) as uint;
-        fail_unless!(next(st) == '|');
+        assert!(next(st) == '|');
         ty::br_anon(id)
       }
       '[' => ty::br_named(st.tcx.sess.ident_of(parse_str(st, ']'))),
       'c' => {
         let id = parse_int(st);
-        fail_unless!(next(st) == '|');
+        assert!(next(st) == '|');
         ty::br_cap_avoid(id, @parse_bound_region(st))
       },
       _ => fail!(~"parse_bound_region: bad input")
@@ -210,16 +210,16 @@ fn parse_region(st: @mut PState) -> ty::Region {
         ty::re_bound(parse_bound_region(st))
       }
       'f' => {
-        fail_unless!(next(st) == '[');
+        assert!(next(st) == '[');
         let id = parse_int(st);
-        fail_unless!(next(st) == '|');
+        assert!(next(st) == '|');
         let br = parse_bound_region(st);
-        fail_unless!(next(st) == ']');
+        assert!(next(st) == ']');
         ty::re_free(id, br)
       }
       's' => {
         let id = parse_int(st);
-        fail_unless!(next(st) == '|');
+        assert!(next(st) == '|');
         ty::re_scope(id)
       }
       't' => {
@@ -271,18 +271,18 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       'c' => return ty::mk_char(st.tcx),
       't' => {
-        fail_unless!((next(st) == '['));
+        assert!((next(st) == '['));
         let def = parse_def(st, NominalType, conv);
         let substs = parse_substs(st, conv);
-        fail_unless!(next(st) == ']');
+        assert!(next(st) == ']');
         return ty::mk_enum(st.tcx, def, substs);
       }
       'x' => {
-        fail_unless!(next(st) == '[');
+        assert!(next(st) == '[');
         let def = parse_def(st, NominalType, conv);
         let substs = parse_substs(st, conv);
         let store = parse_trait_store(st);
-        fail_unless!(next(st) == ']');
+        assert!(next(st) == ']');
         return ty::mk_trait(st.tcx, def, substs, store);
       }
       'p' => {
@@ -313,7 +313,7 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
         return ty::mk_estr(st.tcx, v);
       }
       'T' => {
-        fail_unless!((next(st) == '['));
+        assert!((next(st) == '['));
         let mut params = ~[];
         while peek(st) != ']' { params.push(parse_ty(st, conv)); }
         st.pos = st.pos + 1u;
@@ -332,9 +332,9 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       '#' => {
         let pos = parse_hex(st);
-        fail_unless!((next(st) == ':'));
+        assert!((next(st) == ':'));
         let len = parse_hex(st);
-        fail_unless!((next(st) == '#'));
+        assert!((next(st) == '#'));
         let key = ty::creader_cache_key {cnum: st.crate,
                                          pos: pos,
                                          len: len };
@@ -355,10 +355,10 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       'B' => ty::mk_opaque_box(st.tcx),
       'a' => {
-          fail_unless!((next(st) == '['));
+          assert!((next(st) == '['));
           let did = parse_def(st, NominalType, conv);
           let substs = parse_substs(st, conv);
-          fail_unless!((next(st) == ']'));
+          assert!((next(st) == ']'));
           return ty::mk_struct(st.tcx, did, substs);
       }
       c => { error!("unexpected char in type string: %c", c); fail!();}
@@ -472,7 +472,7 @@ fn parse_bare_fn_ty(st: @mut PState, conv: conv_did) -> ty::BareFnTy {
 }
 
 fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
-    fail_unless!((next(st) == '['));
+    assert!((next(st) == '['));
     let mut inputs: ~[ty::arg] = ~[];
     while peek(st) != ']' {
         let mode = parse_mode(st);
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 7b7cf01d2b5..8dcfaf2eb35 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -175,7 +175,7 @@ pub impl ExtendedDecodeContext {
          */
 
         // from_id_range should be non-empty
-        fail_unless!(!ast_util::empty(self.from_id_range));
+        assert!(!ast_util::empty(self.from_id_range));
         (id - self.from_id_range.min + self.to_id_range.min)
     }
     fn tr_def_id(&self, did: ast::def_id) -> ast::def_id {
@@ -212,7 +212,7 @@ pub impl ExtendedDecodeContext {
          * refer to the current crate and to the new, inlined node-id.
          */
 
-        fail_unless!(did.crate == ast::local_crate);
+        assert!(did.crate == ast::local_crate);
         ast::def_id { crate: ast::local_crate, node: self.tr_id(did.node) }
     }
     fn tr_span(&self, _span: span) -> span {
@@ -1232,7 +1232,7 @@ fn roundtrip(in_item: Option<@ast::item>) {
     debug!("expected string: %s", exp_str);
     debug!("actual string  : %s", out_str);
 
-    fail_unless!(exp_str == out_str);
+    assert!(exp_str == out_str);
 }
 
 #[test]
@@ -1279,7 +1279,7 @@ fn test_simplification() {
     ).get());
     match (item_out, item_exp) {
       (ast::ii_item(item_out), ast::ii_item(item_exp)) => {
-        fail_unless!(pprust::item_to_str(item_out,
+        assert!(pprust::item_to_str(item_out,
                                          ext_cx.parse_sess().interner)
                      == pprust::item_to_str(item_exp,
                                             ext_cx.parse_sess().interner));
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 9fb95fd489e..fdea403cc2a 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -132,7 +132,7 @@ pub fn raw_pat(p: @pat) -> @pat {
 }
 
 pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) {
-    fail_unless!((!pats.is_empty()));
+    assert!((!pats.is_empty()));
     let ext = match is_useful(cx, &pats.map(|p| ~[*p]), ~[wild()]) {
         not_useful => {
             // This is good, wildcard pattern isn't reachable
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 398b17a65b3..024d862461d 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -882,7 +882,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) {
 fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
     fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool {
         let ident = cx.sess.str_of(ident);
-        fail_unless!(!ident.is_empty());
+        assert!(!ident.is_empty());
         let ident = ident_without_trailing_underscores(*ident);
         let ident = ident_without_leading_underscores(ident);
         char::is_uppercase(str::char_at(ident, 0)) &&
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 35f2679a3c6..e9e226d36d1 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -733,7 +733,7 @@ pub impl Liveness {
     fn live_on_entry(&self, ln: LiveNode, var: Variable)
         -> Option<LiveNodeKind> {
 
-        fail_unless!(ln.is_valid());
+        assert!(ln.is_valid());
         let reader = self.users[self.idx(ln, var)].reader;
         if reader.is_valid() {Some(self.ir.lnk(reader))} else {None}
     }
@@ -748,14 +748,14 @@ pub impl Liveness {
     }
 
     fn used_on_entry(&self, ln: LiveNode, var: Variable) -> bool {
-        fail_unless!(ln.is_valid());
+        assert!(ln.is_valid());
         self.users[self.idx(ln, var)].used
     }
 
     fn assigned_on_entry(&self, ln: LiveNode, var: Variable)
         -> Option<LiveNodeKind> {
 
-        fail_unless!(ln.is_valid());
+        assert!(ln.is_valid());
         let writer = self.users[self.idx(ln, var)].writer;
         if writer.is_valid() {Some(self.ir.lnk(writer))} else {None}
     }
@@ -1465,9 +1465,9 @@ pub impl Liveness {
         // repeat until fixed point is reached:
         while self.merge_from_succ(ln, body_ln, first_merge) {
             first_merge = false;
-            fail_unless!(cond_ln == self.propagate_through_opt_expr(cond,
+            assert!(cond_ln == self.propagate_through_opt_expr(cond,
                                                                     ln));
-            fail_unless!(body_ln == self.with_loop_nodes(expr.id, succ, ln,
+            assert!(body_ln == self.with_loop_nodes(expr.id, succ, ln,
             || {
                 self.propagate_through_block(body, cond_ln)
             }));
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index f49a37d7301..f6025548d71 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -463,7 +463,7 @@ pub impl DetermineRpCtxt {
     /// variance `variance`.  If `id` was already parameterized, then
     /// the new variance is joined with the old variance.
     fn add_rp(&mut self, id: ast::node_id, variance: region_variance) {
-        fail_unless!(id != 0);
+        assert!(id != 0);
         let old_variance = self.region_paramd_items.find(&id).
                                 map_consume(|x| *x);
         let joined_variance = match old_variance {
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 8371a6785d1..8503fa2e2cd 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -1407,7 +1407,7 @@ pub impl Resolver {
                     match view_path.node {
                         view_path_simple(_, full_path, _, _) => {
                             let path_len = full_path.idents.len();
-                            fail_unless!(path_len != 0);
+                            assert!(path_len != 0);
 
                             for full_path.idents.eachi |i, ident| {
                                 if i != path_len - 1 {
@@ -2083,7 +2083,7 @@ pub impl Resolver {
         // Decrement the count of unresolved imports.
         match resolution_result {
             Success(()) => {
-                fail_unless!(self.unresolved_imports >= 1);
+                assert!(self.unresolved_imports >= 1);
                 self.unresolved_imports -= 1;
             }
             _ => {
@@ -2099,7 +2099,7 @@ pub impl Resolver {
         if !resolution_result.indeterminate() {
             match *import_directive.subclass {
                 GlobImport => {
-                    fail_unless!(module_.glob_count >= 1);
+                    assert!(module_.glob_count >= 1);
                     module_.glob_count -= 1;
                 }
                 SingleImport(*) => {
@@ -2266,7 +2266,7 @@ pub impl Resolver {
         }
 
         // We've successfully resolved the import. Write the results in.
-        fail_unless!(module_.import_resolutions.contains_key(&target));
+        assert!(module_.import_resolutions.contains_key(&target));
         let import_resolution = module_.import_resolutions.get(&target);
 
         match value_result {
@@ -2329,7 +2329,7 @@ pub impl Resolver {
             }
         }
 
-        fail_unless!(import_resolution.outstanding_references >= 1);
+        assert!(import_resolution.outstanding_references >= 1);
         import_resolution.outstanding_references -= 1;
 
         debug!("(resolving single import) successfully resolved import");
@@ -2359,7 +2359,7 @@ pub impl Resolver {
             return Indeterminate;
         }
 
-        fail_unless!(containing_module.glob_count == 0);
+        assert!(containing_module.glob_count == 0);
 
         // Add all resolved imports from the containing module.
         for containing_module.import_resolutions.each
@@ -2560,7 +2560,7 @@ pub impl Resolver {
                                       span: span)
                                    -> ResolveResult<@mut Module> {
         let module_path_len = module_path.len();
-        fail_unless!(module_path_len > 0);
+        assert!(module_path_len > 0);
 
         debug!("(resolving module path for import) processing `%s` rooted at \
                `%s`",
@@ -2923,7 +2923,7 @@ pub impl Resolver {
         // If this is a search of all imports, we should be done with glob
         // resolution at this point.
         if name_search_type == SearchItemsAndAllImports {
-            fail_unless!(module_.glob_count == 0);
+            assert!(module_.glob_count == 0);
         }
 
         // Check the list of resolved imports.
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index f324640ef2c..12eaeb77d11 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -1259,7 +1259,7 @@ pub fn compile_submatch(bcx: block,
     /*
       For an empty match, a fall-through case must exist
      */
-    fail_unless!((m.len() > 0u || chk.is_some()));
+    assert!((m.len() > 0u || chk.is_some()));
     let _icx = bcx.insn_ctxt("match::compile_submatch");
     let mut bcx = bcx;
     let tcx = bcx.tcx(), dm = tcx.def_map;
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 1564b20e4d2..b854addf0b1 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -139,7 +139,7 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
                 CEnum(discrs.min(), discrs.max())
             } else if cases.len() == 1 {
                 // Equivalent to a struct/tuple/newtype.
-                fail_unless!(cases[0].discr == 0);
+                assert!(cases[0].discr == 0);
                 Univariant(mk_struct(cx, cases[0].tys), false)
             } else {
                 // The general case.  Since there's at least one
@@ -191,7 +191,7 @@ fn generic_fields_of(cx: @CrateContext, r: &Repr, sizing: bool)
             // To get "the" type of a general enum, we pick the case
             // with the largest alignment (so it will always align
             // correctly in containing structures) and pad it out.
-            fail_unless!(sts.len() >= 1);
+            assert!(sts.len() >= 1);
             let mut most_aligned = None;
             let mut largest_align = 0;
             let mut largest_size = 0;
@@ -300,16 +300,16 @@ pub fn trans_case(bcx: block, r: &Repr, discr: int) -> _match::opt_result {
 pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) {
     match *r {
         CEnum(min, max) => {
-            fail_unless!(min <= discr && discr <= max);
+            assert!(min <= discr && discr <= max);
             Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0]))
         }
         Univariant(ref st, true) => {
-            fail_unless!(discr == 0);
+            assert!(discr == 0);
             Store(bcx, C_bool(true),
                   GEPi(bcx, val, [0, st.fields.len() - 1]))
         }
         Univariant(*) => {
-            fail_unless!(discr == 0);
+            assert!(discr == 0);
         }
         General(*) => {
             Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0]))
@@ -325,7 +325,7 @@ pub fn num_args(r: &Repr, discr: int) -> uint {
     match *r {
         CEnum(*) => 0,
         Univariant(ref st, dtor) => {
-            fail_unless!(discr == 0);
+            assert!(discr == 0);
             st.fields.len() - (if dtor { 1 } else { 0 })
         }
         General(ref cases) => cases[discr as uint].fields.len() - 1
@@ -343,7 +343,7 @@ pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int,
             bcx.ccx().sess.bug(~"element access in C-like enum")
         }
         Univariant(ref st, _dtor) => {
-            fail_unless!(discr == 0);
+            assert!(discr == 0);
             struct_field_ptr(bcx, st, val, ix, false)
         }
         General(ref cases) => {
@@ -401,12 +401,12 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
                    vals: &[ValueRef]) -> ValueRef {
     match *r {
         CEnum(min, max) => {
-            fail_unless!(vals.len() == 0);
-            fail_unless!(min <= discr && discr <= max);
+            assert!(vals.len() == 0);
+            assert!(min <= discr && discr <= max);
             C_int(ccx, discr)
         }
         Univariant(ref st, _dro) => {
-            fail_unless!(discr == 0);
+            assert!(discr == 0);
             C_struct(build_const_struct(ccx, st, vals))
         }
         General(ref cases) => {
@@ -431,7 +431,7 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
  */
 fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef])
     -> ~[ValueRef] {
-    fail_unless!(vals.len() == st.fields.len());
+    assert!(vals.len() == st.fields.len());
 
     let mut offset = 0;
     let mut cfields = ~[];
@@ -447,7 +447,7 @@ fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef])
             cfields.push(padding(target_offset - offset));
             offset = target_offset;
         }
-        fail_unless!(!is_undef(vals[i]));
+        assert!(!is_undef(vals[i]));
         // If that assert fails, could change it to wrap in a struct?
         // (See `const_struct_field` for why real fields must not be undef.)
         cfields.push(vals[i]);
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 4a28f014a9d..f1988096a7e 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -314,7 +314,7 @@ pub fn non_gc_box_cast(bcx: block, val: ValueRef) -> ValueRef {
     unsafe {
         debug!("non_gc_box_cast");
         add_comment(bcx, ~"non_gc_box_cast");
-        fail_unless!(llvm::LLVMGetPointerAddressSpace(val_ty(val)) ==
+        assert!(llvm::LLVMGetPointerAddressSpace(val_ty(val)) ==
                      gc_box_addrspace || bcx.unreachable);
         let non_gc_t = T_ptr(llvm::LLVMGetElementType(val_ty(val)));
         PointerCast(bcx, val, non_gc_t)
@@ -489,7 +489,7 @@ pub fn get_res_dtor(ccx: @CrateContext, did: ast::def_id,
         let did = if did.crate != ast::local_crate {
             inline::maybe_instantiate_inline(ccx, did, true)
         } else { did };
-        fail_unless!(did.crate == ast::local_crate);
+        assert!(did.crate == ast::local_crate);
         let (val, _) =
             monomorphize::monomorphic_fn(ccx, did, substs, None, None, None);
 
@@ -1336,7 +1336,7 @@ pub fn cleanup_and_leave(bcx: block,
         }
         cur = match cur.parent {
           Some(next) => next,
-          None => { fail_unless!(upto.is_none()); break; }
+          None => { assert!(upto.is_none()); break; }
         };
     }
     match leave {
@@ -1523,7 +1523,7 @@ pub fn alloc_ty(bcx: block, t: ty::t) -> ValueRef {
     let ccx = bcx.ccx();
     let llty = type_of::type_of(ccx, t);
     if ty::type_has_params(t) { debug!("%s", ty_to_str(ccx.tcx, t)); }
-    fail_unless!(!ty::type_has_params(t));
+    assert!(!ty::type_has_params(t));
     let val = alloca(bcx, llty);
     return val;
 }
@@ -2471,7 +2471,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
             // Want parent_id and not id, because id is the dtor's type
             let class_ty = ty::lookup_item_type(tcx, parent_id).ty;
             // This code shouldn't be reached if the class is generic
-            fail_unless!(!ty::type_has_params(class_ty));
+            assert!(!ty::type_has_params(class_ty));
             let lldty = unsafe {
                 T_fn(~[
                     T_ptr(type_of(ccx, ty::mk_nil(tcx))),
@@ -2491,7 +2491,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
             let llfn;
             match v.node.kind {
                 ast::tuple_variant_kind(ref args) => {
-                    fail_unless!(args.len() != 0u);
+                    assert!(args.len() != 0u);
                     let pth = vec::append(/*bad*/copy *pth,
                                           ~[path_name(enm.ident),
                                             path_name((*v).node.name)]);
diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs
index ed6cbc20209..ab0e2f38a0b 100644
--- a/src/librustc/middle/trans/build.rs
+++ b/src/librustc/middle/trans/build.rs
@@ -813,7 +813,7 @@ pub fn Phi(cx: block, Ty: TypeRef, vals: &[ValueRef], bbs: &[BasicBlockRef])
     -> ValueRef {
     unsafe {
         if cx.unreachable { return llvm::LLVMGetUndef(Ty); }
-        fail_unless!(vals.len() == bbs.len());
+        assert!(vals.len() == bbs.len());
         let phi = EmptyPhi(cx, Ty);
         count_insn(cx, "addincoming");
         llvm::LLVMAddIncoming(phi, vec::raw::to_ptr(vals),
@@ -1033,7 +1033,7 @@ pub fn Trap(cx: block) {
         let T: ValueRef = str::as_c_str(~"llvm.trap", |buf| {
             llvm::LLVMGetNamedFunction(M, buf)
         });
-        fail_unless!((T as int != 0));
+        assert!((T as int != 0));
         let Args: ~[ValueRef] = ~[];
         unsafe {
             count_insn(cx, "trap");
@@ -1047,7 +1047,7 @@ pub fn LandingPad(cx: block, Ty: TypeRef, PersFn: ValueRef,
                   NumClauses: uint) -> ValueRef {
     unsafe {
         check_not_terminated(cx);
-        fail_unless!(!cx.unreachable);
+        assert!(!cx.unreachable);
         count_insn(cx, "landingpad");
         return llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn,
                                       NumClauses as c_uint, noname());
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index aef1fb762de..0377ed15a2d 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -133,7 +133,7 @@ pub fn trans(bcx: block, expr: @ast::expr) -> Callee {
             }
             ast::def_variant(tid, vid) => {
                 // nullary variants are not callable
-                fail_unless!(ty::enum_variant_with_id(bcx.tcx(),
+                assert!(ty::enum_variant_with_id(bcx.tcx(),
                                                       tid,
                                                       vid).args.len() > 0u);
                 fn_callee(bcx, trans_fn_ref(bcx, vid, ref_expr.id))
@@ -231,7 +231,7 @@ pub fn trans_fn_ref_with_vtables(
            vtables);
     let _indenter = indenter();
 
-    fail_unless!(type_params.all(|t| !ty::type_needs_infer(*t)));
+    assert!(type_params.all(|t| !ty::type_needs_infer(*t)));
 
     // Polytype of the function item (may have type params)
     let fn_tpt = ty::lookup_item_type(tcx, def_id);
@@ -286,7 +286,7 @@ pub fn trans_fn_ref_with_vtables(
     // Create a monomorphic verison of generic functions
     if must_monomorphise {
         // Should be either intra-crate or inlined.
-        fail_unless!(def_id.crate == ast::local_crate);
+        assert!(def_id.crate == ast::local_crate);
 
         let mut (val, must_cast) =
             monomorphize::monomorphic_fn(ccx, def_id, type_params,
@@ -705,7 +705,7 @@ pub fn trans_arg_expr(bcx: block,
         // FIXME(#3548) use the adjustments table
         match autoref_arg {
             DoAutorefArg => {
-                fail_unless!(!
+                assert!(!
                     bcx.ccx().maps.moves_map.contains(&arg_expr.id));
                 val = arg_datum.to_ref_llval(bcx);
             }
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index 0ea5007ca91..0ef9d4af604 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -271,7 +271,7 @@ pub fn build_closure(bcx0: block,
         let datum = expr::trans_local_var(bcx, cap_var.def);
         match cap_var.mode {
             moves::CapRef => {
-                fail_unless!(sigil == ast::BorrowedSigil);
+                assert!(sigil == ast::BorrowedSigil);
                 env_vals.push(EnvValue {action: EnvRef,
                                         datum: datum});
             }
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index b8c0b7f41d5..e9fc36bbd7d 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -255,8 +255,8 @@ pub struct param_substs {
 
 pub impl param_substs {
     fn validate(&self) {
-        for self.tys.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
-        for self.self_ty.each |t| { fail_unless!(!ty::type_needs_infer(*t)); }
+        for self.tys.each |t| { assert!(!ty::type_needs_infer(*t)); }
+        for self.self_ty.each |t| { assert!(!ty::type_needs_infer(*t)); }
     }
 }
 
@@ -1359,7 +1359,7 @@ pub fn monomorphize_type(bcx: block, t: ty::t) -> ty::t {
         Some(substs) => {
             ty::subst_tps(bcx.tcx(), substs.tys, substs.self_ty, t)
         }
-        _ => { fail_unless!(!ty::type_has_params(t)); t }
+        _ => { assert!(!ty::type_has_params(t)); t }
     }
 }
 
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index a495350a73f..2443c9998f1 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -74,7 +74,7 @@ pub fn const_lit(cx: @CrateContext, e: @ast::expr, lit: ast::lit)
 pub fn const_ptrcast(cx: @CrateContext, a: ValueRef, t: TypeRef) -> ValueRef {
     unsafe {
         let b = llvm::LLVMConstPointerCast(a, T_ptr(t));
-        fail_unless!(cx.const_globals.insert(b as int, a));
+        assert!(cx.const_globals.insert(b as int, a));
         b
     }
 }
@@ -116,7 +116,7 @@ fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef {
         None => v
     };
     unsafe {
-        fail_unless!(llvm::LLVMIsGlobalConstant(v) == True);
+        assert!(llvm::LLVMIsGlobalConstant(v) == True);
         llvm::LLVMGetInitializer(v)
     }
 }
@@ -131,7 +131,7 @@ fn const_deref(cx: @CrateContext, v: ValueRef, t: ty::t, explicit: bool)
     -> (ValueRef, ty::t) {
     match ty::deref(cx.tcx, t, explicit) {
         Some(ref mt) => {
-            fail_unless!(mt.mutbl != ast::m_mutbl);
+            assert!(mt.mutbl != ast::m_mutbl);
             let dv = match ty::get(t).sty {
                 ty::ty_ptr(*) | ty::ty_rptr(*) => {
                      const_deref_ptr(cx, v)
@@ -197,8 +197,8 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             match adj.autoref {
                 None => { }
                 Some(ref autoref) => {
-                    fail_unless!(autoref.region == ty::re_static);
-                    fail_unless!(autoref.mutbl != ast::m_mutbl);
+                    assert!(autoref.region == ty::re_static);
+                    assert!(autoref.mutbl != ast::m_mutbl);
                     // Don't copy data to do a deref+ref.
                     let llptr = match maybe_ptr {
                         Some(ptr) => ptr,
@@ -211,8 +211,8 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                         ty::AutoBorrowVec => {
                             let size = machine::llsize_of(cx,
                                                           val_ty(llconst));
-                            fail_unless!(abi::slice_elt_base == 0);
-                            fail_unless!(abi::slice_elt_len == 1);
+                            assert!(abi::slice_elt_base == 0);
+                            assert!(abi::slice_elt_len == 1);
                             llconst = C_struct(~[llptr, size]);
                         }
                         _ => {
@@ -375,7 +375,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
 
               let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
               let len = match ty::get(bt).sty {
-                  ty::ty_estr(*) => {fail_unless!(len > 0); len - 1},
+                  ty::ty_estr(*) => {assert!(len > 0); len - 1},
                   _ => len
               };
               if iv >= len {
@@ -494,14 +494,14 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_path(pth) => {
-            fail_unless!(pth.types.len() == 0);
+            assert!(pth.types.len() == 0);
             match cx.tcx.def_map.find(&e.id) {
                 Some(&ast::def_fn(def_id, _purity)) => {
                     if !ast_util::is_local(def_id) {
                         let ty = csearch::get_type(cx.tcx, def_id).ty;
                         base::trans_external_path(cx, def_id, ty)
                     } else {
-                        fail_unless!(ast_util::is_local(def_id));
+                        assert!(ast_util::is_local(def_id));
                         base::get_item_val(cx, def_id.node)
                     }
                 }
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index 1c201d0def6..c2235b763e2 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -47,7 +47,7 @@ pub fn trans_block(bcx: block, b: &ast::blk, dest: expr::Dest) -> block {
             bcx = expr::trans_into(bcx, e, dest);
         }
         None => {
-            fail_unless!(dest == expr::Ignore || bcx.unreachable);
+            assert!(dest == expr::Ignore || bcx.unreachable);
         }
     }
     return bcx;
diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs
index 164f6fe44fc..869fdc20a65 100644
--- a/src/librustc/middle/trans/datum.rs
+++ b/src/librustc/middle/trans/datum.rs
@@ -247,19 +247,19 @@ pub impl Datum {
                       action: CopyAction, datum: Datum) -> block {
         debug!("store_to_datum(self=%s, action=%?, datum=%s)",
                self.to_str(bcx.ccx()), action, datum.to_str(bcx.ccx()));
-        fail_unless!(datum.mode.is_by_ref());
+        assert!(datum.mode.is_by_ref());
         self.store_to(bcx, id, action, datum.val)
     }
 
     fn move_to_datum(&self, bcx: block, action: CopyAction, datum: Datum)
                     -> block {
-        fail_unless!(datum.mode.is_by_ref());
+        assert!(datum.mode.is_by_ref());
         self.move_to(bcx, action, datum.val)
     }
 
     fn copy_to_datum(&self, bcx: block, action: CopyAction, datum: Datum)
                     -> block {
-        fail_unless!(datum.mode.is_by_ref());
+        assert!(datum.mode.is_by_ref());
         self.copy_to(bcx, action, datum.val)
     }
 
@@ -372,7 +372,7 @@ pub impl Datum {
          * Schedules this datum for cleanup in `bcx`.  The datum
          * must be an rvalue. */
 
-        fail_unless!(self.source == RevokeClean);
+        assert!(self.source == RevokeClean);
         match self.mode {
             ByValue => {
                 add_clean_temp_immediate(bcx, self.val, self.ty);
@@ -393,7 +393,7 @@ pub impl Datum {
                     // Lvalues which potentially need to be dropped
                     // must be passed by ref, so that we can zero them
                     // out.
-                    fail_unless!(self.mode.is_by_ref());
+                    assert!(self.mode.is_by_ref());
                     zero_mem(bcx, self.val, self.ty);
                 }
             }
@@ -697,7 +697,7 @@ pub impl Datum {
                         // changing the type, so I am putting this
                         // code in place here to do the right
                         // thing if this change ever goes through.
-                        fail_unless!(ty::type_is_immediate(ty));
+                        assert!(ty::type_is_immediate(ty));
                         (Some(Datum {ty: ty, ..*self}), bcx)
                     }
                 };
@@ -737,7 +737,7 @@ pub impl Datum {
                         // except for changing the type, so I am putting this
                         // code in place here to do the right thing if this
                         // change ever goes through.
-                        fail_unless!(ty::type_is_immediate(ty));
+                        assert!(ty::type_is_immediate(ty));
                         (Some(Datum {ty: ty, ..*self}), bcx)
                     }
                 }
@@ -797,7 +797,7 @@ pub impl Datum {
         // either we were asked to deref a specific number of times,
         // in which case we should have, or we asked to deref as many
         // times as we can
-        fail_unless!(derefs == max || max == uint::max_value);
+        assert!(derefs == max || max == uint::max_value);
         DatumBlock { bcx: bcx, datum: datum }
     }
 
@@ -817,7 +817,7 @@ pub impl DatumBlock {
     }
 
     fn assert_by_ref(&self) -> DatumBlock {
-        fail_unless!(self.datum.mode.is_by_ref());
+        assert!(self.datum.mode.is_by_ref());
         *self
     }
 
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 6825c3896e4..dc910f9f178 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -278,7 +278,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
         debug!("add_env(closure_ty=%s)", ty_to_str(tcx, closure_ty));
         let scratch = scratch_datum(bcx, closure_ty, false);
         let llfn = GEPi(bcx, scratch.val, [0u, abi::fn_field_code]);
-        fail_unless!(datum.appropriate_mode() == ByValue);
+        assert!(datum.appropriate_mode() == ByValue);
         Store(bcx, datum.to_appropriate_llval(bcx), llfn);
         let llenv = GEPi(bcx, scratch.val, [0u, abi::fn_field_box]);
         Store(bcx, base::null_env_ptr(bcx), llenv);
@@ -457,7 +457,7 @@ fn trans_rvalue_datum_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
         }
         ast::expr_binary(op, lhs, rhs) => {
             // if overloaded, would be RvalueDpsExpr
-            fail_unless!(!bcx.ccx().maps.method_map.contains_key(&expr.id));
+            assert!(!bcx.ccx().maps.method_map.contains_key(&expr.id));
 
             return trans_binary(bcx, expr, op, lhs, rhs);
         }
@@ -1301,10 +1301,10 @@ fn trans_unary_datum(bcx: block,
     let _icx = bcx.insn_ctxt("trans_unary_datum");
 
     // if deref, would be LvalueExpr
-    fail_unless!(op != ast::deref);
+    assert!(op != ast::deref);
 
     // if overloaded, would be RvalueDpsExpr
-    fail_unless!(!bcx.ccx().maps.method_map.contains_key(&un_expr.id));
+    assert!(!bcx.ccx().maps.method_map.contains_key(&un_expr.id));
 
     let un_ty = expr_ty(bcx, un_expr);
     let sub_ty = expr_ty(bcx, sub_expr);
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index 1639c6b414d..1b27d21e6f4 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -401,7 +401,7 @@ pub fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) {
     let _icx = bcx.insn_ctxt("make_visit_glue");
     let mut bcx = bcx;
     let ty_visitor_name = special_idents::ty_visitor;
-    fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name));
+    assert!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name));
     let (trait_id, ty) = *bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name);
     let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty)));
     bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, trait_id);
@@ -489,7 +489,7 @@ pub fn trans_struct_drop(bcx: block,
         // Class dtors have no explicit args, so the params should
         // just consist of the output pointer and the environment
         // (self)
-        fail_unless!((params.len() == 2));
+        assert!((params.len() == 2));
 
         // If we need to take a reference to the class (because it's using
         // the Drop trait), do so now.
@@ -675,7 +675,7 @@ pub fn declare_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info {
     let _icx = ccx.insn_ctxt("declare_tydesc");
     // If emit_tydescs already ran, then we shouldn't be creating any new
     // tydescs.
-    fail_unless!(!*ccx.finished_tydescs);
+    assert!(!*ccx.finished_tydescs);
 
     let llty = type_of(ccx, t);
 
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index ae2d7bbee50..ed9000e7418 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -327,7 +327,7 @@ pub fn trans_static_method_callee(bcx: block,
 
     match vtbls[bound_index] {
         typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => {
-            fail_unless!(rcvr_substs.all(|t| !ty::type_needs_infer(*t)));
+            assert!(rcvr_substs.all(|t| !ty::type_needs_infer(*t)));
 
             let mth_id = method_with_name(bcx.ccx(), impl_did, mname);
             let callee_substs = combine_impl_and_methods_tps(
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 29760eb0bb5..71e8f7c2125 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -47,7 +47,7 @@ pub fn monomorphic_fn(ccx: @CrateContext,
                       impl_did_opt: Option<ast::def_id>,
                       ref_id: Option<ast::node_id>) ->
                       (ValueRef, bool) {
-    fail_unless!(real_substs.all(|t| !ty::type_needs_infer(*t)));
+    assert!(real_substs.all(|t| !ty::type_needs_infer(*t)));
     let _icx = ccx.insn_ctxt("monomorphic_fn");
     let mut must_cast = false;
     let substs = vec::map(real_substs, |t| {
@@ -57,8 +57,8 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         }
     });
 
-    for real_substs.each() |s| { fail_unless!(!ty::type_has_params(*s)); }
-    for substs.each() |s| { fail_unless!(!ty::type_has_params(*s)); }
+    for real_substs.each() |s| { assert!(!ty::type_has_params(*s)); }
+    for substs.each() |s| { assert!(!ty::type_has_params(*s)); }
     let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len());
     // XXX: Bad copy.
     let hash_id = make_mono_id(ccx, fn_id, copy substs, vtables, impl_did_opt,
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index b8145e65326..a9869f15875 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -336,7 +336,7 @@ pub fn emit_calls_to_trait_visit_ty(bcx: block,
                                  -> block {
     use syntax::parse::token::special_idents::tydesc;
     let final = sub_block(bcx, ~"final");
-    fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc));
+    assert!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc));
     let (_, tydesc_ty) = *bcx.ccx().tcx.intrinsic_defs.get(&tydesc);
     let tydesc_ty = type_of(bcx.ccx(), tydesc_ty);
     let mut r = Reflector {
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
index 8e4719d2ccc..a9381647b33 100644
--- a/src/librustc/middle/trans/type_of.rs
+++ b/src/librustc/middle/trans/type_of.rs
@@ -68,7 +68,7 @@ pub fn type_of_fn_from_ty(cx: @CrateContext, fty: ty::t) -> TypeRef {
 }
 
 pub fn type_of_non_gc_box(cx: @CrateContext, t: ty::t) -> TypeRef {
-    fail_unless!(!ty::type_needs_infer(t));
+    assert!(!ty::type_needs_infer(t));
 
     let t_norm = ty::normalize_ty(cx.tcx, t);
     if t != t_norm {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 5e46fb512d4..425f14b7c07 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -2005,7 +2005,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
                 // If this assertion failures, it is likely because of a
                 // failure in the cross-crate inlining code to translate a
                 // def-id.
-                fail_unless!(p.def_id.crate == ast::local_crate);
+                assert!(p.def_id.crate == ast::local_crate);
 
                 param_bounds_to_contents(
                     cx, *cx.ty_param_bounds.get(&p.def_id.node))
@@ -3559,7 +3559,7 @@ pub fn trait_supertraits(cx: ctxt,
 
     // Not in the cache. It had better be in the metadata, which means it
     // shouldn't be local.
-    fail_unless!(!is_local(id));
+    assert!(!is_local(id));
 
     // Get the supertraits out of the metadata and create the
     // InstantiatedTraitRef for each.
@@ -3591,7 +3591,7 @@ pub fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] {
         // If the lookup in trait_method_cache fails, assume that the trait
         // method we're trying to look up is in a different crate, and look
         // for it there.
-        fail_unless!(id.crate != ast::local_crate);
+        assert!(id.crate != ast::local_crate);
         let result = csearch::get_trait_methods(cx, id);
 
         // Store the trait method in the local trait_method_cache so that
@@ -3912,7 +3912,7 @@ pub fn lookup_item_type(cx: ctxt,
         return tpt;
       }
       None => {
-        fail_unless!(did.crate != ast::local_crate);
+        assert!(did.crate != ast::local_crate);
         let tyt = csearch::get_type(cx, did);
         cx.tcache.insert(did, tyt);
         return tyt;
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index eb106f3b91f..697649a4187 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -585,7 +585,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
     // The caller should not both provide explicit bound lifetime
     // names and expected types.  Either we infer the bound lifetime
     // names or they are provided, but not both.
-    fail_unless!(lifetimes.is_empty() || expected_sig.is_none());
+    assert!(lifetimes.is_empty() || expected_sig.is_none());
 
     debug!("ty_of_fn_decl");
     let _i = indenter();
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 18d84b96787..f1396432957 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -1802,7 +1802,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
 
         if check_completeness && !error_happened {
             // Make sure the programmer specified all the fields.
-            fail_unless!(fields_found <= field_types.len());
+            assert!(fields_found <= field_types.len());
             if fields_found < field_types.len() {
                 let mut missing_fields = ~[];
                 for field_types.each |class_field| {
@@ -3412,8 +3412,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
       ~"visit_tydesc" => {
           let tydesc_name = special_idents::tydesc;
           let ty_visitor_name = tcx.sess.ident_of(~"TyVisitor");
-          fail_unless!(tcx.intrinsic_defs.contains_key(&tydesc_name));
-          fail_unless!(ccx.tcx.intrinsic_defs.contains_key(&ty_visitor_name));
+          assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
+          assert!(ccx.tcx.intrinsic_defs.contains_key(&ty_visitor_name));
           let (_, tydesc_ty) = *tcx.intrinsic_defs.get(&tydesc_name);
           let (_, visitor_trait) = *tcx.intrinsic_defs.get(&ty_visitor_name);
 
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index d161df22976..dfc5f218d67 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -712,7 +712,7 @@ pub mod guarantor {
             ast::expr_copy(*) |
             ast::expr_repeat(*) |
             ast::expr_vec(*) => {
-                fail_unless!(!ty::expr_is_lval(
+                assert!(!ty::expr_is_lval(
                     rcx.fcx.tcx(), rcx.fcx.inh.method_map, expr));
                 None
             }
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index d485ca447fc..a1eaa1f6a33 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -181,7 +181,7 @@ pub fn lookup_vtable(vcx: &VtableContext,
         Some(ty) => ty,
         None => {
             // fixup_ty can only fail if this is early resolution
-            fail_unless!(is_early);
+            assert!(is_early);
             // The type has unconstrained type variables in it, so we can't
             // do early resolution on it. Return some completely bogus vtable
             // information: we aren't storing it anyways.
@@ -367,7 +367,7 @@ pub fn lookup_vtable(vcx: &VtableContext,
                                                               is_early) {
                                 Some(ref substs) => (/*bad*/copy *substs),
                                 None => {
-                                    fail_unless!(is_early);
+                                    assert!(is_early);
                                     // Bail out with a bogus answer
                                     return Some(vtable_param(0, 0));
                                 }
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 498ad2c5bff..4fc9e8d19ae 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -797,7 +797,7 @@ pub impl CoherenceChecker {
     }
 
     fn span_of_impl(&self, implementation: @Impl) -> span {
-        fail_unless!(implementation.did.crate == local_crate);
+        assert!(implementation.did.crate == local_crate);
         match self.crate_context.tcx.items.find(&implementation.did.node) {
             Some(&node_item(item, _)) => {
                 return item.span;
diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs
index ca59ee0328a..d8093d571a1 100644
--- a/src/librustc/middle/typeck/infer/mod.rs
+++ b/src/librustc/middle/typeck/infer/mod.rs
@@ -586,7 +586,7 @@ pub impl InferCtxt {
 
     /// Execute `f` and commit the bindings if successful
     fn commit<T,E>(@mut self, f: &fn() -> Result<T,E>) -> Result<T,E> {
-        fail_unless!(!self.in_snapshot());
+        assert!(!self.in_snapshot());
 
         debug!("commit()");
         do indent {
@@ -679,7 +679,7 @@ pub impl InferCtxt {
         let region_var = self.next_region_var_nb(span);
 
         // add lb_region as a lower bound on the newly built variable
-        fail_unless!(self.region_vars.make_subregion(span,
+        assert!(self.region_vars.make_subregion(span,
                                                      lb_region,
                                                      region_var).is_ok());
 
diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs
index 19c06804ea0..d9f00451dd5 100644
--- a/src/librustc/middle/typeck/infer/region_inference.rs
+++ b/src/librustc/middle/typeck/infer/region_inference.rs
@@ -671,7 +671,7 @@ pub impl RegionVarBindings {
             match undo_item {
               Snapshot => {}
               AddVar(vid) => {
-                fail_unless!(self.var_spans.len() == vid.to_uint() + 1);
+                assert!(self.var_spans.len() == vid.to_uint() + 1);
                 self.var_spans.pop();
               }
               AddConstraint(ref constraint) => {
@@ -731,7 +731,7 @@ pub impl RegionVarBindings {
 
     fn add_constraint(&mut self, +constraint: Constraint, span: span) {
         // cannot add constraints once regions are resolved
-        fail_unless!(self.values.is_empty());
+        assert!(self.values.is_empty());
 
         debug!("RegionVarBindings: add_constraint(%?)", constraint);
 
@@ -747,7 +747,7 @@ pub impl RegionVarBindings {
                       sub: Region,
                       sup: Region) -> cres<()> {
         // cannot add constraints once regions are resolved
-        fail_unless!(self.values.is_empty());
+        assert!(self.values.is_empty());
 
         debug!("RegionVarBindings: make_subregion(%?, %?)", sub, sup);
         match (sub, sup) {
@@ -789,7 +789,7 @@ pub impl RegionVarBindings {
                    b: Region)
                 -> cres<Region> {
         // cannot add constraints once regions are resolved
-        fail_unless!(self.values.is_empty());
+        assert!(self.values.is_empty());
 
         debug!("RegionVarBindings: lub_regions(%?, %?)", a, b);
         match (a, b) {
@@ -815,7 +815,7 @@ pub impl RegionVarBindings {
                    b: Region)
                 -> cres<Region> {
         // cannot add constraints once regions are resolved
-        fail_unless!(self.values.is_empty());
+        assert!(self.values.is_empty());
 
         debug!("RegionVarBindings: glb_regions(%?, %?)", a, b);
         match (a, b) {
@@ -1359,7 +1359,7 @@ pub impl RegionVarBindings {
 
         return match a_node.value {
             NoValue => {
-                fail_unless!(a_node.classification == Contracting);
+                assert!(a_node.classification == Contracting);
                 a_node.value = Value(b_region);
                 true // changed
             }
@@ -1617,7 +1617,7 @@ pub impl RegionVarBindings {
                   }
 
                   ConstrainRegSubVar(region, _) => {
-                    fail_unless!(dir == Incoming);
+                    assert!(dir == Incoming);
                     result.push(SpannedRegion {
                         region: region,
                         span: edge.span
@@ -1625,7 +1625,7 @@ pub impl RegionVarBindings {
                   }
 
                   ConstrainVarSubReg(_, region) => {
-                    fail_unless!(dir == Outgoing);
+                    assert!(dir == Outgoing);
                     result.push(SpannedRegion {
                         region: region,
                         span: edge.span
diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs
index 038dc524bec..c208d1d24fc 100644
--- a/src/librustc/middle/typeck/infer/resolve.rs
+++ b/src/librustc/middle/typeck/infer/resolve.rs
@@ -114,9 +114,9 @@ pub impl ResolveState {
         // n.b. This is a hokey mess because the current fold doesn't
         // allow us to pass back errors in any useful way.
 
-        fail_unless!(vec::is_empty(self.v_seen));
+        assert!(vec::is_empty(self.v_seen));
         let rty = indent(|| self.resolve_type(typ) );
-        fail_unless!(vec::is_empty(self.v_seen));
+        assert!(vec::is_empty(self.v_seen));
         match self.err {
           None => {
             debug!("Resolved to %s + %s (modes=%x)",
diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs
index 6a4def65fe7..52a0300c5a0 100644
--- a/src/librustc/middle/typeck/infer/test.rs
+++ b/src/librustc/middle/typeck/infer/test.rs
@@ -110,7 +110,7 @@ pub impl Env {
                       m: &ast::_mod,
                       idx: uint,
                       names: &[~str]) -> Option<ast::node_id> {
-            fail_unless!(idx < names.len());
+            assert!(idx < names.len());
             for m.items.each |item| {
                 if self.tcx.sess.str_of(item.ident) == names[idx] {
                     return search(self, *item, idx+1, names);
diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs
index 3c5470dc22f..75dac7fd7c5 100644
--- a/src/librustc/middle/typeck/infer/unify.rs
+++ b/src/librustc/middle/typeck/infer/unify.rs
@@ -131,7 +131,7 @@ pub impl InferCtxt {
         } else {
             // If equal, redirect one to the other and increment the
             // other's rank.
-            fail_unless!(node_a.rank == node_b.rank);
+            assert!(node_a.rank == node_b.rank);
             self.set(node_b.root, Redirect(node_a.root));
             (node_a.root, node_a.rank + 1)
         }
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs
index ea577c758af..2df9884911e 100644
--- a/src/librustc/middle/typeck/mod.rs
+++ b/src/librustc/middle/typeck/mod.rs
@@ -184,7 +184,7 @@ pub struct CrateCtxt {
 // Functions that write types into the node type table
 pub fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) {
     debug!("write_ty_to_tcx(%d, %s)", node_id, ppaux::ty_to_str(tcx, ty));
-    fail_unless!(!ty::type_needs_infer(ty));
+    assert!(!ty::type_needs_infer(ty));
     tcx.node_types.insert(node_id as uint, ty);
 }
 pub fn write_substs_to_tcx(tcx: ty::ctxt,
@@ -193,7 +193,7 @@ pub fn write_substs_to_tcx(tcx: ty::ctxt,
     if substs.len() > 0u {
         debug!("write_substs_to_tcx(%d, %?)", node_id,
                substs.map(|t| ppaux::ty_to_str(tcx, *t)));
-        fail_unless!(substs.all(|t| !ty::type_needs_infer(*t)));
+        assert!(substs.all(|t| !ty::type_needs_infer(*t)));
         tcx.node_type_substs.insert(node_id, substs);
     }
 }
diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs
index 7082c154d2f..eeca90dbecd 100644
--- a/src/librustc/middle/typeck/rscope.rs
+++ b/src/librustc/middle/typeck/rscope.rs
@@ -180,7 +180,7 @@ impl region_scope for MethodRscope {
         })
     }
     fn self_region(&self, _span: span) -> Result<ty::Region, RegionError> {
-        fail_unless!(self.variance.is_some() || self.self_ty.is_borrowed());
+        assert!(self.variance.is_some() || self.self_ty.is_borrowed());
         match self.variance {
             None => {}  // must be borrowed self, so this is OK
             Some(_) => {
diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs
index d3108f690c1..3b905c612a5 100644
--- a/src/librustdoc/astsrv.rs
+++ b/src/librustdoc/astsrv.rs
@@ -138,7 +138,7 @@ fn should_prune_unconfigured_items() {
     let source = ~"#[cfg(shut_up_and_leave_me_alone)]fn a() { }";
     do from_str(source) |srv| {
         do exec(srv) |ctxt| {
-            fail_unless!(vec::is_empty(ctxt.ast.node.module.items));
+            assert!(vec::is_empty(ctxt.ast.node.module.items));
         }
     }
 }
@@ -148,7 +148,7 @@ fn srv_should_build_ast_map() {
     let source = ~"fn a() { }";
     do from_str(source) |srv| {
         do exec(srv) |ctxt| {
-            fail_unless!(!ctxt.ast_map.is_empty())
+            assert!(!ctxt.ast_map.is_empty())
         };
     }
 }
@@ -164,6 +164,6 @@ fn srv_should_return_request_result() {
     let source = ~"fn a() { }";
     do from_str(source) |srv| {
         let result = exec(srv, |_ctxt| 1000 );
-        fail_unless!(result == 1000);
+        assert!(result == 1000);
     }
 }
diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs
index 32966156eb1..213198e6f21 100644
--- a/src/librustdoc/attr_parser.rs
+++ b/src/librustdoc/attr_parser.rs
@@ -71,7 +71,7 @@ fn should_extract_crate_name_from_link_attribute() {
     let source = ~"#[link(name = \"snuggles\")]";
     let attrs = test::parse_attributes(source);
     let attrs = parse_crate(attrs);
-    fail_unless!(attrs.name == Some(~"snuggles"));
+    assert!(attrs.name == Some(~"snuggles"));
 }
 
 #[test]
@@ -79,7 +79,7 @@ fn should_not_extract_crate_name_if_no_link_attribute() {
     let source = ~"";
     let attrs = test::parse_attributes(source);
     let attrs = parse_crate(attrs);
-    fail_unless!(attrs.name == None);
+    assert!(attrs.name == None);
 }
 
 #[test]
@@ -87,7 +87,7 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() {
     let source = ~"#[link(whatever)]";
     let attrs = test::parse_attributes(source);
     let attrs = parse_crate(attrs);
-    fail_unless!(attrs.name == None);
+    assert!(attrs.name == None);
 }
 
 pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> {
@@ -106,7 +106,7 @@ fn parse_desc_should_handle_undocumented_mods() {
     let source = ~"";
     let attrs = test::parse_attributes(source);
     let attrs = parse_desc(attrs);
-    fail_unless!(attrs == None);
+    assert!(attrs == None);
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn parse_desc_should_parse_simple_doc_attributes() {
     let source = ~"#[doc = \"basic\"]";
     let attrs = test::parse_attributes(source);
     let attrs = parse_desc(attrs);
-    fail_unless!(attrs == Some(~"basic"));
+    assert!(attrs == Some(~"basic"));
 }
 
 pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool {
@@ -133,28 +133,28 @@ pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool {
 fn should_parse_hidden_attribute() {
     let source = ~"#[doc(hidden)]";
     let attrs = test::parse_attributes(source);
-    fail_unless!(parse_hidden(attrs) == true);
+    assert!(parse_hidden(attrs) == true);
 }
 
 #[test]
 fn should_parse_hidden_attribute_with_other_docs() {
     let source = ~"#[doc = \"foo\"] #[doc(hidden)] #[doc = \"foo\"]";
     let attrs = test::parse_attributes(source);
-    fail_unless!(parse_hidden(attrs) == true);
+    assert!(parse_hidden(attrs) == true);
 }
 
 #[test]
 fn should_not_parse_non_hidden_attribute() {
     let source = ~"#[doc = \"\"]";
     let attrs = test::parse_attributes(source);
-    fail_unless!(parse_hidden(attrs) == false);
+    assert!(parse_hidden(attrs) == false);
 }
 
 #[test]
 fn should_concatenate_multiple_doc_comments() {
     let source = ~"/// foo\n/// bar";
     let desc = parse_desc(test::parse_attributes(source));
-    fail_unless!(desc == Some(~"foo\nbar"));
+    assert!(desc == Some(~"foo\nbar"));
 }
 
 
diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs
index 101c11bd58b..b550155140f 100644
--- a/src/librustdoc/attr_pass.rs
+++ b/src/librustdoc/attr_pass.rs
@@ -81,7 +81,7 @@ fn fold_crate(
 #[test]
 fn should_replace_top_module_name_with_crate_name() {
     let doc = test::mk_doc(~"#[link(name = \"bond\")];");
-    fail_unless!(doc.cratemod().name() == ~"bond");
+    assert!(doc.cratemod().name() == ~"bond");
 }
 
 fn fold_item(
@@ -124,25 +124,25 @@ fn parse_item_attrs<T:Owned>(
 #[test]
 fn should_should_extract_mod_attributes() {
     let doc = test::mk_doc(~"#[doc = \"test\"] mod a { }");
-    fail_unless!(doc.cratemod().mods()[0].desc() == Some(~"test"));
+    assert!(doc.cratemod().mods()[0].desc() == Some(~"test"));
 }
 
 #[test]
 fn should_extract_top_mod_attributes() {
     let doc = test::mk_doc(~"#[doc = \"test\"];");
-    fail_unless!(doc.cratemod().desc() == Some(~"test"));
+    assert!(doc.cratemod().desc() == Some(~"test"));
 }
 
 #[test]
 fn should_extract_foreign_fn_attributes() {
     let doc = test::mk_doc(~"extern { #[doc = \"test\"] fn a(); }");
-    fail_unless!(doc.cratemod().nmods()[0].fns[0].desc() == Some(~"test"));
+    assert!(doc.cratemod().nmods()[0].fns[0].desc() == Some(~"test"));
 }
 
 #[test]
 fn should_extract_fn_attributes() {
     let doc = test::mk_doc(~"#[doc = \"test\"] fn a() -> int { }");
-    fail_unless!(doc.cratemod().fns()[0].desc() == Some(~"test"));
+    assert!(doc.cratemod().fns()[0].desc() == Some(~"test"));
 }
 
 fn fold_enum(
@@ -194,13 +194,13 @@ fn fold_enum(
 fn should_extract_enum_docs() {
     let doc = test::mk_doc(~"#[doc = \"b\"]\
                             enum a { v }");
-    fail_unless!(doc.cratemod().enums()[0].desc() == Some(~"b"));
+    assert!(doc.cratemod().enums()[0].desc() == Some(~"b"));
 }
 
 #[test]
 fn should_extract_variant_docs() {
     let doc = test::mk_doc(~"enum a { #[doc = \"c\"] v }");
-    fail_unless!(doc.cratemod().enums()[0].variants[0].desc == Some(~"c"));
+    assert!(doc.cratemod().enums()[0].variants[0].desc == Some(~"c"));
 }
 
 fn fold_trait(
@@ -253,7 +253,7 @@ fn merge_method_attrs(
     };
 
     do vec::map2(docs, attrs) |doc, attrs| {
-        fail_unless!(doc.name == attrs.first());
+        assert!(doc.name == attrs.first());
         let desc = attrs.second();
 
         doc::MethodDoc {
@@ -266,7 +266,7 @@ fn merge_method_attrs(
 #[test]
 fn should_extract_trait_docs() {
     let doc = test::mk_doc(~"#[doc = \"whatever\"] trait i { fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].desc() == Some(~"whatever"));
+    assert!(doc.cratemod().traits()[0].desc() == Some(~"whatever"));
 }
 
 #[test]
@@ -276,7 +276,7 @@ fn should_extract_trait_method_docs() {
          #[doc = \"desc\"]\
          fn f(a: bool) -> bool;\
          }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].desc == Some(~"desc"));
+    assert!(doc.cratemod().traits()[0].methods[0].desc == Some(~"desc"));
 }
 
 
@@ -297,7 +297,7 @@ fn fold_impl(
 fn should_extract_impl_docs() {
     let doc = test::mk_doc(
         ~"#[doc = \"whatever\"] impl int { fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].desc() == Some(~"whatever"));
+    assert!(doc.cratemod().impls()[0].desc() == Some(~"whatever"));
 }
 
 #[test]
@@ -307,7 +307,7 @@ fn should_extract_impl_method_docs() {
          #[doc = \"desc\"]\
          fn f(a: bool) -> bool { }\
          }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].desc == Some(~"desc"));
+    assert!(doc.cratemod().impls()[0].methods[0].desc == Some(~"desc"));
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 2b95d42f40e..62ddec7a119 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -253,7 +253,7 @@ fn should_find_pandoc() {
         ProgramOutput { status: 0, out: ~"pandoc 1.8.2.1", err: ~"" }
     };
     let result = maybe_find_pandoc(&config, None, mock_program_output);
-    fail_unless!(result == result::Ok(Some(~"pandoc")));
+    assert!(result == result::Ok(Some(~"pandoc")));
 }
 
 #[test]
@@ -266,7 +266,7 @@ fn should_error_with_no_pandoc() {
         ProgramOutput { status: 1, out: ~"", err: ~"" }
     };
     let result = maybe_find_pandoc(&config, None, mock_program_output);
-    fail_unless!(result == result::Err(~"couldn't find pandoc"));
+    assert!(result == result::Err(~"couldn't find pandoc"));
 }
 
 #[cfg(test)]
@@ -283,20 +283,20 @@ mod test {
 #[test]
 fn should_error_with_no_crates() {
     let config = test::parse_config(~[~"rustdoc"]);
-    fail_unless!(config.get_err() == ~"no crates specified");
+    assert!(config.get_err() == ~"no crates specified");
 }
 
 #[test]
 fn should_error_with_multiple_crates() {
     let config =
         test::parse_config(~[~"rustdoc", ~"crate1.rc", ~"crate2.rc"]);
-    fail_unless!(config.get_err() == ~"multiple crates specified");
+    assert!(config.get_err() == ~"multiple crates specified");
 }
 
 #[test]
 fn should_set_output_dir_to_cwd_if_not_provided() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    fail_unless!(config.get().output_dir == Path("."));
+    assert!(config.get().output_dir == Path("."));
 }
 
 #[test]
@@ -304,13 +304,13 @@ fn should_set_output_dir_if_provided() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles"
     ]);
-    fail_unless!(config.get().output_dir == Path("snuggles"));
+    assert!(config.get().output_dir == Path("snuggles"));
 }
 
 #[test]
 fn should_set_output_format_to_pandoc_html_if_not_provided() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    fail_unless!(config.get().output_format == PandocHtml);
+    assert!(config.get().output_format == PandocHtml);
 }
 
 #[test]
@@ -318,7 +318,7 @@ fn should_set_output_format_to_markdown_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
     ]);
-    fail_unless!(config.get().output_format == Markdown);
+    assert!(config.get().output_format == Markdown);
 }
 
 #[test]
@@ -326,7 +326,7 @@ fn should_set_output_format_to_pandoc_html_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
     ]);
-    fail_unless!(config.get().output_format == PandocHtml);
+    assert!(config.get().output_format == PandocHtml);
 }
 
 #[test]
@@ -334,13 +334,13 @@ fn should_error_on_bogus_format() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus"
     ]);
-    fail_unless!(config.get_err() == ~"unknown output format 'bogus'");
+    assert!(config.get_err() == ~"unknown output format 'bogus'");
 }
 
 #[test]
 fn should_set_output_style_to_doc_per_mod_by_default() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    fail_unless!(config.get().output_style == DocPerMod);
+    assert!(config.get().output_style == DocPerMod);
 }
 
 #[test]
@@ -348,7 +348,7 @@ fn should_set_output_style_to_one_doc_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate"
     ]);
-    fail_unless!(config.get().output_style == DocPerCrate);
+    assert!(config.get().output_style == DocPerCrate);
 }
 
 #[test]
@@ -356,7 +356,7 @@ fn should_set_output_style_to_doc_per_mod_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod"
     ]);
-    fail_unless!(config.get().output_style == DocPerMod);
+    assert!(config.get().output_style == DocPerMod);
 }
 
 #[test]
@@ -364,7 +364,7 @@ fn should_error_on_bogus_output_style() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus"
     ]);
-    fail_unless!(config.get_err() == ~"unknown output style 'bogus'");
+    assert!(config.get_err() == ~"unknown output style 'bogus'");
 }
 
 #[test]
@@ -372,11 +372,11 @@ fn should_set_pandoc_command_if_requested() {
     let config = test::parse_config(~[
         ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc"
     ]);
-    fail_unless!(config.get().pandoc_cmd == Some(~"panda-bear-doc"));
+    assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc"));
 }
 
 #[test]
 fn should_set_pandoc_command_when_using_pandoc() {
     let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]);
-    fail_unless!(config.get().pandoc_cmd == Some(~"pandoc"));
+    assert!(config.get().pandoc_cmd == Some(~"pandoc"));
 }
diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs
index 012a56c5b72..7c50af40f33 100644
--- a/src/librustdoc/desc_to_brief_pass.rs
+++ b/src/librustdoc/desc_to_brief_pass.rs
@@ -84,13 +84,13 @@ fn fold_impl(fold: &fold::Fold<()>, doc: doc::ImplDoc) -> doc::ImplDoc {
 #[test]
 fn should_promote_desc() {
     let doc = test::mk_doc(~"#[doc = \"desc\"] mod m { }");
-    fail_unless!(doc.cratemod().mods()[0].brief() == Some(~"desc"));
+    assert!(doc.cratemod().mods()[0].brief() == Some(~"desc"));
 }
 
 #[test]
 fn should_promote_trait_method_desc() {
     let doc = test::mk_doc(~"trait i { #[doc = \"desc\"] fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].brief ==
+    assert!(doc.cratemod().traits()[0].methods[0].brief ==
         Some(~"desc"));
 }
 
@@ -98,7 +98,7 @@ fn should_promote_trait_method_desc() {
 fn should_promote_impl_method_desc() {
     let doc = test::mk_doc(
         ~"impl int { #[doc = \"desc\"] fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].brief == Some(~"desc"));
+    assert!(doc.cratemod().impls()[0].methods[0].brief == Some(~"desc"));
 }
 
 #[cfg(test)]
@@ -222,20 +222,20 @@ fn paragraphs(s: &str) -> ~[~str] {
 #[test]
 fn test_paragraphs_1() {
     let paras = paragraphs(~"1\n\n2");
-    fail_unless!(paras == ~[~"1", ~"2"]);
+    assert!(paras == ~[~"1", ~"2"]);
 }
 
 #[test]
 fn test_paragraphs_2() {
     let paras = paragraphs(~"\n\n1\n1\n\n2\n\n");
-    fail_unless!(paras == ~[~"1\n1", ~"2"]);
+    assert!(paras == ~[~"1\n1", ~"2"]);
 }
 
 #[test]
 fn should_promote_short_descs() {
     let desc = Some(~"desc");
     let brief = extract(copy desc);
-    fail_unless!(brief == desc);
+    assert!(brief == desc);
 }
 
 #[test]
@@ -249,7 +249,7 @@ Scotland in the mid 12th century, although it may have been built by
 King Henry II of England when he took control of England'snorthern
 counties.");
     let brief = extract(desc);
-    fail_unless!(brief == None);
+    assert!(brief == None);
 }
 
 #[test]
@@ -263,7 +263,7 @@ Scotland in the mid 12th century, although it may have been built by
 King Henry II of England when he took control of England'snorthern
 counties.");
     let brief = extract(desc);
-    fail_unless!(brief == Some(
+    assert!(brief == Some(
         ~"Warkworth Castle is a ruined medieval building in the town"));
 }
 
@@ -278,7 +278,7 @@ Scotland in the mid 12th century, although it may have been built by
 King Henry II of England when he took control of England'snorthern
 counties.");
     let brief = extract(desc);
-    fail_unless!(brief == Some(
+    assert!(brief == Some(
         ~"Warkworth..Castle is a ruined medieval building in the town"));
 }
 
@@ -293,6 +293,6 @@ Scotland in the mid 12th century, although it may have been built by
 King Henry II of England when he took control of England'snorthern
 counties.");
     let brief = extract(desc);
-    fail_unless!(brief == Some(
+    assert!(brief == Some(
         ~"Warkworth... Castle is a ruined medieval building in the town"));
 }
diff --git a/src/librustdoc/escape_pass.rs b/src/librustdoc/escape_pass.rs
index 1eb8c0e6eca..949573be05e 100644
--- a/src/librustdoc/escape_pass.rs
+++ b/src/librustdoc/escape_pass.rs
@@ -27,5 +27,5 @@ fn escape(s: &str) -> ~str {
 fn should_escape_backslashes() {
     let s = ~"\\n";
     let r = escape(s);
-    fail_unless!(r == ~"\\\\n");
+    assert!(r == ~"\\\\n");
 }
diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs
index 08a5928ac3d..1d6d569e1c2 100644
--- a/src/librustdoc/extract.rs
+++ b/src/librustdoc/extract.rs
@@ -185,8 +185,8 @@ fn constdoc_from_const(itemdoc: doc::ItemDoc) -> doc::ConstDoc {
 #[test]
 fn should_extract_const_name_and_id() {
     let doc = test::mk_doc(~"static a: int = 0;");
-    fail_unless!(doc.cratemod().consts()[0].id() != 0);
-    fail_unless!(doc.cratemod().consts()[0].name() == ~"a");
+    assert!(doc.cratemod().consts()[0].id() != 0);
+    assert!(doc.cratemod().consts()[0].name() == ~"a");
 }
 
 fn enumdoc_from_enum(
@@ -216,14 +216,14 @@ fn variantdoc_from_variant(variant: &ast::variant) -> doc::VariantDoc {
 #[test]
 fn should_extract_enums() {
     let doc = test::mk_doc(~"enum e { v }");
-    fail_unless!(doc.cratemod().enums()[0].id() != 0);
-    fail_unless!(doc.cratemod().enums()[0].name() == ~"e");
+    assert!(doc.cratemod().enums()[0].id() != 0);
+    assert!(doc.cratemod().enums()[0].name() == ~"e");
 }
 
 #[test]
 fn should_extract_enum_variants() {
     let doc = test::mk_doc(~"enum e { v }");
-    fail_unless!(doc.cratemod().enums()[0].variants[0].name == ~"v");
+    assert!(doc.cratemod().enums()[0].variants[0].name == ~"v");
 }
 
 fn traitdoc_from_trait(
@@ -262,13 +262,13 @@ fn traitdoc_from_trait(
 #[test]
 fn should_extract_traits() {
     let doc = test::mk_doc(~"trait i { fn f(); }");
-    fail_unless!(doc.cratemod().traits()[0].name() == ~"i");
+    assert!(doc.cratemod().traits()[0].name() == ~"i");
 }
 
 #[test]
 fn should_extract_trait_methods() {
     let doc = test::mk_doc(~"trait i { fn f(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].name == ~"f");
+    assert!(doc.cratemod().traits()[0].methods[0].name == ~"f");
 }
 
 fn impldoc_from_impl(
@@ -296,7 +296,7 @@ fn impldoc_from_impl(
 #[test]
 fn should_extract_impl_methods() {
     let doc = test::mk_doc(~"impl int { fn f() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].name == ~"f");
+    assert!(doc.cratemod().impls()[0].methods[0].name == ~"f");
 }
 
 fn tydoc_from_ty(
@@ -311,7 +311,7 @@ fn tydoc_from_ty(
 #[test]
 fn should_extract_tys() {
     let doc = test::mk_doc(~"type a = int;");
-    fail_unless!(doc.cratemod().types()[0].name() == ~"a");
+    assert!(doc.cratemod().types()[0].name() == ~"a");
 }
 
 fn structdoc_from_struct(
@@ -333,13 +333,13 @@ fn structdoc_from_struct(
 #[test]
 fn should_extract_structs() {
     let doc = test::mk_doc(~"struct Foo { field: () }");
-    fail_unless!(doc.cratemod().structs()[0].name() == ~"Foo");
+    assert!(doc.cratemod().structs()[0].name() == ~"Foo");
 }
 
 #[test]
 fn should_extract_struct_fields() {
     let doc = test::mk_doc(~"struct Foo { field: () }");
-    fail_unless!(doc.cratemod().structs()[0].fields[0] == ~"field");
+    assert!(doc.cratemod().structs()[0].fields[0] == ~"field");
 }
 
 #[cfg(test)]
@@ -359,35 +359,35 @@ mod test {
     #[test]
     pub fn extract_empty_crate() {
         let doc = mk_doc(~"");
-        fail_unless!(vec::is_empty(doc.cratemod().mods()));
-        fail_unless!(vec::is_empty(doc.cratemod().fns()));
+        assert!(vec::is_empty(doc.cratemod().mods()));
+        assert!(vec::is_empty(doc.cratemod().fns()));
     }
 
     #[test]
     pub fn extract_mods() {
         let doc = mk_doc(~"mod a { mod b { } mod c { } }");
-        fail_unless!(doc.cratemod().mods()[0].name() == ~"a");
-        fail_unless!(doc.cratemod().mods()[0].mods()[0].name() == ~"b");
-        fail_unless!(doc.cratemod().mods()[0].mods()[1].name() == ~"c");
+        assert!(doc.cratemod().mods()[0].name() == ~"a");
+        assert!(doc.cratemod().mods()[0].mods()[0].name() == ~"b");
+        assert!(doc.cratemod().mods()[0].mods()[1].name() == ~"c");
     }
 
     #[test]
     pub fn extract_fns_from_foreign_mods() {
         let doc = mk_doc(~"extern { fn a(); }");
-        fail_unless!(doc.cratemod().nmods()[0].fns[0].name() == ~"a");
+        assert!(doc.cratemod().nmods()[0].fns[0].name() == ~"a");
     }
 
     #[test]
     pub fn extract_mods_deep() {
         let doc = mk_doc(~"mod a { mod b { mod c { } } }");
-        fail_unless!(doc.cratemod().mods()[0].mods()[0].mods()[0].name() ==
+        assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].name() ==
             ~"c");
     }
 
     #[test]
     pub fn extract_should_set_mod_ast_id() {
         let doc = mk_doc(~"mod a { }");
-        fail_unless!(doc.cratemod().mods()[0].id() != 0);
+        assert!(doc.cratemod().mods()[0].id() != 0);
     }
 
     #[test]
@@ -396,14 +396,14 @@ mod test {
             ~"fn a() { } \
               mod b { fn c() {
              } }");
-        fail_unless!(doc.cratemod().fns()[0].name() == ~"a");
-        fail_unless!(doc.cratemod().mods()[0].fns()[0].name() == ~"c");
+        assert!(doc.cratemod().fns()[0].name() == ~"a");
+        assert!(doc.cratemod().mods()[0].fns()[0].name() == ~"c");
     }
 
     #[test]
     pub fn extract_should_set_fn_ast_id() {
         let doc = mk_doc(~"fn a() { }");
-        fail_unless!(doc.cratemod().fns()[0].id() != 0);
+        assert!(doc.cratemod().fns()[0].id() != 0);
     }
 
     #[test]
@@ -411,7 +411,7 @@ mod test {
         let source = ~"";
         let ast = parse::from_str(source);
         let doc = extract(ast, ~"burp");
-        fail_unless!(doc.cratemod().name() == ~"burp");
+        assert!(doc.cratemod().name() == ~"burp");
     }
 
     #[test]
@@ -419,7 +419,7 @@ mod test {
         let source = ~"";
         do astsrv::from_str(source) |srv| {
             let doc = from_srv(srv, ~"name");
-            fail_unless!(doc.cratemod().name() == ~"name");
+            assert!(doc.cratemod().name() == ~"name");
         }
     }
 }
diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index 2cd9ef3671d..d2f97b66bb6 100644
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -373,7 +373,7 @@ fn default_fold_should_produce_same_doc() {
     let doc = extract::extract(ast, ~"");
     let fld = default_seq_fold(());
     let folded = (fld.fold_doc)(&fld, copy doc);
-    fail_unless!(doc == folded);
+    assert!(doc == folded);
 }
 
 #[test]
@@ -383,7 +383,7 @@ fn default_fold_should_produce_same_consts() {
     let doc = extract::extract(ast, ~"");
     let fld = default_seq_fold(());
     let folded = (fld.fold_doc)(&fld, copy doc);
-    fail_unless!(doc == folded);
+    assert!(doc == folded);
 }
 
 #[test]
@@ -393,7 +393,7 @@ fn default_fold_should_produce_same_enums() {
     let doc = extract::extract(ast, ~"");
     let fld = default_seq_fold(());
     let folded = (fld.fold_doc)(&fld, copy doc);
-    fail_unless!(doc == folded);
+    assert!(doc == folded);
 }
 
 #[test]
@@ -403,5 +403,5 @@ fn default_parallel_fold_should_produce_same_doc() {
     let doc = extract::extract(ast, ~"");
     let fld = default_par_fold(());
     let folded = (fld.fold_doc)(&fld, copy doc);
-    fail_unless!(doc == folded);
+    assert!(doc == folded);
 }
diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs
index 4feeed84aa2..55901b4904a 100644
--- a/src/librustdoc/markdown_index_pass.rs
+++ b/src/librustdoc/markdown_index_pass.rs
@@ -164,27 +164,27 @@ fn pandoc_header_id(header: &str) -> ~str {
 
 #[test]
 fn should_remove_punctuation_from_headers() {
-    fail_unless!(pandoc_header_id(~"impl foo of bar<A>") ==
+    assert!(pandoc_header_id(~"impl foo of bar<A>") ==
         ~"impl-foo-of-bara");
-    fail_unless!(pandoc_header_id(~"impl of num::num for int")
+    assert!(pandoc_header_id(~"impl of num::num for int")
         == ~"impl-of-numnum-for-int");
-    fail_unless!(pandoc_header_id(~"impl of num::num for int/&")
+    assert!(pandoc_header_id(~"impl of num::num for int/&")
         == ~"impl-of-numnum-for-int");
-    fail_unless!(pandoc_header_id(~"impl of num::num for ^int")
+    assert!(pandoc_header_id(~"impl of num::num for ^int")
         == ~"impl-of-numnum-for-int");
-    fail_unless!(pandoc_header_id(~"impl for & condvar")
+    assert!(pandoc_header_id(~"impl for & condvar")
         == ~"impl-for-condvar");
-    fail_unless!(pandoc_header_id(~"impl of Select<T, U> for (Left, Right)")
+    assert!(pandoc_header_id(~"impl of Select<T, U> for (Left, Right)")
                  == ~"impl-of-selectt-u-for-left-right");
-    fail_unless!(pandoc_header_id(~"impl of Condition<'self, T, U>")
+    assert!(pandoc_header_id(~"impl of Condition<'self, T, U>")
                  == ~"impl-of-conditionself-t-u");
-    fail_unless!(pandoc_header_id(~"impl of Condition<T: Copy + Clone>")
+    assert!(pandoc_header_id(~"impl of Condition<T: Copy + Clone>")
                  == ~"impl-of-conditiont-copy-clone");
 }
 
 #[test]
 fn should_trim_whitespace_after_removing_punctuation() {
-    fail_unless!(pandoc_header_id("impl foo for ()") == ~"impl-foo-for");
+    assert!(pandoc_header_id("impl foo for ()") == ~"impl-foo-for");
 }
 
 #[test]
@@ -193,13 +193,13 @@ fn should_index_mod_contents() {
         config::DocPerCrate,
         ~"mod a { } fn b() { }"
     );
-    fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
+    assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
         kind: ~"Module",
         name: ~"a",
         brief: None,
         link: ~"#module-a"
     });
-    fail_unless!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry {
+    assert!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry {
         kind: ~"Function",
         name: ~"b",
         brief: None,
@@ -213,13 +213,13 @@ fn should_index_mod_contents_multi_page() {
         config::DocPerMod,
         ~"mod a { } fn b() { }"
     );
-    fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
+    assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
         kind: ~"Module",
         name: ~"a",
         brief: None,
         link: ~"a.html"
     });
-    fail_unless!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry {
+    assert!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry {
         kind: ~"Function",
         name: ~"b",
         brief: None,
@@ -233,7 +233,7 @@ fn should_index_foreign_mod_pages() {
         config::DocPerMod,
         ~"extern mod a { }"
     );
-    fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
+    assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry {
         kind: ~"Foreign module",
         name: ~"a",
         brief: None,
@@ -247,7 +247,7 @@ fn should_add_brief_desc_to_index() {
         config::DocPerMod,
         ~"#[doc = \"test\"] mod a { }"
     );
-    fail_unless!((&doc.cratemod().index).get().entries[0].brief
+    assert!((&doc.cratemod().index).get().entries[0].brief
         == Some(~"test"));
 }
 
@@ -257,7 +257,7 @@ fn should_index_foreign_mod_contents() {
         config::DocPerCrate,
         ~"extern mod a { fn b(); }"
     );
-    fail_unless!((&doc.cratemod().nmods()[0].index).get().entries[0]
+    assert!((&doc.cratemod().nmods()[0].index).get().entries[0]
         == doc::IndexEntry {
         kind: ~"Function",
         name: ~"b",
diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs
index 4b1b92221c0..8c4cd26bb7c 100644
--- a/src/librustdoc/markdown_pass.rs
+++ b/src/librustdoc/markdown_pass.rs
@@ -91,9 +91,9 @@ fn should_write_modules_last() {
     let idx_c = str::find_str(markdown, ~"# Module `c`").get();
     let idx_d = str::find_str(markdown, ~"## Function `d`").get();
 
-    fail_unless!(idx_b < idx_d);
-    fail_unless!(idx_d < idx_a);
-    fail_unless!(idx_a < idx_c);
+    assert!(idx_b < idx_d);
+    assert!(idx_d < idx_a);
+    assert!(idx_a < idx_c);
 }
 
 struct Ctxt {
@@ -175,10 +175,10 @@ fn should_write_title_for_each_page() {
         let (page, markdown) = po.recv();
         match page {
           doc::CratePage(_) => {
-            fail_unless!(str::contains(markdown, ~"% Crate core"));
+            assert!(str::contains(markdown, ~"% Crate core"));
           }
           doc::ItemPage(_) => {
-            fail_unless!(str::contains(markdown, ~"% Module a"));
+            assert!(str::contains(markdown, ~"% Module a"));
           }
         }
     }
@@ -248,7 +248,7 @@ pub fn header_name(doc: doc::ItemTag) -> ~str {
         fullpath
       }
       &doc::ImplTag(ref doc) => {
-        fail_unless!(doc.self_ty.is_some());
+        assert!(doc.self_ty.is_some());
           let bounds = if (&doc.bounds_str).is_some() {
               fmt!(" where %s", (&doc.bounds_str).get())
           } else {
@@ -326,7 +326,7 @@ fn write_mod(
 #[test]
 fn should_write_full_path_to_mod() {
     let markdown = test::render(~"mod a { mod b { mod c { } } }");
-    fail_unless!(str::contains(markdown, ~"# Module `a::b::c`"));
+    assert!(str::contains(markdown, ~"# Module `a::b::c`"));
 }
 
 fn write_common(
@@ -371,7 +371,7 @@ fn should_write_sections() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(str::contains(markdown, ~"#### Header\n\nBody\n\n"));
+    assert!(str::contains(markdown, ~"#### Header\n\nBody\n\n"));
 }
 
 fn write_mod_contents(
@@ -428,7 +428,7 @@ fn item_header_lvl(doc: &doc::ItemTag) -> Hlvl {
 #[test]
 fn should_write_crate_description() {
     let markdown = test::render(~"#[doc = \"this is the crate\"];");
-    fail_unless!(str::contains(markdown, ~"this is the crate"));
+    assert!(str::contains(markdown, ~"this is the crate"));
 }
 
 fn write_index(ctxt: &Ctxt, index: doc::Index) {
@@ -457,7 +457,7 @@ fn write_index(ctxt: &Ctxt, index: doc::Index) {
 #[test]
 fn should_write_index() {
     let markdown = test::render(~"mod a { } mod b { }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         markdown,
         ~"\n\n* [Module `a`](#module-a)\n\
          * [Module `b`](#module-b)\n\n"
@@ -467,19 +467,19 @@ fn should_write_index() {
 #[test]
 fn should_write_index_brief() {
     let markdown = test::render(~"#[doc = \"test\"] mod a { }");
-    fail_unless!(str::contains(markdown, ~"(#module-a) - test\n"));
+    assert!(str::contains(markdown, ~"(#module-a) - test\n"));
 }
 
 #[test]
 fn should_not_write_index_if_no_entries() {
     let markdown = test::render(~"");
-    fail_unless!(!str::contains(markdown, ~"\n\n\n"));
+    assert!(!str::contains(markdown, ~"\n\n\n"));
 }
 
 #[test]
 fn should_write_index_for_foreign_mods() {
     let markdown = test::render(~"extern mod a { fn a(); }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         markdown,
         ~"\n\n* [Function `a`](#function-a)\n\n"
     ));
@@ -500,22 +500,22 @@ fn write_nmod(ctxt: &Ctxt, doc: doc::NmodDoc) {
 #[test]
 fn should_write_foreign_mods() {
     let markdown = test::render(~"#[doc = \"test\"] extern mod a { }");
-    fail_unless!(str::contains(markdown, ~"Foreign module `a`"));
-    fail_unless!(str::contains(markdown, ~"test"));
+    assert!(str::contains(markdown, ~"Foreign module `a`"));
+    assert!(str::contains(markdown, ~"test"));
 }
 
 #[test]
 fn should_write_foreign_fns() {
     let markdown = test::render(
         ~"extern mod a { #[doc = \"test\"] fn a(); }");
-    fail_unless!(str::contains(markdown, ~"test"));
+    assert!(str::contains(markdown, ~"test"));
 }
 
 #[test]
 fn should_write_foreign_fn_headers() {
     let markdown = test::render(
         ~"extern mod a { #[doc = \"test\"] fn a(); }");
-    fail_unless!(str::contains(markdown, ~"## Function `a`"));
+    assert!(str::contains(markdown, ~"## Function `a`"));
 }
 
 fn write_fn(
@@ -561,19 +561,19 @@ fn code_block_indent(s: ~str) -> ~str {
 #[test]
 fn write_markdown_should_write_function_header() {
     let markdown = test::render(~"fn func() { }");
-    fail_unless!(str::contains(markdown, ~"## Function `func`"));
+    assert!(str::contains(markdown, ~"## Function `func`"));
 }
 
 #[test]
 fn should_write_the_function_signature() {
     let markdown = test::render(~"#[doc = \"f\"] fn a() { }");
-    fail_unless!(str::contains(markdown, ~"\n    fn a()\n"));
+    assert!(str::contains(markdown, ~"\n    fn a()\n"));
 }
 
 #[test]
 fn should_insert_blank_line_after_fn_signature() {
     let markdown = test::render(~"#[doc = \"f\"] fn a() { }");
-    fail_unless!(str::contains(markdown, ~"fn a()\n\n"));
+    assert!(str::contains(markdown, ~"fn a()\n\n"));
 }
 
 #[test]
@@ -594,13 +594,13 @@ fn should_correctly_indent_fn_signature() {
         ]
     };
     let markdown = test::write_markdown_str(doc);
-    fail_unless!(str::contains(markdown, ~"    line 1\n    line 2"));
+    assert!(str::contains(markdown, ~"    line 1\n    line 2"));
 }
 
 #[test]
 fn should_leave_blank_line_between_fn_header_and_sig() {
     let markdown = test::render(~"fn a() { }");
-    fail_unless!(str::contains(markdown, ~"Function `a`\n\n    fn a()"));
+    assert!(str::contains(markdown, ~"Function `a`\n\n    fn a()"));
 }
 
 fn write_const(
@@ -614,7 +614,7 @@ fn write_const(
 #[test]
 fn should_write_const_header() {
     let markdown = test::render(~"static a: bool = true;");
-    fail_unless!(str::contains(markdown, ~"## Const `a`\n\n"));
+    assert!(str::contains(markdown, ~"## Const `a`\n\n"));
 }
 
 #[test]
@@ -622,7 +622,7 @@ fn should_write_const_description() {
     let markdown = test::render(
         ~"#[doc = \"b\"]\
          static a: bool = true;");
-    fail_unless!(str::contains(markdown, ~"\n\nb\n\n"));
+    assert!(str::contains(markdown, ~"\n\nb\n\n"));
 }
 
 fn write_enum(
@@ -636,14 +636,14 @@ fn write_enum(
 #[test]
 fn should_write_enum_header() {
     let markdown = test::render(~"enum a { b }");
-    fail_unless!(str::contains(markdown, ~"## Enum `a`\n\n"));
+    assert!(str::contains(markdown, ~"## Enum `a`\n\n"));
 }
 
 #[test]
 fn should_write_enum_description() {
     let markdown = test::render(
         ~"#[doc = \"b\"] enum a { b }");
-    fail_unless!(str::contains(markdown, ~"\n\nb\n\n"));
+    assert!(str::contains(markdown, ~"\n\nb\n\n"));
 }
 
 fn write_variants(
@@ -664,7 +664,7 @@ fn write_variants(
 }
 
 fn write_variant(ctxt: &Ctxt, doc: doc::VariantDoc) {
-    fail_unless!(doc.sig.is_some());
+    assert!(doc.sig.is_some());
     let sig = (&doc.sig).get();
     match copy doc.desc {
       Some(desc) => {
@@ -682,7 +682,7 @@ fn should_write_variant_list() {
         ~"enum a { \
          #[doc = \"test\"] b, \
          #[doc = \"test\"] c }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         markdown,
         ~"\n\n#### Variants\n\
          \n* `b` - test\
@@ -692,7 +692,7 @@ fn should_write_variant_list() {
 #[test]
 fn should_write_variant_list_without_descs() {
     let markdown = test::render(~"enum a { b, c }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         markdown,
         ~"\n\n#### Variants\n\
          \n* `b`\
@@ -702,7 +702,7 @@ fn should_write_variant_list_without_descs() {
 #[test]
 fn should_write_variant_list_with_signatures() {
     let markdown = test::render(~"enum a { b(int), #[doc = \"a\"] c(int) }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         markdown,
         ~"\n\n#### Variants\n\
          \n* `b(int)`\
@@ -733,28 +733,28 @@ fn write_method(ctxt: &Ctxt, doc: doc::MethodDoc) {
 #[test]
 fn should_write_trait_header() {
     let markdown = test::render(~"trait i { fn a(); }");
-    fail_unless!(str::contains(markdown, ~"## Trait `i`"));
+    assert!(str::contains(markdown, ~"## Trait `i`"));
 }
 
 #[test]
 fn should_write_trait_desc() {
     let markdown = test::render(
         ~"#[doc = \"desc\"] trait i { fn a(); }");
-    fail_unless!(str::contains(markdown, ~"desc"));
+    assert!(str::contains(markdown, ~"desc"));
 }
 
 #[test]
 fn should_write_trait_method_header() {
     let markdown = test::render(
         ~"trait i { fn a(); }");
-    fail_unless!(str::contains(markdown, ~"### Method `a`"));
+    assert!(str::contains(markdown, ~"### Method `a`"));
 }
 
 #[test]
 fn should_write_trait_method_signature() {
     let markdown = test::render(
         ~"trait i { fn a(&self); }");
-    fail_unless!(str::contains(markdown, ~"\n    fn a(&self)"));
+    assert!(str::contains(markdown, ~"\n    fn a(&self)"));
 }
 
 fn write_impl(ctxt: &Ctxt, doc: doc::ImplDoc) {
@@ -765,19 +765,19 @@ fn write_impl(ctxt: &Ctxt, doc: doc::ImplDoc) {
 #[test]
 fn should_write_impl_header() {
     let markdown = test::render(~"impl int { fn a() { } }");
-    fail_unless!(str::contains(markdown, ~"## Implementation for `int`"));
+    assert!(str::contains(markdown, ~"## Implementation for `int`"));
 }
 
 #[test]
 fn should_write_impl_header_with_bounds() {
     let markdown = test::render(~"impl <T> int<T> { }");
-    fail_unless!(str::contains(markdown, ~"## Implementation for `int<T>` where `<T>`"));
+    assert!(str::contains(markdown, ~"## Implementation for `int<T>` where `<T>`"));
 }
 
 #[test]
 fn should_write_impl_header_with_trait() {
     let markdown = test::render(~"impl j for int { fn a() { } }");
-    fail_unless!(str::contains(markdown,
+    assert!(str::contains(markdown,
         ~"## Implementation of `j` for `int`"));
 }
 
@@ -785,21 +785,21 @@ fn should_write_impl_header_with_trait() {
 fn should_write_impl_desc() {
     let markdown = test::render(
         ~"#[doc = \"desc\"] impl int { fn a() { } }");
-    fail_unless!(str::contains(markdown, ~"desc"));
+    assert!(str::contains(markdown, ~"desc"));
 }
 
 #[test]
 fn should_write_impl_method_header() {
     let markdown = test::render(
         ~"impl int { fn a() { } }");
-    fail_unless!(str::contains(markdown, ~"### Method `a`"));
+    assert!(str::contains(markdown, ~"### Method `a`"));
 }
 
 #[test]
 fn should_write_impl_method_signature() {
     let markdown = test::render(
         ~"impl int { fn a(&mut self) { } }");
-    fail_unless!(str::contains(markdown, ~"\n    fn a(&mut self)"));
+    assert!(str::contains(markdown, ~"\n    fn a(&mut self)"));
 }
 
 fn write_type(
@@ -813,20 +813,20 @@ fn write_type(
 #[test]
 fn should_write_type_header() {
     let markdown = test::render(~"type t = int;");
-    fail_unless!(str::contains(markdown, ~"## Type `t`"));
+    assert!(str::contains(markdown, ~"## Type `t`"));
 }
 
 #[test]
 fn should_write_type_desc() {
     let markdown = test::render(
         ~"#[doc = \"desc\"] type t = int;");
-    fail_unless!(str::contains(markdown, ~"\n\ndesc\n\n"));
+    assert!(str::contains(markdown, ~"\n\ndesc\n\n"));
 }
 
 #[test]
 fn should_write_type_signature() {
     let markdown = test::render(~"type t = int;");
-    fail_unless!(str::contains(markdown, ~"\n\n    type t = int\n\n"));
+    assert!(str::contains(markdown, ~"\n\n    type t = int\n\n"));
 }
 
 fn put_struct(
@@ -840,7 +840,7 @@ fn put_struct(
 #[test]
 fn should_put_struct_header() {
     let markdown = test::render(~"struct S { field: () }");
-    fail_unless!(str::contains(markdown, ~"## Struct `S`\n\n"));
+    assert!(str::contains(markdown, ~"## Struct `S`\n\n"));
 }
 
 #[cfg(test)]
@@ -927,12 +927,12 @@ mod test {
     #[test]
     pub fn write_markdown_should_write_mod_headers() {
         let markdown = render(~"mod moo { }");
-        fail_unless!(str::contains(markdown, ~"# Module `moo`"));
+        assert!(str::contains(markdown, ~"# Module `moo`"));
     }
 
     #[test]
     pub fn should_leave_blank_line_after_header() {
         let markdown = render(~"mod morp { }");
-        fail_unless!(str::contains(markdown, ~"Module `morp`\n\n"));
+        assert!(str::contains(markdown, ~"Module `morp`\n\n"));
     }
 }
diff --git a/src/librustdoc/markdown_writer.rs b/src/librustdoc/markdown_writer.rs
index 4c68e632f83..2011649995e 100644
--- a/src/librustdoc/markdown_writer.rs
+++ b/src/librustdoc/markdown_writer.rs
@@ -92,7 +92,7 @@ fn pandoc_writer(
     config: config::Config,
     page: doc::Page
 ) -> Writer {
-    fail_unless!(config.pandoc_cmd.is_some());
+    assert!(config.pandoc_cmd.is_some());
     let pandoc_cmd = (&config.pandoc_cmd).get();
     let filename = make_local_filename(config, page);
 
@@ -201,7 +201,7 @@ pub fn make_filename(
                 config.output_style == config::DocPerMod {
                 ~"index"
             } else {
-                fail_unless!(doc.topmod.name() != ~"");
+                assert!(doc.topmod.name() != ~"");
                 doc.topmod.name()
             }
           }
@@ -229,7 +229,7 @@ fn should_use_markdown_file_name_based_off_crate() {
     let doc = test::mk_doc(~"test", ~"");
     let page = doc::CratePage(doc.CrateDoc());
     let filename = make_local_filename(config, page);
-    fail_unless!(filename.to_str() == ~"output/dir/test.md");
+    assert!(filename.to_str() == ~"output/dir/test.md");
 }
 
 #[test]
@@ -243,7 +243,7 @@ fn should_name_html_crate_file_name_index_html_when_doc_per_mod() {
     let doc = test::mk_doc(~"", ~"");
     let page = doc::CratePage(doc.CrateDoc());
     let filename = make_local_filename(config, page);
-    fail_unless!(filename.to_str() == ~"output/dir/index.html");
+    assert!(filename.to_str() == ~"output/dir/index.html");
 }
 
 #[test]
@@ -258,7 +258,7 @@ fn should_name_mod_file_names_by_path() {
     let modb = copy doc.cratemod().mods()[0].mods()[0];
     let page = doc::ItemPage(doc::ModTag(modb));
     let filename = make_local_filename(config, page);
-    fail_unless!(filename == Path("output/dir/a_b.html"));
+    assert!(filename == Path("output/dir/a_b.html"));
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/page_pass.rs b/src/librustdoc/page_pass.rs
index e1996409a76..55f17f5c150 100644
--- a/src/librustdoc/page_pass.rs
+++ b/src/librustdoc/page_pass.rs
@@ -155,19 +155,19 @@ fn should_not_split_the_doc_into_pages_for_doc_per_crate() {
         config::DocPerCrate,
         ~"mod a { } mod b { mod c { } }"
     );
-    fail_unless!(doc.pages.len() == 1u);
+    assert!(doc.pages.len() == 1u);
 }
 
 #[test]
 fn should_make_a_page_for_every_mod() {
     let doc = test::mk_doc(~"mod a { }");
-    fail_unless!(doc.pages.mods()[0].name() == ~"a");
+    assert!(doc.pages.mods()[0].name() == ~"a");
 }
 
 #[test]
 fn should_remove_mods_from_containing_mods() {
     let doc = test::mk_doc(~"mod a { }");
-    fail_unless!(vec::is_empty(doc.cratemod().mods()));
+    assert!(vec::is_empty(doc.cratemod().mods()));
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/pass.rs b/src/librustdoc/pass.rs
index e71b145d7df..52d6e8d9cd6 100644
--- a/src/librustdoc/pass.rs
+++ b/src/librustdoc/pass.rs
@@ -93,6 +93,6 @@ fn test_run_passes() {
         ];
         let doc = extract::from_srv(srv.clone(), ~"one");
         let doc = run_passes(srv, doc, passes);
-        fail_unless!(doc.cratemod().name() == ~"onetwothree");
+        assert!(doc.cratemod().name() == ~"onetwothree");
     }
 }
diff --git a/src/librustdoc/path_pass.rs b/src/librustdoc/path_pass.rs
index 58b25446dc1..dab60e0e0c0 100644
--- a/src/librustdoc/path_pass.rs
+++ b/src/librustdoc/path_pass.rs
@@ -98,9 +98,9 @@ fn should_record_mod_paths() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = run(srv.clone(), doc);
-        fail_unless!(doc.cratemod().mods()[0].mods()[0].mods()[0].path()
+        assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].path()
             == ~[~"a", ~"b"]);
-        fail_unless!(doc.cratemod().mods()[0].mods()[1].mods()[0].path()
+        assert!(doc.cratemod().mods()[0].mods()[1].mods()[0].path()
             == ~[~"a", ~"d"]);
     }
 }
@@ -111,7 +111,7 @@ fn should_record_fn_paths() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = run(srv.clone(), doc);
-        fail_unless!(doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]);
+        assert!(doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]);
     }
 }
 
diff --git a/src/librustdoc/prune_hidden_pass.rs b/src/librustdoc/prune_hidden_pass.rs
index 3c069e59e7a..f46d183ffcf 100644
--- a/src/librustdoc/prune_hidden_pass.rs
+++ b/src/librustdoc/prune_hidden_pass.rs
@@ -66,7 +66,7 @@ fn should_prune_hidden_items() {
     use core::vec;
 
     let doc = test::mk_doc(~"#[doc(hidden)] mod a { }");
-    fail_unless!(vec::is_empty(doc.cratemod().mods()))
+    assert!(vec::is_empty(doc.cratemod().mods()))
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/prune_private_pass.rs b/src/librustdoc/prune_private_pass.rs
index e6f21b5df54..a1f8fdb75d9 100644
--- a/src/librustdoc/prune_private_pass.rs
+++ b/src/librustdoc/prune_private_pass.rs
@@ -85,7 +85,7 @@ fn strip_priv_methods(
         let ast_method = do methods.find |m| {
             extract::to_str(m.ident) == method.name
         };
-        fail_unless!(ast_method.is_some());
+        assert!(ast_method.is_some());
         let ast_method = ast_method.unwrap();
         match ast_method.vis {
             ast::public => true,
@@ -157,7 +157,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool {
 #[test]
 fn should_prune_items_without_pub_modifier() {
     let doc = test::mk_doc(~"mod a { }");
-    fail_unless!(vec::is_empty(doc.cratemod().mods()));
+    assert!(vec::is_empty(doc.cratemod().mods()));
 }
 
 #[test]
@@ -168,7 +168,7 @@ fn should_not_prune_trait_impls() {
           trait Foo { } \
           impl Foo for int { } \
           ");
-    fail_unless!(!doc.cratemod().impls().is_empty());
+    assert!(!doc.cratemod().impls().is_empty());
 }
 
 #[test]
@@ -178,7 +178,7 @@ fn should_prune_associated_methods_without_vis_modifier_on_impls_without_vis_mod
           pub fn bar() { }\
           fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls()[0].methods.len() == 1);
+    assert!(doc.cratemod().impls()[0].methods.len() == 1);
 }
 
 #[test]
@@ -188,7 +188,7 @@ fn should_prune_priv_associated_methods_on_impls_without_vis_modifier() {
           pub fn bar() { }\
           priv fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls()[0].methods.len() == 1);
+    assert!(doc.cratemod().impls()[0].methods.len() == 1);
 }
 
 #[test]
@@ -198,7 +198,7 @@ fn should_prune_priv_associated_methods_on_pub_impls() {
           fn bar() { }\
           priv fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls()[0].methods.len() == 1);
+    assert!(doc.cratemod().impls()[0].methods.len() == 1);
 }
 
 #[test]
@@ -208,7 +208,7 @@ fn should_prune_associated_methods_without_vis_modifier_on_priv_impls() {
           pub fn bar() { }\
           fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls()[0].methods.len() == 1);
+    assert!(doc.cratemod().impls()[0].methods.len() == 1);
 }
 
 #[test]
@@ -218,7 +218,7 @@ fn should_prune_priv_associated_methods_on_priv_impls() {
           pub fn bar() { }\
           priv fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls()[0].methods.len() == 1);
+    assert!(doc.cratemod().impls()[0].methods.len() == 1);
 }
 
 #[test]
@@ -227,7 +227,7 @@ fn should_prune_associated_impls_with_no_pub_methods() {
         ~"priv impl Foo {\
           fn baz() { }\
           }");
-    fail_unless!(doc.cratemod().impls().is_empty());
+    assert!(doc.cratemod().impls().is_empty());
 }
 
 #[test]
@@ -236,7 +236,7 @@ fn should_not_prune_associated_impls_with_pub_methods() {
         ~" \
           impl Foo { pub fn bar() { } } \
           ");
-    fail_unless!(!doc.cratemod().impls().is_empty());
+    assert!(!doc.cratemod().impls().is_empty());
 }
 
 
diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs
index 33003a59611..788f84b06c2 100644
--- a/src/librustdoc/sectionalize_pass.rs
+++ b/src/librustdoc/sectionalize_pass.rs
@@ -168,7 +168,7 @@ fn should_create_section_headers() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         doc.cratemod().mods()[0].item.sections[0].header,
         ~"Header"));
 }
@@ -181,7 +181,7 @@ fn should_create_section_bodies() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(str::contains(
+    assert!(str::contains(
         doc.cratemod().mods()[0].item.sections[0].body,
         ~"Body"));
 }
@@ -194,7 +194,7 @@ fn should_not_create_sections_from_indented_headers() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(vec::is_empty(doc.cratemod().mods()[0].item.sections));
+    assert!(vec::is_empty(doc.cratemod().mods()[0].item.sections));
 }
 
 #[test]
@@ -206,10 +206,10 @@ fn should_remove_section_text_from_main_desc() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(!str::contains(
+    assert!(!str::contains(
         doc.cratemod().mods()[0].desc().get(),
         ~"Header"));
-    fail_unless!(!str::contains(
+    assert!(!str::contains(
         doc.cratemod().mods()[0].desc().get(),
         ~"Body"));
 }
@@ -222,7 +222,7 @@ fn should_eliminate_desc_if_it_is_just_whitespace() {
          Body\"]\
          mod a {
          }");
-    fail_unless!(doc.cratemod().mods()[0].desc() == None);
+    assert!(doc.cratemod().mods()[0].desc() == None);
 }
 
 #[test]
@@ -233,7 +233,7 @@ fn should_sectionalize_trait_methods() {
          # Header\n\
          Body\"]\
          fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].sections.len() == 1u);
+    assert!(doc.cratemod().traits()[0].methods[0].sections.len() == 1u);
 }
 
 #[test]
@@ -244,7 +244,7 @@ fn should_sectionalize_impl_methods() {
          # Header\n\
          Body\"]\
          fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].sections.len() == 1u);
+    assert!(doc.cratemod().impls()[0].methods[0].sections.len() == 1u);
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/sort_item_name_pass.rs b/src/librustdoc/sort_item_name_pass.rs
index b3fb874cdb2..86b2cc634fd 100644
--- a/src/librustdoc/sort_item_name_pass.rs
+++ b/src/librustdoc/sort_item_name_pass.rs
@@ -31,7 +31,7 @@ fn test() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = (mk_pass().f)(srv.clone(), doc);
-        fail_unless!(doc.cratemod().items[0].name() == ~"y");
-        fail_unless!(doc.cratemod().items[1].name() == ~"z");
+        assert!(doc.cratemod().items[0].name() == ~"y");
+        assert!(doc.cratemod().items[1].name() == ~"z");
     }
 }
diff --git a/src/librustdoc/sort_item_type_pass.rs b/src/librustdoc/sort_item_type_pass.rs
index 5919f1b0c2f..d75565d4ec8 100644
--- a/src/librustdoc/sort_item_type_pass.rs
+++ b/src/librustdoc/sort_item_type_pass.rs
@@ -55,14 +55,14 @@ fn test() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = (mk_pass().f)(srv.clone(), doc);
-        fail_unless!(doc.cratemod().items[0].name() == ~"iconst");
-        fail_unless!(doc.cratemod().items[1].name() == ~"itype");
-        fail_unless!(doc.cratemod().items[2].name() == ~"ienum");
-        fail_unless!(doc.cratemod().items[3].name() == ~"istruct");
-        fail_unless!(doc.cratemod().items[4].name() == ~"itrait");
-        fail_unless!(doc.cratemod().items[5].name() == ~"__extensions__");
-        fail_unless!(doc.cratemod().items[6].name() == ~"ifn");
-        fail_unless!(doc.cratemod().items[7].name() == ~"imod");
-        fail_unless!(doc.cratemod().items[8].name() == ~"inmod");
+        assert!(doc.cratemod().items[0].name() == ~"iconst");
+        assert!(doc.cratemod().items[1].name() == ~"itype");
+        assert!(doc.cratemod().items[2].name() == ~"ienum");
+        assert!(doc.cratemod().items[3].name() == ~"istruct");
+        assert!(doc.cratemod().items[4].name() == ~"itrait");
+        assert!(doc.cratemod().items[5].name() == ~"__extensions__");
+        assert!(doc.cratemod().items[6].name() == ~"ifn");
+        assert!(doc.cratemod().items[7].name() == ~"imod");
+        assert!(doc.cratemod().items[8].name() == ~"inmod");
     }
 }
diff --git a/src/librustdoc/sort_pass.rs b/src/librustdoc/sort_pass.rs
index e66eb3c0fae..dc7bc8b9df2 100644
--- a/src/librustdoc/sort_pass.rs
+++ b/src/librustdoc/sort_pass.rs
@@ -67,10 +67,10 @@ fn test() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = (mk_pass(~"", name_lteq).f)(srv.clone(), doc);
-        fail_unless!(doc.cratemod().mods()[0].name() == ~"w");
-        fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"x");
-        fail_unless!(doc.cratemod().mods()[1].items[1].name() == ~"y");
-        fail_unless!(doc.cratemod().mods()[1].name() == ~"z");
+        assert!(doc.cratemod().mods()[0].name() == ~"w");
+        assert!(doc.cratemod().mods()[1].items[0].name() == ~"x");
+        assert!(doc.cratemod().mods()[1].items[1].name() == ~"y");
+        assert!(doc.cratemod().mods()[1].name() == ~"z");
     }
 }
 
@@ -84,10 +84,10 @@ fn should_be_stable() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc);
-        fail_unless!(doc.cratemod().mods()[0].items[0].name() == ~"b");
-        fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"d");
+        assert!(doc.cratemod().mods()[0].items[0].name() == ~"b");
+        assert!(doc.cratemod().mods()[1].items[0].name() == ~"d");
         let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc);
-        fail_unless!(doc.cratemod().mods()[0].items[0].name() == ~"b");
-        fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"d");
+        assert!(doc.cratemod().mods()[0].items[0].name() == ~"b");
+        assert!(doc.cratemod().mods()[1].items[0].name() == ~"d");
     }
 }
diff --git a/src/librustdoc/text_pass.rs b/src/librustdoc/text_pass.rs
index 65e7228eeae..b5e9b452d14 100644
--- a/src/librustdoc/text_pass.rs
+++ b/src/librustdoc/text_pass.rs
@@ -140,89 +140,89 @@ fn fold_impl(
 #[test]
 fn should_execute_op_on_enum_brief() {
     let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }");
-    fail_unless!(doc.cratemod().enums()[0].brief() == Some(~"a"));
+    assert!(doc.cratemod().enums()[0].brief() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_enum_desc() {
     let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }");
-    fail_unless!(doc.cratemod().enums()[0].desc() == Some(~"a"));
+    assert!(doc.cratemod().enums()[0].desc() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_variant_desc() {
     let doc = test::mk_doc(~"enum a { #[doc = \" a \"] b }");
-    fail_unless!(doc.cratemod().enums()[0].variants[0].desc == Some(~"a"));
+    assert!(doc.cratemod().enums()[0].variants[0].desc == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_trait_brief() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] trait i { fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].brief() == Some(~"a"));
+    assert!(doc.cratemod().traits()[0].brief() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_trait_desc() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] trait i { fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].desc() == Some(~"a"));
+    assert!(doc.cratemod().traits()[0].desc() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_trait_method_brief() {
     let doc = test::mk_doc(
         ~"trait i { #[doc = \" a \"] fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].brief == Some(~"a"));
+    assert!(doc.cratemod().traits()[0].methods[0].brief == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_trait_method_desc() {
     let doc = test::mk_doc(
         ~"trait i { #[doc = \" a \"] fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].desc == Some(~"a"));
+    assert!(doc.cratemod().traits()[0].methods[0].desc == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_impl_brief() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] impl int { fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].brief() == Some(~"a"));
+    assert!(doc.cratemod().impls()[0].brief() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_impl_desc() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] impl int { fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].desc() == Some(~"a"));
+    assert!(doc.cratemod().impls()[0].desc() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_impl_method_brief() {
     let doc = test::mk_doc(
         ~"impl int { #[doc = \" a \"] fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].brief == Some(~"a"));
+    assert!(doc.cratemod().impls()[0].methods[0].brief == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_impl_method_desc() {
     let doc = test::mk_doc(
         ~"impl int { #[doc = \" a \"] fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].desc == Some(~"a"));
+    assert!(doc.cratemod().impls()[0].methods[0].desc == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_type_brief() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] type t = int;");
-    fail_unless!(doc.cratemod().types()[0].brief() == Some(~"a"));
+    assert!(doc.cratemod().types()[0].brief() == Some(~"a"));
 }
 
 #[test]
 fn should_execute_op_on_type_desc() {
     let doc = test::mk_doc(
         ~"#[doc = \" a \"] type t = int;");
-    fail_unless!(doc.cratemod().types()[0].desc() == Some(~"a"));
+    assert!(doc.cratemod().types()[0].desc() == Some(~"a"));
 }
 
 #[test]
@@ -232,7 +232,7 @@ fn should_execute_on_item_section_headers() {
          #    Header    \n\
          Body\"]\
          fn a() { }");
-    fail_unless!(doc.cratemod().fns()[0].sections()[0].header == ~"Header");
+    assert!(doc.cratemod().fns()[0].sections()[0].header == ~"Header");
 }
 
 #[test]
@@ -242,7 +242,7 @@ fn should_execute_on_item_section_bodies() {
          # Header\n\
          Body      \"]\
          fn a() { }");
-    fail_unless!(doc.cratemod().fns()[0].sections()[0].body == ~"Body");
+    assert!(doc.cratemod().fns()[0].sections()[0].body == ~"Body");
 }
 
 #[test]
@@ -253,7 +253,7 @@ fn should_execute_on_trait_method_section_headers() {
          # Header    \n\
          Body\"]\
          fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].sections[0].header
+    assert!(doc.cratemod().traits()[0].methods[0].sections[0].header
         == ~"Header");
 }
 
@@ -265,7 +265,7 @@ fn should_execute_on_trait_method_section_bodies() {
          # Header\n\
          Body     \"]\
          fn a(); }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].sections[0].body ==
+    assert!(doc.cratemod().traits()[0].methods[0].sections[0].body ==
         ~"Body");
 }
 
@@ -277,7 +277,7 @@ fn should_execute_on_impl_method_section_headers() {
          # Header   \n\
          Body\"]\
          fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].sections[0].header
+    assert!(doc.cratemod().impls()[0].methods[0].sections[0].header
         == ~"Header");
 }
 
@@ -289,7 +289,7 @@ fn should_execute_on_impl_method_section_bodies() {
          # Header\n\
          Body    \"]\
          fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].sections[0].body ==
+    assert!(doc.cratemod().impls()[0].methods[0].sections[0].body ==
         ~"Body");
 }
 
diff --git a/src/librustdoc/trim_pass.rs b/src/librustdoc/trim_pass.rs
index a1439e2e149..ca543a27189 100644
--- a/src/librustdoc/trim_pass.rs
+++ b/src/librustdoc/trim_pass.rs
@@ -29,7 +29,7 @@ fn should_trim_text() {
     let doc = test::mk_doc(~"#[doc = \" desc \"] \
                             mod m {
                             }");
-    fail_unless!(doc.cratemod().mods()[0].desc() == Some(~"desc"));
+    assert!(doc.cratemod().mods()[0].desc() == Some(~"desc"));
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index 229a0a3ff0f..293799d85b2 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -86,13 +86,13 @@ fn get_fn_sig(srv: astsrv::Srv, fn_id: doc::AstId) -> Option<~str> {
 #[test]
 fn should_add_fn_sig() {
     let doc = test::mk_doc(~"fn a<T>() -> int { }");
-    fail_unless!(doc.cratemod().fns()[0].sig == Some(~"fn a<T>() -> int"));
+    assert!(doc.cratemod().fns()[0].sig == Some(~"fn a<T>() -> int"));
 }
 
 #[test]
 fn should_add_foreign_fn_sig() {
     let doc = test::mk_doc(~"extern mod a { fn a<T>() -> int; }");
-    fail_unless!(doc.cratemod().nmods()[0].fns[0].sig ==
+    assert!(doc.cratemod().nmods()[0].fns[0].sig ==
         Some(~"fn a<T>() -> int"));
 }
 
@@ -122,7 +122,7 @@ fn fold_const(
 #[test]
 fn should_add_const_types() {
     let doc = test::mk_doc(~"static a: bool = true;");
-    fail_unless!(doc.cratemod().consts()[0].sig == Some(~"bool"));
+    assert!(doc.cratemod().consts()[0].sig == Some(~"bool"));
 }
 
 fn fold_enum(
@@ -166,7 +166,7 @@ fn fold_enum(
 #[test]
 fn should_add_variant_sigs() {
     let doc = test::mk_doc(~"enum a { b(int) }");
-    fail_unless!(doc.cratemod().enums()[0].variants[0].sig ==
+    assert!(doc.cratemod().enums()[0].variants[0].sig ==
         Some(~"b(int)"));
 }
 
@@ -263,7 +263,7 @@ fn get_method_sig(
 #[test]
 fn should_add_trait_method_sigs() {
     let doc = test::mk_doc(~"trait i { fn a<T>(&mut self) -> int; }");
-    fail_unless!(doc.cratemod().traits()[0].methods[0].sig
+    assert!(doc.cratemod().traits()[0].methods[0].sig
         == Some(~"fn a<T>(&mut self) -> int"));
 }
 
@@ -308,31 +308,31 @@ fn fold_impl(
 #[test]
 fn should_add_impl_bounds() {
     let doc = test::mk_doc(~"impl<T, U: Copy, V: Copy + Clone> Option<T, U, V> { }");
-    fail_unless!(doc.cratemod().impls()[0].bounds_str == Some(~"<T, U: Copy, V: Copy + Clone>"));
+    assert!(doc.cratemod().impls()[0].bounds_str == Some(~"<T, U: Copy, V: Copy + Clone>"));
 }
 
 #[test]
 fn should_add_impl_trait_types() {
     let doc = test::mk_doc(~"impl j for int { fn a<T>() { } }");
-    fail_unless!(doc.cratemod().impls()[0].trait_types[0] == ~"j");
+    assert!(doc.cratemod().impls()[0].trait_types[0] == ~"j");
 }
 
 #[test]
 fn should_not_add_impl_trait_types_if_none() {
     let doc = test::mk_doc(~"impl int { fn a() { } }");
-    fail_unless!(vec::len(doc.cratemod().impls()[0].trait_types) == 0);
+    assert!(vec::len(doc.cratemod().impls()[0].trait_types) == 0);
 }
 
 #[test]
 fn should_add_impl_self_ty() {
     let doc = test::mk_doc(~"impl int { fn a() { } }");
-    fail_unless!(doc.cratemod().impls()[0].self_ty == Some(~"int"));
+    assert!(doc.cratemod().impls()[0].self_ty == Some(~"int"));
 }
 
 #[test]
 fn should_add_impl_method_sigs() {
     let doc = test::mk_doc(~"impl int { fn a<T>(&self) -> int { fail!() } }");
-    fail_unless!(doc.cratemod().impls()[0].methods[0].sig
+    assert!(doc.cratemod().impls()[0].methods[0].sig
         == Some(~"fn a<T>(&self) -> int"));
 }
 
@@ -372,7 +372,7 @@ fn fold_type(
 #[test]
 fn should_add_type_signatures() {
     let doc = test::mk_doc(~"type t<T> = int;");
-    fail_unless!(doc.cratemod().types()[0].sig == Some(~"type t<T> = int"));
+    assert!(doc.cratemod().types()[0].sig == Some(~"type t<T> = int"));
 }
 
 fn fold_struct(
@@ -425,7 +425,7 @@ fn strip_struct_extra_stuff(item: @ast::item) -> @ast::item {
 #[test]
 fn should_add_struct_defs() {
     let doc = test::mk_doc(~"struct S { field: () }");
-    fail_unless!((&doc.cratemod().structs()[0].sig).get().contains(
+    assert!((&doc.cratemod().structs()[0].sig).get().contains(
         "struct S {"));
 }
 
@@ -433,14 +433,14 @@ fn should_add_struct_defs() {
 fn should_not_serialize_struct_drop_blocks() {
     // All we care about are the fields
     let doc = test::mk_doc(~"struct S { field: (), drop { } }");
-    fail_unless!(!(&doc.cratemod().structs()[0].sig).get().contains("drop"));
+    assert!(!(&doc.cratemod().structs()[0].sig).get().contains("drop"));
 }
 
 #[test]
 fn should_not_serialize_struct_attrs() {
     // All we care about are the fields
     let doc = test::mk_doc(~"#[wut] struct S { field: () }");
-    fail_unless!(!(&doc.cratemod().structs()[0].sig).get().contains("wut"));
+    assert!(!(&doc.cratemod().structs()[0].sig).get().contains("wut"));
 }
 
 #[cfg(test)]
diff --git a/src/librustdoc/unindent_pass.rs b/src/librustdoc/unindent_pass.rs
index 6207e2252e4..19877fea1fd 100644
--- a/src/librustdoc/unindent_pass.rs
+++ b/src/librustdoc/unindent_pass.rs
@@ -84,7 +84,7 @@ fn unindent(s: &str) -> ~str {
             if str::is_whitespace(*line) {
                 copy *line
             } else {
-                fail_unless!(str::len(*line) >= min_indent);
+                assert!(str::len(*line) >= min_indent);
                 str::slice(*line, min_indent, str::len(*line)).to_owned()
             }
         };
@@ -98,14 +98,14 @@ fn unindent(s: &str) -> ~str {
 fn should_unindent() {
     let s = ~"    line1\n    line2";
     let r = unindent(s);
-    fail_unless!(r == ~"line1\nline2");
+    assert!(r == ~"line1\nline2");
 }
 
 #[test]
 fn should_unindent_multiple_paragraphs() {
     let s = ~"    line1\n\n    line2";
     let r = unindent(s);
-    fail_unless!(r == ~"line1\n\nline2");
+    assert!(r == ~"line1\n\nline2");
 }
 
 #[test]
@@ -114,7 +114,7 @@ fn should_leave_multiple_indent_levels() {
     // base indentation and should be preserved
     let s = ~"    line1\n\n        line2";
     let r = unindent(s);
-    fail_unless!(r == ~"line1\n\n    line2");
+    assert!(r == ~"line1\n\n    line2");
 }
 
 #[test]
@@ -126,12 +126,12 @@ fn should_ignore_first_line_indent() {
     //          and continue here"]
     let s = ~"line1\n    line2";
     let r = unindent(s);
-    fail_unless!(r == ~"line1\nline2");
+    assert!(r == ~"line1\nline2");
 }
 
 #[test]
 fn should_not_ignore_first_line_indent_in_a_single_line_para() {
     let s = ~"line1\n\n    line2";
     let r = unindent(s);
-    fail_unless!(r == ~"line1\n\n    line2");
+    assert!(r == ~"line1\n\n    line2");
 }
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
index f9dc13f1989..cd64061af03 100644
--- a/src/librustpkg/util.rs
+++ b/src/librustpkg/util.rs
@@ -790,19 +790,19 @@ pub fn link_exe(src: &Path, dest: &Path) -> bool {
 
 #[test]
 fn test_is_cmd() {
-    fail_unless!(is_cmd(~"build"));
-    fail_unless!(is_cmd(~"clean"));
-    fail_unless!(is_cmd(~"do"));
-    fail_unless!(is_cmd(~"info"));
-    fail_unless!(is_cmd(~"install"));
-    fail_unless!(is_cmd(~"prefer"));
-    fail_unless!(is_cmd(~"test"));
-    fail_unless!(is_cmd(~"uninstall"));
-    fail_unless!(is_cmd(~"unprefer"));
+    assert!(is_cmd(~"build"));
+    assert!(is_cmd(~"clean"));
+    assert!(is_cmd(~"do"));
+    assert!(is_cmd(~"info"));
+    assert!(is_cmd(~"install"));
+    assert!(is_cmd(~"prefer"));
+    assert!(is_cmd(~"test"));
+    assert!(is_cmd(~"uninstall"));
+    assert!(is_cmd(~"unprefer"));
 }
 
 #[test]
 fn test_parse_name() {
-    fail_unless!(parse_name(~"org.mozilla.servo").get() == ~"servo");
-    fail_unless!(parse_name(~"org. mozilla.servo 2131").is_err());
+    assert!(parse_name(~"org.mozilla.servo").get() == ~"servo");
+    assert!(parse_name(~"org. mozilla.servo 2131").is_err());
 }
diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index 02c50cc7c98..ac8dd1a5d65 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -44,7 +44,7 @@ pub impl<'self> Condvar<'self> {
      */
     #[inline(always)]
     fn wait_on(&self, condvar_id: uint) {
-        fail_unless!(!*self.failed);
+        assert!(!*self.failed);
         self.cond.wait_on(condvar_id);
         // This is why we need to wrap sync::condvar.
         check_poison(self.is_mutex, *self.failed);
@@ -60,7 +60,7 @@ pub impl<'self> Condvar<'self> {
      */
     #[inline(always)]
     fn signal_on(&self, condvar_id: uint) -> bool {
-        fail_unless!(!*self.failed);
+        assert!(!*self.failed);
         self.cond.signal_on(condvar_id)
     }
 
@@ -74,7 +74,7 @@ pub impl<'self> Condvar<'self> {
      */
     #[inline(always)]
     fn broadcast_on(&self, condvar_id: uint) -> uint {
-        fail_unless!(!*self.failed);
+        assert!(!*self.failed);
         self.cond.broadcast_on(condvar_id)
     }
 }
@@ -230,7 +230,7 @@ struct PoisonOnFail {
 impl Drop for PoisonOnFail {
     fn finalize(&self) {
         unsafe {
-            /* fail_unless!(!*self.failed);
+            /* assert!(!*self.failed);
                -- might be false in case of cond.wait() */
             if task::failing() {
                 *self.failed = true;
@@ -392,7 +392,7 @@ pub impl<T:Const + Owned> RWARC<T> {
         // of this cast is removing the mutability.)
         let new_data = unsafe { cast::transmute_immut(data) };
         // Downgrade ensured the token belonged to us. Just a sanity check.
-        fail_unless!(ptr::ref_eq(&state.data, new_data));
+        assert!(ptr::ref_eq(&state.data, new_data));
         // Produce new token
         RWReadMode {
             data: new_data,
@@ -505,13 +505,13 @@ mod tests {
             let arc_v = p.recv();
 
             let v = *arc::get::<~[int]>(&arc_v);
-            fail_unless!(v[3] == 4);
+            assert!(v[3] == 4);
         };
 
         let c = p.recv();
         c.send(arc::clone(&arc_v));
 
-        fail_unless!((*arc::get(&arc_v))[2] == 3);
+        assert!((*arc::get(&arc_v))[2] == 3);
 
         info!(arc_v);
     }
@@ -532,7 +532,7 @@ mod tests {
         }
         do arc.access_cond |state, cond| {
             comm::send_one(c.take(), ());
-            fail_unless!(!*state);
+            assert!(!*state);
             while !*state {
                 cond.wait();
             }
@@ -549,7 +549,7 @@ mod tests {
             do arc2.access_cond |one, cond| {
                 cond.signal();
                 // Parent should fail when it wakes up.
-                fail_unless!(*one == 0);
+                assert!(*one == 0);
             }
         }
 
@@ -566,11 +566,11 @@ mod tests {
         let arc2 = ~arc.clone();
         do task::try || {
             do arc2.access |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do arc.access |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -579,11 +579,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.write |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do arc.read |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -592,11 +592,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.write |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do arc.write |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -606,12 +606,12 @@ mod tests {
         do task::try || {
             do arc2.write_downgrade |write_mode| {
                 do (&write_mode).write |one| {
-                    fail_unless!(*one == 2);
+                    assert!(*one == 2);
                 }
             }
         };
         do arc.write |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -620,11 +620,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.read |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do arc.read |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -633,11 +633,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.read |one| {
-                fail_unless!(*one == 2);
+                assert!(*one == 2);
             }
         };
         do arc.write |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -648,12 +648,12 @@ mod tests {
             do arc2.write_downgrade |write_mode| {
                 let read_mode = arc2.downgrade(write_mode);
                 do (&read_mode).read |one| {
-                    fail_unless!(*one == 2);
+                    assert!(*one == 2);
                 }
             }
         };
         do arc.write |one| {
-            fail_unless!(*one == 1);
+            assert!(*one == 1);
         }
     }
     #[test]
@@ -681,7 +681,7 @@ mod tests {
             do task::task().future_result(|+r| children.push(r)).spawn
                 || {
                 do arc3.read |num| {
-                    fail_unless!(*num >= 0);
+                    assert!(*num >= 0);
                 }
             }
         }
@@ -691,7 +691,7 @@ mod tests {
 
         // Wait for writer to finish
         p.recv();
-        do arc.read |num| { fail_unless!(*num == 10); }
+        do arc.read |num| { assert!(*num == 10); }
     }
     #[test]
     pub fn test_rw_downgrade() {
@@ -712,7 +712,7 @@ mod tests {
             do task::spawn || {
                 rp1.recv(); // wait for downgrader to give go-ahead
                 do arcn.read |state| {
-                    fail_unless!(*state == 31337);
+                    assert!(*state == 31337);
                     rc2.send(());
                 }
             }
@@ -724,7 +724,7 @@ mod tests {
         do task::spawn || {
             wp1.recv();
             do arc2.write_cond |state, cond| {
-                fail_unless!(*state == 0);
+                assert!(*state == 0);
                 *state = 42;
                 cond.signal();
             }
@@ -732,7 +732,7 @@ mod tests {
             do arc2.write |state| {
                 // This shouldn't happen until after the downgrade read
                 // section, and all other readers, finish.
-                fail_unless!(*state == 31337);
+                assert!(*state == 31337);
                 *state = 42;
             }
             wc2.send(());
@@ -745,7 +745,7 @@ mod tests {
                 while *state == 0 {
                     cond.wait();
                 }
-                fail_unless!(*state == 42);
+                assert!(*state == 42);
                 *state = 31337;
                 // send to other readers
                 for vec::each(reader_convos) |x| {
@@ -763,7 +763,7 @@ mod tests {
                     }
                 }
                 wc1.send(()); // tell writer to try again
-                fail_unless!(*state == 31337);
+                assert!(*state == 31337);
             }
         }
 
diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index d3452712728..0266f2d8631 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -159,23 +159,23 @@ mod tests {
 
     #[test]
     pub fn test_to_base64() {
-        fail_unless!((~"").to_base64()       == ~"");
-        fail_unless!((~"f").to_base64()      == ~"Zg==");
-        fail_unless!((~"fo").to_base64()     == ~"Zm8=");
-        fail_unless!((~"foo").to_base64()    == ~"Zm9v");
-        fail_unless!((~"foob").to_base64()   == ~"Zm9vYg==");
-        fail_unless!((~"fooba").to_base64()  == ~"Zm9vYmE=");
-        fail_unless!((~"foobar").to_base64() == ~"Zm9vYmFy");
+        assert!((~"").to_base64()       == ~"");
+        assert!((~"f").to_base64()      == ~"Zg==");
+        assert!((~"fo").to_base64()     == ~"Zm8=");
+        assert!((~"foo").to_base64()    == ~"Zm9v");
+        assert!((~"foob").to_base64()   == ~"Zm9vYg==");
+        assert!((~"fooba").to_base64()  == ~"Zm9vYmE=");
+        assert!((~"foobar").to_base64() == ~"Zm9vYmFy");
     }
 
     #[test]
     pub fn test_from_base64() {
-        fail_unless!((~"").from_base64() == str::to_bytes(~""));
-        fail_unless!((~"Zg==").from_base64() == str::to_bytes(~"f"));
-        fail_unless!((~"Zm8=").from_base64() == str::to_bytes(~"fo"));
-        fail_unless!((~"Zm9v").from_base64() == str::to_bytes(~"foo"));
-        fail_unless!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob"));
-        fail_unless!((~"Zm9vYmE=").from_base64() == str::to_bytes(~"fooba"));
-        fail_unless!((~"Zm9vYmFy").from_base64() == str::to_bytes(~"foobar"));
+        assert!((~"").from_base64() == str::to_bytes(~""));
+        assert!((~"Zg==").from_base64() == str::to_bytes(~"f"));
+        assert!((~"Zm8=").from_base64() == str::to_bytes(~"fo"));
+        assert!((~"Zm9v").from_base64() == str::to_bytes(~"foo"));
+        assert!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob"));
+        assert!((~"Zm9vYmE=").from_base64() == str::to_bytes(~"fooba"));
+        assert!((~"Zm9vYmFy").from_base64() == str::to_bytes(~"foobar"));
     }
 }
diff --git a/src/libstd/bigint.rs b/src/libstd/bigint.rs
index 9671112bec0..35b1a28a465 100644
--- a/src/libstd/bigint.rs
+++ b/src/libstd/bigint.rs
@@ -162,7 +162,7 @@ impl Sub<BigUint, BigUint> for BigUint {
             lo
         };
 
-        fail_unless!(borrow == 0);     // <=> fail_unless!((self >= other));
+        assert!(borrow == 0);     // <=> assert!((self >= other));
         return BigUint::new(diff);
     }
 }
@@ -351,7 +351,7 @@ pub impl BigUint {
             n <<= 1;
             shift += 1;
         }
-        fail_unless!(shift < BigDigit::bits);
+        assert!(shift < BigDigit::bits);
         let (d, m) = divmod_inner(self << shift, other << shift);
         return (d, m >> shift);
 
@@ -390,7 +390,7 @@ pub impl BigUint {
             for an.each_reverse |elt| {
                 let ai = BigDigit::to_uint(carry, *elt);
                 let di = ai / (bn as uint);
-                fail_unless!(di < BigDigit::base);
+                assert!(di < BigDigit::base);
                 carry = (ai % (bn as uint)) as BigDigit;
                 d = ~[di as BigDigit] + d;
             }
@@ -434,7 +434,7 @@ pub impl BigUint {
     }
 
     fn to_str_radix(&self, radix: uint) -> ~str {
-        fail_unless!(1 < radix && radix <= 16);
+        assert!(1 < radix && radix <= 16);
         let (base, max_len) = get_radix_base(radix);
         if base == BigDigit::base {
             return fill_concat(self.data, radix, max_len)
@@ -510,7 +510,7 @@ pub impl BigUint {
 
 #[cfg(target_arch = "x86_64")]
 priv fn get_radix_base(radix: uint) -> (uint, uint) {
-    fail_unless!(1 < radix && radix <= 16);
+    assert!(1 < radix && radix <= 16);
     match radix {
         2  => (4294967296, 32),
         3  => (3486784401, 20),
@@ -535,7 +535,7 @@ priv fn get_radix_base(radix: uint) -> (uint, uint) {
 #[cfg(target_arch = "x86")]
 #[cfg(target_arch = "mips")]
 priv fn get_radix_base(radix: uint) -> (uint, uint) {
-    fail_unless!(1 < radix && radix <= 16);
+    assert!(1 < radix && radix <= 16);
     match radix {
         2  => (65536, 16),
         3  => (59049, 10),
@@ -784,7 +784,7 @@ pub impl BigInt {
         if ss < os { return -1; }
         if ss > os { return  1; }
 
-        fail_unless!(ss == os);
+        assert!(ss == os);
         match ss {
             Zero  => 0,
             Plus  => self.data.cmp(&other.data),
@@ -871,7 +871,7 @@ mod biguint_tests {
     #[test]
     fn test_from_slice() {
         fn check(slice: &[BigDigit], data: &[BigDigit]) {
-            fail_unless!(data == BigUint::from_slice(slice).data);
+            assert!(data == BigUint::from_slice(slice).data);
         }
         check(~[1], ~[1]);
         check(~[0, 0, 0], ~[]);
@@ -889,30 +889,30 @@ mod biguint_tests {
             for vec::slice(data, i, data.len()).eachi |j0, nj| {
                 let j = j0 + i;
                 if i == j {
-                    fail_unless!(ni.cmp(nj) == 0);
-                    fail_unless!(nj.cmp(ni) == 0);
-                    fail_unless!(ni == nj);
-                    fail_unless!(!(ni != nj));
-                    fail_unless!(ni <= nj);
-                    fail_unless!(ni >= nj);
-                    fail_unless!(!(ni < nj));
-                    fail_unless!(!(ni > nj));
+                    assert!(ni.cmp(nj) == 0);
+                    assert!(nj.cmp(ni) == 0);
+                    assert!(ni == nj);
+                    assert!(!(ni != nj));
+                    assert!(ni <= nj);
+                    assert!(ni >= nj);
+                    assert!(!(ni < nj));
+                    assert!(!(ni > nj));
                 } else {
-                    fail_unless!(ni.cmp(nj) < 0);
-                    fail_unless!(nj.cmp(ni) > 0);
+                    assert!(ni.cmp(nj) < 0);
+                    assert!(nj.cmp(ni) > 0);
 
-                    fail_unless!(!(ni == nj));
-                    fail_unless!(ni != nj);
+                    assert!(!(ni == nj));
+                    assert!(ni != nj);
 
-                    fail_unless!(ni <= nj);
-                    fail_unless!(!(ni >= nj));
-                    fail_unless!(ni < nj);
-                    fail_unless!(!(ni > nj));
+                    assert!(ni <= nj);
+                    assert!(!(ni >= nj));
+                    assert!(ni < nj);
+                    assert!(!(ni > nj));
 
-                    fail_unless!(!(nj <= ni));
-                    fail_unless!(nj >= ni);
-                    fail_unless!(!(nj < ni));
-                    fail_unless!(nj > ni);
+                    assert!(!(nj <= ni));
+                    assert!(nj >= ni);
+                    assert!(!(nj < ni));
+                    assert!(nj > ni);
                 }
             }
         }
@@ -921,7 +921,7 @@ mod biguint_tests {
     #[test]
     fn test_shl() {
         fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) {
-            fail_unless!(BigUint::new(v) << shift == BigUint::new(ans));
+            assert!(BigUint::new(v) << shift == BigUint::new(ans));
         }
 
         check(~[], 3, ~[]);
@@ -966,7 +966,7 @@ mod biguint_tests {
     #[ignore(cfg(target_arch = "mips"))]
     fn test_shr() {
         fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) {
-            fail_unless!(BigUint::new(v) >> shift == BigUint::new(ans));
+            assert!(BigUint::new(v) >> shift == BigUint::new(ans));
         }
 
         check(~[], 3, ~[]);
@@ -1008,8 +1008,8 @@ mod biguint_tests {
     fn test_convert_int() {
         fn check(v: ~[BigDigit], i: int) {
             let b = BigUint::new(v);
-            fail_unless!(b == IntConvertible::from_int(i));
-            fail_unless!(b.to_int() == i);
+            assert!(b == IntConvertible::from_int(i));
+            assert!(b.to_int() == i);
         }
 
         check(~[], 0);
@@ -1018,17 +1018,17 @@ mod biguint_tests {
         check(~[ 0,  1], ((uint::max_value >> BigDigit::bits) + 1) as int);
         check(~[-1, -1 >> 1], int::max_value);
 
-        fail_unless!(BigUint::new(~[0, -1]).to_int() == int::max_value);
-        fail_unless!(BigUint::new(~[0, 0, 1]).to_int() == int::max_value);
-        fail_unless!(BigUint::new(~[0, 0, -1]).to_int() == int::max_value);
+        assert!(BigUint::new(~[0, -1]).to_int() == int::max_value);
+        assert!(BigUint::new(~[0, 0, 1]).to_int() == int::max_value);
+        assert!(BigUint::new(~[0, 0, -1]).to_int() == int::max_value);
     }
 
     #[test]
     fn test_convert_uint() {
         fn check(v: ~[BigDigit], u: uint) {
             let b = BigUint::new(v);
-            fail_unless!(b == BigUint::from_uint(u));
-            fail_unless!(b.to_uint() == u);
+            assert!(b == BigUint::from_uint(u));
+            assert!(b.to_uint() == u);
         }
 
         check(~[], 0);
@@ -1038,8 +1038,8 @@ mod biguint_tests {
         check(~[ 0, -1], uint::max_value << BigDigit::bits);
         check(~[-1, -1], uint::max_value);
 
-        fail_unless!(BigUint::new(~[0, 0, 1]).to_uint()  == uint::max_value);
-        fail_unless!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value);
+        assert!(BigUint::new(~[0, 0, 1]).to_uint()  == uint::max_value);
+        assert!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value);
     }
 
     static sum_triples: &'static [(&'static [BigDigit],
@@ -1064,8 +1064,8 @@ mod biguint_tests {
             let b = BigUint::from_slice(bVec);
             let c = BigUint::from_slice(cVec);
 
-            fail_unless!(a + b == c);
-            fail_unless!(b + a == c);
+            assert!(a + b == c);
+            assert!(b + a == c);
         }
     }
 
@@ -1077,8 +1077,8 @@ mod biguint_tests {
             let b = BigUint::from_slice(bVec);
             let c = BigUint::from_slice(cVec);
 
-            fail_unless!(c - a == b);
-            fail_unless!(c - b == a);
+            assert!(c - a == b);
+            assert!(c - b == a);
         }
     }
 
@@ -1128,8 +1128,8 @@ mod biguint_tests {
             let b = BigUint::from_slice(bVec);
             let c = BigUint::from_slice(cVec);
 
-            fail_unless!(a * b == c);
-            fail_unless!(b * a == c);
+            assert!(a * b == c);
+            assert!(b * a == c);
         }
 
         for divmod_quadruples.each |elm| {
@@ -1139,8 +1139,8 @@ mod biguint_tests {
             let c = BigUint::from_slice(cVec);
             let d = BigUint::from_slice(dVec);
 
-            fail_unless!(a == b * c + d);
-            fail_unless!(a == c * b + d);
+            assert!(a == b * c + d);
+            assert!(a == c * b + d);
         }
     }
 
@@ -1153,10 +1153,10 @@ mod biguint_tests {
             let c = BigUint::from_slice(cVec);
 
             if a.is_not_zero() {
-                fail_unless!(c.divmod(&a) == (b, Zero::zero()));
+                assert!(c.divmod(&a) == (b, Zero::zero()));
             }
             if b.is_not_zero() {
-                fail_unless!(c.divmod(&b) == (a, Zero::zero()));
+                assert!(c.divmod(&b) == (a, Zero::zero()));
             }
         }
 
@@ -1167,7 +1167,7 @@ mod biguint_tests {
             let c = BigUint::from_slice(cVec);
             let d = BigUint::from_slice(dVec);
 
-            if b.is_not_zero() { fail_unless!(a.divmod(&b) == (c, d)); }
+            if b.is_not_zero() { assert!(a.divmod(&b) == (c, d)); }
         }
     }
 
@@ -1234,7 +1234,7 @@ mod biguint_tests {
             let &(n, rs) = num_pair;
             for rs.each |str_pair| {
                 let &(radix, str) = str_pair;
-                fail_unless!(n.to_str_radix(radix) == str);
+                assert!(n.to_str_radix(radix) == str);
             }
         }
     }
@@ -1245,13 +1245,13 @@ mod biguint_tests {
             let &(n, rs) = num_pair;
             for rs.each |str_pair| {
                 let &(radix, str) = str_pair;
-                fail_unless!(Some(n) == BigUint::from_str_radix(str, radix));
+                assert!(Some(n) == BigUint::from_str_radix(str, radix));
             }
         }
 
-        fail_unless!(BigUint::from_str_radix(~"Z", 10) == None);
-        fail_unless!(BigUint::from_str_radix(~"_", 2) == None);
-        fail_unless!(BigUint::from_str_radix(~"-1", 10) == None);
+        assert!(BigUint::from_str_radix(~"Z", 10) == None);
+        assert!(BigUint::from_str_radix(~"_", 2) == None);
+        assert!(BigUint::from_str_radix(~"-1", 10) == None);
     }
 
     #[test]
@@ -1269,7 +1269,7 @@ mod biguint_tests {
             let ans = match BigUint::from_str_radix(s, 10) {
                 Some(x) => x, None => fail!()
             };
-            fail_unless!(n == ans);
+            assert!(n == ans);
         }
 
         check(3, "6");
@@ -1291,7 +1291,7 @@ mod bigint_tests {
         fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) {
             let inp = BigInt::from_biguint(inp_s, BigUint::from_uint(inp_n));
             let ans = BigInt { sign: ans_s, data: BigUint::from_uint(ans_n)};
-            fail_unless!(inp == ans);
+            assert!(inp == ans);
         }
         check(Plus, 1, Plus, 1);
         check(Plus, 0, Zero, 0);
@@ -1311,30 +1311,30 @@ mod bigint_tests {
             for vec::slice(nums, i, nums.len()).eachi |j0, nj| {
                 let j = i + j0;
                 if i == j {
-                    fail_unless!(ni.cmp(nj) == 0);
-                    fail_unless!(nj.cmp(ni) == 0);
-                    fail_unless!(ni == nj);
-                    fail_unless!(!(ni != nj));
-                    fail_unless!(ni <= nj);
-                    fail_unless!(ni >= nj);
-                    fail_unless!(!(ni < nj));
-                    fail_unless!(!(ni > nj));
+                    assert!(ni.cmp(nj) == 0);
+                    assert!(nj.cmp(ni) == 0);
+                    assert!(ni == nj);
+                    assert!(!(ni != nj));
+                    assert!(ni <= nj);
+                    assert!(ni >= nj);
+                    assert!(!(ni < nj));
+                    assert!(!(ni > nj));
                 } else {
-                    fail_unless!(ni.cmp(nj) < 0);
-                    fail_unless!(nj.cmp(ni) > 0);
+                    assert!(ni.cmp(nj) < 0);
+                    assert!(nj.cmp(ni) > 0);
 
-                    fail_unless!(!(ni == nj));
-                    fail_unless!(ni != nj);
+                    assert!(!(ni == nj));
+                    assert!(ni != nj);
 
-                    fail_unless!(ni <= nj);
-                    fail_unless!(!(ni >= nj));
-                    fail_unless!(ni < nj);
-                    fail_unless!(!(ni > nj));
+                    assert!(ni <= nj);
+                    assert!(!(ni >= nj));
+                    assert!(ni < nj);
+                    assert!(!(ni > nj));
 
-                    fail_unless!(!(nj <= ni));
-                    fail_unless!(nj >= ni);
-                    fail_unless!(!(nj < ni));
-                    fail_unless!(nj > ni);
+                    assert!(!(nj <= ni));
+                    assert!(nj >= ni);
+                    assert!(!(nj < ni));
+                    assert!(nj > ni);
                 }
             }
         }
@@ -1343,8 +1343,8 @@ mod bigint_tests {
     #[test]
     fn test_convert_int() {
         fn check(b: BigInt, i: int) {
-            fail_unless!(b == IntConvertible::from_int(i));
-            fail_unless!(b.to_int() == i);
+            assert!(b == IntConvertible::from_int(i));
+            assert!(b.to_int() == i);
         }
 
         check(Zero::zero(), 0);
@@ -1353,20 +1353,20 @@ mod bigint_tests {
             Plus, BigUint::from_uint(int::max_value as uint)
         ), int::max_value);
 
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Plus, BigUint::from_uint(int::max_value as uint + 1)
         ).to_int() == int::max_value);
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Plus, BigUint::new(~[1, 2, 3])
         ).to_int() == int::max_value);
 
         check(BigInt::from_biguint(
             Minus, BigUint::from_uint(-int::min_value as uint)
         ), int::min_value);
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Minus, BigUint::from_uint(-int::min_value as uint + 1)
         ).to_int() == int::min_value);
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Minus, BigUint::new(~[1, 2, 3])
         ).to_int() == int::min_value);
     }
@@ -1374,8 +1374,8 @@ mod bigint_tests {
     #[test]
     fn test_convert_uint() {
         fn check(b: BigInt, u: uint) {
-            fail_unless!(b == BigInt::from_uint(u));
-            fail_unless!(b.to_uint() == u);
+            assert!(b == BigInt::from_uint(u));
+            assert!(b.to_uint() == u);
         }
 
         check(Zero::zero(), 0);
@@ -1384,14 +1384,14 @@ mod bigint_tests {
         check(
             BigInt::from_biguint(Plus, BigUint::from_uint(uint::max_value)),
             uint::max_value);
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Plus, BigUint::new(~[1, 2, 3])
         ).to_uint() == uint::max_value);
 
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Minus, BigUint::from_uint(uint::max_value)
         ).to_uint() == 0);
-        fail_unless!(BigInt::from_biguint(
+        assert!(BigInt::from_biguint(
             Minus, BigUint::new(~[1, 2, 3])
         ).to_uint() == 0);
     }
@@ -1418,14 +1418,14 @@ mod bigint_tests {
             let b = BigInt::from_slice(Plus, bVec);
             let c = BigInt::from_slice(Plus, cVec);
 
-            fail_unless!(a + b == c);
-            fail_unless!(b + a == c);
-            fail_unless!(c + (-a) == b);
-            fail_unless!(c + (-b) == a);
-            fail_unless!(a + (-c) == (-b));
-            fail_unless!(b + (-c) == (-a));
-            fail_unless!((-a) + (-b) == (-c));
-            fail_unless!(a + (-a) == Zero::zero());
+            assert!(a + b == c);
+            assert!(b + a == c);
+            assert!(c + (-a) == b);
+            assert!(c + (-b) == a);
+            assert!(a + (-c) == (-b));
+            assert!(b + (-c) == (-a));
+            assert!((-a) + (-b) == (-c));
+            assert!(a + (-a) == Zero::zero());
         }
     }
 
@@ -1437,14 +1437,14 @@ mod bigint_tests {
             let b = BigInt::from_slice(Plus, bVec);
             let c = BigInt::from_slice(Plus, cVec);
 
-            fail_unless!(c - a == b);
-            fail_unless!(c - b == a);
-            fail_unless!((-b) - a == (-c));
-            fail_unless!((-a) - b == (-c));
-            fail_unless!(b - (-a) == c);
-            fail_unless!(a - (-b) == c);
-            fail_unless!((-c) - (-a) == (-b));
-            fail_unless!(a - a == Zero::zero());
+            assert!(c - a == b);
+            assert!(c - b == a);
+            assert!((-b) - a == (-c));
+            assert!((-a) - b == (-c));
+            assert!(b - (-a) == c);
+            assert!(a - (-b) == c);
+            assert!((-c) - (-a) == (-b));
+            assert!(a - a == Zero::zero());
         }
     }
 
@@ -1494,11 +1494,11 @@ mod bigint_tests {
             let b = BigInt::from_slice(Plus, bVec);
             let c = BigInt::from_slice(Plus, cVec);
 
-            fail_unless!(a * b == c);
-            fail_unless!(b * a == c);
+            assert!(a * b == c);
+            assert!(b * a == c);
 
-            fail_unless!((-a) * b == -c);
-            fail_unless!((-b) * a == -c);
+            assert!((-a) * b == -c);
+            assert!((-b) * a == -c);
         }
 
         for divmod_quadruples.each |elm| {
@@ -1508,8 +1508,8 @@ mod bigint_tests {
             let c = BigInt::from_slice(Plus, cVec);
             let d = BigInt::from_slice(Plus, dVec);
 
-            fail_unless!(a == b * c + d);
-            fail_unless!(a == c * b + d);
+            assert!(a == b * c + d);
+            assert!(a == c * b + d);
         }
     }
 
@@ -1518,12 +1518,12 @@ mod bigint_tests {
         fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) {
             let (d, m) = a.divmod(b);
             if m.is_not_zero() {
-                fail_unless!(m.sign == b.sign);
+                assert!(m.sign == b.sign);
             }
-            fail_unless!(m.abs() <= b.abs());
-            fail_unless!(*a == b * d + m);
-            fail_unless!(d == *ans_d);
-            fail_unless!(m == *ans_m);
+            assert!(m.abs() <= b.abs());
+            assert!(*a == b * d + m);
+            assert!(d == *ans_d);
+            assert!(m == *ans_m);
         }
 
         fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
@@ -1569,12 +1569,12 @@ mod bigint_tests {
         fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) {
             let (q, r) = a.quotrem(b);
             if r.is_not_zero() {
-                fail_unless!(r.sign == a.sign);
+                assert!(r.sign == a.sign);
             }
-            fail_unless!(r.abs() <= b.abs());
-            fail_unless!(*a == b * q + r);
-            fail_unless!(q == *ans_q);
-            fail_unless!(r == *ans_r);
+            assert!(r.abs() <= b.abs());
+            assert!(*a == b * q + r);
+            assert!(q == *ans_q);
+            assert!(r == *ans_r);
         }
 
         fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
@@ -1609,7 +1609,7 @@ mod bigint_tests {
     #[test]
     fn test_to_str_radix() {
         fn check(n: int, ans: &str) {
-            fail_unless!(ans == IntConvertible::from_int::<BigInt>(
+            assert!(ans == IntConvertible::from_int::<BigInt>(
                 n).to_str_radix(10));
         }
         check(10, "10");
@@ -1624,7 +1624,7 @@ mod bigint_tests {
     fn test_from_str_radix() {
         fn check(s: &str, ans: Option<int>) {
             let ans = ans.map(|&n| IntConvertible::from_int(n));
-            fail_unless!(BigInt::from_str_radix(s, 10) == ans);
+            assert!(BigInt::from_str_radix(s, 10) == ans);
         }
         check("10", Some(10));
         check("1", Some(1));
@@ -1637,11 +1637,11 @@ mod bigint_tests {
 
     #[test]
     fn test_neg() {
-        fail_unless!(-BigInt::new(Plus,  ~[1, 1, 1]) ==
+        assert!(-BigInt::new(Plus,  ~[1, 1, 1]) ==
             BigInt::new(Minus, ~[1, 1, 1]));
-        fail_unless!(-BigInt::new(Minus, ~[1, 1, 1]) ==
+        assert!(-BigInt::new(Minus, ~[1, 1, 1]) ==
             BigInt::new(Plus,  ~[1, 1, 1]));
-        fail_unless!(-Zero::zero::<BigInt>() == Zero::zero::<BigInt>());
+        assert!(-Zero::zero::<BigInt>() == Zero::zero::<BigInt>());
     }
 }
 
diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 8bac0fed3c9..f69e2130e71 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -132,7 +132,7 @@ pub impl BigBitv {
     fn process(&mut self, b: &BigBitv, nbits: uint,
                op: &fn(uint, uint) -> uint) -> bool {
         let len = b.storage.len();
-        fail_unless!((self.storage.len() == len));
+        assert!((self.storage.len() == len));
         let mut changed = false;
         for uint::range(0, len) |i| {
             let mask = big_mask(nbits, i);
@@ -300,7 +300,7 @@ pub impl Bitv {
     /// Retrieve the value at index `i`
     #[inline(always)]
     fn get(&self, i: uint) -> bool {
-       fail_unless!((i < self.nbits));
+       assert!((i < self.nbits));
        match self.rep {
          Big(ref b)   => b.get(i),
          Small(ref s) => s.get(i)
@@ -314,7 +314,7 @@ pub impl Bitv {
      */
     #[inline(always)]
     fn set(&mut self, i: uint, x: bool) {
-      fail_unless!((i < self.nbits));
+      assert!((i < self.nbits));
       match self.rep {
         Big(ref mut b)   => b.set(i, x),
         Small(ref mut s) => s.set(i, x)
@@ -484,7 +484,7 @@ pub impl Bitv {
      * the bitvector and vector must have the same length
      */
     fn eq_vec(&self, v: ~[uint]) -> bool {
-        fail_unless!(self.nbits == v.len());
+        assert!(self.nbits == v.len());
         let mut i = 0;
         while i < self.nbits {
             let w0 = self.get(i);
@@ -725,7 +725,7 @@ impl Set<uint> for BitvSet {
         let nbits = self.capacity();
         if value >= nbits {
             let newsize = uint::max(value, nbits * 2) / uint::bits + 1;
-            fail_unless!(newsize > self.bitv.storage.len());
+            assert!(newsize > self.bitv.storage.len());
             self.bitv.storage.grow(newsize, &0);
         }
         self.size += 1;
@@ -884,10 +884,10 @@ mod tests {
     #[test]
     pub fn test_to_str() {
         let zerolen = Bitv::new(0u, false);
-        fail_unless!(zerolen.to_str() == ~"");
+        assert!(zerolen.to_str() == ~"");
 
         let eightbits = Bitv::new(8u, false);
-        fail_unless!(eightbits.to_str() == ~"00000000");
+        assert!(eightbits.to_str() == ~"00000000");
     }
 
     #[test]
@@ -896,16 +896,16 @@ mod tests {
         let mut exp;
         act = Bitv::new(0u, false);
         exp = vec::from_elem::<uint>(0u, 0u);
-        fail_unless!(act.eq_vec(exp));
+        assert!(act.eq_vec(exp));
     }
 
     #[test]
     pub fn test_1_element() {
         let mut act;
         act = Bitv::new(1u, false);
-        fail_unless!(act.eq_vec(~[0u]));
+        assert!(act.eq_vec(~[0u]));
         act = Bitv::new(1u, true);
-        fail_unless!(act.eq_vec(~[1u]));
+        assert!(act.eq_vec(~[1u]));
     }
 
     #[test]
@@ -913,7 +913,7 @@ mod tests {
         let mut b = bitv::Bitv::new(2, false);
         b.set(0, true);
         b.set(1, false);
-        fail_unless!(b.to_str() == ~"10");
+        assert!(b.to_str() == ~"10");
     }
 
     #[test]
@@ -922,11 +922,11 @@ mod tests {
         // all 0
 
         act = Bitv::new(10u, false);
-        fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])));
+        assert!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])));
         // all 1
 
         act = Bitv::new(10u, true);
-        fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])));
+        assert!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -935,7 +935,7 @@ mod tests {
         act.set(2u, true);
         act.set(3u, true);
         act.set(4u, true);
-        fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u])));
+        assert!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -944,7 +944,7 @@ mod tests {
         act.set(7u, true);
         act.set(8u, true);
         act.set(9u, true);
-        fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u])));
+        assert!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u])));
         // mixed
 
         act = Bitv::new(10u, false);
@@ -952,7 +952,7 @@ mod tests {
         act.set(3u, true);
         act.set(6u, true);
         act.set(9u, true);
-        fail_unless!((act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u])));
+        assert!((act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u])));
     }
 
     #[test]
@@ -961,14 +961,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(31u, false);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(31u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u]));
@@ -983,7 +983,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
@@ -998,7 +998,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u]));
@@ -1012,7 +1012,7 @@ mod tests {
         act.set(28u, true);
         act.set(29u, true);
         act.set(30u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u]));
@@ -1022,7 +1022,7 @@ mod tests {
         act.set(3u, true);
         act.set(17u, true);
         act.set(30u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u]));
@@ -1034,14 +1034,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(32u, false);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(32u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1056,7 +1056,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1071,7 +1071,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1086,7 +1086,7 @@ mod tests {
         act.set(29u, true);
         act.set(30u, true);
         act.set(31u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1097,7 +1097,7 @@ mod tests {
         act.set(17u, true);
         act.set(30u, true);
         act.set(31u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 1u]));
@@ -1109,14 +1109,14 @@ mod tests {
         // all 0
 
         act = Bitv::new(33u, false);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
         // all 1
 
         act = Bitv::new(33u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 1u]));
@@ -1131,7 +1131,7 @@ mod tests {
         act.set(5u, true);
         act.set(6u, true);
         act.set(7u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1146,7 +1146,7 @@ mod tests {
         act.set(21u, true);
         act.set(22u, true);
         act.set(23u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u]));
@@ -1161,7 +1161,7 @@ mod tests {
         act.set(29u, true);
         act.set(30u, true);
         act.set(31u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
                         1u, 1u, 1u, 1u, 1u, 1u, 0u]));
@@ -1173,7 +1173,7 @@ mod tests {
         act.set(30u, true);
         act.set(31u, true);
         act.set(32u, true);
-        fail_unless!(act.eq_vec(
+        assert!(act.eq_vec(
                        ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
                         0u, 0u, 0u, 0u, 1u, 1u, 1u]));
@@ -1183,14 +1183,14 @@ mod tests {
     pub fn test_equal_differing_sizes() {
         let v0 = Bitv::new(10u, false);
         let v1 = Bitv::new(11u, false);
-        fail_unless!(!v0.equal(&v1));
+        assert!(!v0.equal(&v1));
     }
 
     #[test]
     pub fn test_equal_greatly_differing_sizes() {
         let v0 = Bitv::new(10u, false);
         let v1 = Bitv::new(110u, false);
-        fail_unless!(!v0.equal(&v1));
+        assert!(!v0.equal(&v1));
     }
 
     #[test]
@@ -1201,7 +1201,7 @@ mod tests {
         let mut b = bitv::Bitv::new(1, true);
         b.set(0, true);
 
-        fail_unless!(a.equal(&b));
+        assert!(a.equal(&b));
     }
 
     #[test]
@@ -1216,38 +1216,38 @@ mod tests {
             b.set(i, true);
         }
 
-        fail_unless!(a.equal(&b));
+        assert!(a.equal(&b));
     }
 
     #[test]
     pub fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + ~"00000000" + ~"11111111";
-        fail_unless!(bitv.to_str() == str);
+        assert!(bitv.to_str() == str);
     }
 
     #[test]
     pub fn test_to_bytes() {
         let mut bv = Bitv::new(3, true);
         bv.set(1, false);
-        fail_unless!(bv.to_bytes() == ~[0b10100000]);
+        assert!(bv.to_bytes() == ~[0b10100000]);
 
         let mut bv = Bitv::new(9, false);
         bv.set(2, true);
         bv.set(8, true);
-        fail_unless!(bv.to_bytes() == ~[0b00100000, 0b10000000]);
+        assert!(bv.to_bytes() == ~[0b00100000, 0b10000000]);
     }
 
     #[test]
     pub fn test_from_bools() {
-        fail_unless!(from_bools([true, false, true, true]).to_str() ==
+        assert!(from_bools([true, false, true, true]).to_str() ==
             ~"1011");
     }
 
     #[test]
     pub fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        fail_unless!(from_bytes([0b00100110]).to_bools() == bools);
+        assert!(from_bytes([0b00100110]).to_bools() == bools);
     }
 
     #[test]
@@ -1258,10 +1258,10 @@ mod tests {
         b1.set(1, true);
         b2.set(1, true);
         b2.set(2, true);
-        fail_unless!(b1.difference(&b2));
-        fail_unless!(b1[0]);
-        fail_unless!(!b1[1]);
-        fail_unless!(!b1[2]);
+        assert!(b1.difference(&b2));
+        assert!(b1[0]);
+        assert!(!b1[1]);
+        assert!(!b1[2]);
     }
 
     #[test]
@@ -1272,10 +1272,10 @@ mod tests {
         b1.set(40, true);
         b2.set(40, true);
         b2.set(80, true);
-        fail_unless!(b1.difference(&b2));
-        fail_unless!(b1[0]);
-        fail_unless!(!b1[40]);
-        fail_unless!(!b1[80]);
+        assert!(b1.difference(&b2));
+        assert!(b1[0]);
+        assert!(!b1[40]);
+        assert!(!b1[80]);
     }
 
     #[test]
@@ -1299,13 +1299,13 @@ mod tests {
     #[test]
     pub fn test_bitv_set_basic() {
         let mut b = BitvSet::new();
-        fail_unless!(b.insert(3));
-        fail_unless!(!b.insert(3));
-        fail_unless!(b.contains(&3));
-        fail_unless!(b.insert(400));
-        fail_unless!(!b.insert(400));
-        fail_unless!(b.contains(&400));
-        fail_unless!(b.len() == 2);
+        assert!(b.insert(3));
+        assert!(!b.insert(3));
+        assert!(b.contains(&3));
+        assert!(b.insert(400));
+        assert!(!b.insert(400));
+        assert!(b.contains(&400));
+        assert!(b.len() == 2);
     }
 
     #[test]
@@ -1313,26 +1313,26 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        fail_unless!(a.insert(11));
-        fail_unless!(a.insert(1));
-        fail_unless!(a.insert(3));
-        fail_unless!(a.insert(77));
-        fail_unless!(a.insert(103));
-        fail_unless!(a.insert(5));
+        assert!(a.insert(11));
+        assert!(a.insert(1));
+        assert!(a.insert(3));
+        assert!(a.insert(77));
+        assert!(a.insert(103));
+        assert!(a.insert(5));
 
-        fail_unless!(b.insert(2));
-        fail_unless!(b.insert(11));
-        fail_unless!(b.insert(77));
-        fail_unless!(b.insert(5));
-        fail_unless!(b.insert(3));
+        assert!(b.insert(2));
+        assert!(b.insert(11));
+        assert!(b.insert(77));
+        assert!(b.insert(5));
+        assert!(b.insert(3));
 
         let mut i = 0;
         let expected = [3, 5, 11, 77];
         for a.intersection(&b) |x| {
-            fail_unless!(*x == expected[i]);
+            assert!(*x == expected[i]);
             i += 1
         }
-        fail_unless!(i == expected.len());
+        assert!(i == expected.len());
     }
 
     #[test]
@@ -1340,22 +1340,22 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        fail_unless!(a.insert(1));
-        fail_unless!(a.insert(3));
-        fail_unless!(a.insert(5));
-        fail_unless!(a.insert(200));
-        fail_unless!(a.insert(500));
+        assert!(a.insert(1));
+        assert!(a.insert(3));
+        assert!(a.insert(5));
+        assert!(a.insert(200));
+        assert!(a.insert(500));
 
-        fail_unless!(b.insert(3));
-        fail_unless!(b.insert(200));
+        assert!(b.insert(3));
+        assert!(b.insert(200));
 
         let mut i = 0;
         let expected = [1, 5, 500];
         for a.difference(&b) |x| {
-            fail_unless!(*x == expected[i]);
+            assert!(*x == expected[i]);
             i += 1
         }
-        fail_unless!(i == expected.len());
+        assert!(i == expected.len());
     }
 
     #[test]
@@ -1363,67 +1363,67 @@ mod tests {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
 
-        fail_unless!(a.insert(1));
-        fail_unless!(a.insert(3));
-        fail_unless!(a.insert(5));
-        fail_unless!(a.insert(9));
-        fail_unless!(a.insert(11));
+        assert!(a.insert(1));
+        assert!(a.insert(3));
+        assert!(a.insert(5));
+        assert!(a.insert(9));
+        assert!(a.insert(11));
 
-        fail_unless!(b.insert(3));
-        fail_unless!(b.insert(9));
-        fail_unless!(b.insert(14));
-        fail_unless!(b.insert(220));
+        assert!(b.insert(3));
+        assert!(b.insert(9));
+        assert!(b.insert(14));
+        assert!(b.insert(220));
 
         let mut i = 0;
         let expected = [1, 5, 11, 14, 220];
         for a.symmetric_difference(&b) |x| {
-            fail_unless!(*x == expected[i]);
+            assert!(*x == expected[i]);
             i += 1
         }
-        fail_unless!(i == expected.len());
+        assert!(i == expected.len());
     }
 
     #[test]
     pub fn test_bitv_set_union() {
         let mut a = BitvSet::new();
         let mut b = BitvSet::new();
-        fail_unless!(a.insert(1));
-        fail_unless!(a.insert(3));
-        fail_unless!(a.insert(5));
-        fail_unless!(a.insert(9));
-        fail_unless!(a.insert(11));
-        fail_unless!(a.insert(160));
-        fail_unless!(a.insert(19));
-        fail_unless!(a.insert(24));
-
-        fail_unless!(b.insert(1));
-        fail_unless!(b.insert(5));
-        fail_unless!(b.insert(9));
-        fail_unless!(b.insert(13));
-        fail_unless!(b.insert(19));
+        assert!(a.insert(1));
+        assert!(a.insert(3));
+        assert!(a.insert(5));
+        assert!(a.insert(9));
+        assert!(a.insert(11));
+        assert!(a.insert(160));
+        assert!(a.insert(19));
+        assert!(a.insert(24));
+
+        assert!(b.insert(1));
+        assert!(b.insert(5));
+        assert!(b.insert(9));
+        assert!(b.insert(13));
+        assert!(b.insert(19));
 
         let mut i = 0;
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160];
         for a.union(&b) |x| {
-            fail_unless!(*x == expected[i]);
+            assert!(*x == expected[i]);
             i += 1
         }
-        fail_unless!(i == expected.len());
+        assert!(i == expected.len());
     }
 
     #[test]
     pub fn test_bitv_remove() {
         let mut a = BitvSet::new();
 
-        fail_unless!(a.insert(1));
-        fail_unless!(a.remove(&1));
+        assert!(a.insert(1));
+        assert!(a.remove(&1));
 
-        fail_unless!(a.insert(100));
-        fail_unless!(a.remove(&100));
+        assert!(a.insert(100));
+        assert!(a.remove(&100));
 
-        fail_unless!(a.insert(1000));
-        fail_unless!(a.remove(&1000));
-        fail_unless!(a.capacity() == uint::bits);
+        assert!(a.insert(1000));
+        assert!(a.remove(&1000));
+        assert!(a.capacity() == uint::bits);
     }
 
     fn rng() -> @rand::Rng {
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 1787be75e24..113c8130349 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -122,7 +122,7 @@ pub unsafe fn c_vec_with_dtor<T>(base: *mut T, len: uint, dtor: @fn())
  * Fails if `ofs` is greater or equal to the length of the vector
  */
 pub fn get<T:Copy>(t: CVec<T>, ofs: uint) -> T {
-    fail_unless!(ofs < len(t));
+    assert!(ofs < len(t));
     return unsafe { *ptr::mut_offset(t.base, ofs) };
 }
 
@@ -132,7 +132,7 @@ pub fn get<T:Copy>(t: CVec<T>, ofs: uint) -> T {
  * Fails if `ofs` is greater or equal to the length of the vector
  */
 pub fn set<T:Copy>(t: CVec<T>, ofs: uint, v: T) {
-    fail_unless!(ofs < len(t));
+    assert!(ofs < len(t));
     unsafe { *ptr::mut_offset(t.base, ofs) = v };
 }
 
@@ -159,7 +159,7 @@ mod tests {
         unsafe {
             let mem = libc::malloc(n);
 
-            fail_unless!(mem as int != 0);
+            assert!(mem as int != 0);
 
             return unsafe { c_vec_with_dtor(mem as *mut u8, n as uint,
                                          || unsafe { free(mem) }) };
@@ -172,9 +172,9 @@ mod tests {
 
         set(cv, 3u, 8u8);
         set(cv, 4u, 9u8);
-        fail_unless!(get(cv, 3u) == 8u8);
-        fail_unless!(get(cv, 4u) == 9u8);
-        fail_unless!(len(cv) == 16u);
+        assert!(get(cv, 3u) == 8u8);
+        assert!(get(cv, 4u) == 9u8);
+        assert!(len(cv) == 16u);
     }
 
     #[test]
@@ -202,7 +202,7 @@ mod tests {
 
         set(cv, 0u, 32u8);
         set(cv, 1u, 33u8);
-        fail_unless!(unsafe { *p } == 32u8);
+        assert!(unsafe { *p } == 32u8);
         set(cv, 2u, 34u8); /* safety */
     }
 
diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs
index 93a2f4e2acc..5d7f64a7c8f 100644
--- a/src/libstd/cmp.rs
+++ b/src/libstd/cmp.rs
@@ -53,15 +53,15 @@ impl FuzzyEq<f64> for f64 {
 
 #[test]
 fn test_fuzzy_equals() {
-    fail_unless!((&1.0f).fuzzy_eq(&1.0));
-    fail_unless!((&1.0f32).fuzzy_eq(&1.0f32));
-    fail_unless!((&1.0f64).fuzzy_eq(&1.0f64));
+    assert!((&1.0f).fuzzy_eq(&1.0));
+    assert!((&1.0f32).fuzzy_eq(&1.0f32));
+    assert!((&1.0f64).fuzzy_eq(&1.0f64));
 }
 
 #[test]
 fn test_fuzzy_eq_eps() {
-    fail_unless!((&1.2f).fuzzy_eq_eps(&0.9, &0.5));
-    fail_unless!(!(&1.5f).fuzzy_eq_eps(&0.9, &0.5));
+    assert!((&1.2f).fuzzy_eq_eps(&0.9, &0.5));
+    assert!(!(&1.5f).fuzzy_eq_eps(&0.9, &0.5));
 }
 
 #[test]
@@ -87,16 +87,16 @@ mod test_complex{
         let a = Complex {r: 0.9, i: 0.9};
         let b = Complex {r: 0.9, i: 0.9};
 
-        fail_unless!((a.fuzzy_eq(&b)));
+        assert!((a.fuzzy_eq(&b)));
     }
 
     #[test]
     fn test_fuzzy_eq_eps() {
         let other = Complex {r: 0.9, i: 0.9};
 
-        fail_unless!((&Complex {r: 0.9, i: 1.2}).fuzzy_eq_eps(&other, &0.5));
-        fail_unless!((&Complex {r: 1.2, i: 0.9}).fuzzy_eq_eps(&other, &0.5));
-        fail_unless!(!(&Complex {r: 0.9, i: 1.5}).fuzzy_eq_eps(&other, &0.5));
-        fail_unless!(!(&Complex {r: 1.5, i: 0.9}).fuzzy_eq_eps(&other, &0.5));
+        assert!((&Complex {r: 0.9, i: 1.2}).fuzzy_eq_eps(&other, &0.5));
+        assert!((&Complex {r: 1.2, i: 0.9}).fuzzy_eq_eps(&other, &0.5));
+        assert!(!(&Complex {r: 0.9, i: 1.5}).fuzzy_eq_eps(&other, &0.5));
+        assert!(!(&Complex {r: 1.5, i: 0.9}).fuzzy_eq_eps(&other, &0.5));
     }
 }
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 9f68c676222..0e0347406ae 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -105,7 +105,7 @@ mod test {
         left.send(~"abc");
         right.send(123);
 
-        fail_unless!(left.recv() == 123);
-        fail_unless!(right.recv() == ~"abc");
+        assert!(left.recv() == 123);
+        assert!(right.recv() == ~"abc");
     }
 }
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 72b68f8fe3a..e029b882472 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -120,7 +120,7 @@ pub impl<T> Deque<T> {
 /// Grow is only called on full elts, so nelts is also len(elts), unlike
 /// elsewhere.
 fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
-    fail_unless!(nelts == elts.len());
+    assert!(nelts == elts.len());
     let mut rv = ~[];
 
     do rv.grow_fn(nelts + 1) |i| {
@@ -145,46 +145,46 @@ mod tests {
     #[test]
     fn test_simple() {
         let mut d = Deque::new();
-        fail_unless!(d.len() == 0u);
+        assert!(d.len() == 0u);
         d.add_front(17);
         d.add_front(42);
         d.add_back(137);
-        fail_unless!(d.len() == 3u);
+        assert!(d.len() == 3u);
         d.add_back(137);
-        fail_unless!(d.len() == 4u);
+        assert!(d.len() == 4u);
         debug!(d.peek_front());
-        fail_unless!(*d.peek_front() == 42);
+        assert!(*d.peek_front() == 42);
         debug!(d.peek_back());
-        fail_unless!(*d.peek_back() == 137);
+        assert!(*d.peek_back() == 137);
         let mut i: int = d.pop_front();
         debug!(i);
-        fail_unless!(i == 42);
+        assert!(i == 42);
         i = d.pop_back();
         debug!(i);
-        fail_unless!(i == 137);
+        assert!(i == 137);
         i = d.pop_back();
         debug!(i);
-        fail_unless!(i == 137);
+        assert!(i == 137);
         i = d.pop_back();
         debug!(i);
-        fail_unless!(i == 17);
-        fail_unless!(d.len() == 0u);
+        assert!(i == 17);
+        assert!(d.len() == 0u);
         d.add_back(3);
-        fail_unless!(d.len() == 1u);
+        assert!(d.len() == 1u);
         d.add_front(2);
-        fail_unless!(d.len() == 2u);
+        assert!(d.len() == 2u);
         d.add_back(4);
-        fail_unless!(d.len() == 3u);
+        assert!(d.len() == 3u);
         d.add_front(1);
-        fail_unless!(d.len() == 4u);
+        assert!(d.len() == 4u);
         debug!(d.get(0));
         debug!(d.get(1));
         debug!(d.get(2));
         debug!(d.get(3));
-        fail_unless!(*d.get(0) == 1);
-        fail_unless!(*d.get(1) == 2);
-        fail_unless!(*d.get(2) == 3);
-        fail_unless!(*d.get(3) == 4);
+        assert!(*d.get(0) == 1);
+        assert!(*d.get(1) == 2);
+        assert!(*d.get(2) == 3);
+        assert!(*d.get(3) == 4);
     }
 
     #[test]
@@ -195,62 +195,62 @@ mod tests {
         let d: @int = @175;
 
         let mut deq = Deque::new();
-        fail_unless!(deq.len() == 0);
+        assert!(deq.len() == 0);
         deq.add_front(a);
         deq.add_front(b);
         deq.add_back(c);
-        fail_unless!(deq.len() == 3);
+        assert!(deq.len() == 3);
         deq.add_back(d);
-        fail_unless!(deq.len() == 4);
-        fail_unless!(*deq.peek_front() == b);
-        fail_unless!(*deq.peek_back() == d);
-        fail_unless!(deq.pop_front() == b);
-        fail_unless!(deq.pop_back() == d);
-        fail_unless!(deq.pop_back() == c);
-        fail_unless!(deq.pop_back() == a);
-        fail_unless!(deq.len() == 0);
+        assert!(deq.len() == 4);
+        assert!(*deq.peek_front() == b);
+        assert!(*deq.peek_back() == d);
+        assert!(deq.pop_front() == b);
+        assert!(deq.pop_back() == d);
+        assert!(deq.pop_back() == c);
+        assert!(deq.pop_back() == a);
+        assert!(deq.len() == 0);
         deq.add_back(c);
-        fail_unless!(deq.len() == 1);
+        assert!(deq.len() == 1);
         deq.add_front(b);
-        fail_unless!(deq.len() == 2);
+        assert!(deq.len() == 2);
         deq.add_back(d);
-        fail_unless!(deq.len() == 3);
+        assert!(deq.len() == 3);
         deq.add_front(a);
-        fail_unless!(deq.len() == 4);
-        fail_unless!(*deq.get(0) == a);
-        fail_unless!(*deq.get(1) == b);
-        fail_unless!(*deq.get(2) == c);
-        fail_unless!(*deq.get(3) == d);
+        assert!(deq.len() == 4);
+        assert!(*deq.get(0) == a);
+        assert!(*deq.get(1) == b);
+        assert!(*deq.get(2) == c);
+        assert!(*deq.get(3) == d);
     }
 
     fn test_parameterized<T:Copy + Eq + Durable>(a: T, b: T, c: T, d: T) {
         let mut deq = Deque::new();
-        fail_unless!(deq.len() == 0);
+        assert!(deq.len() == 0);
         deq.add_front(a);
         deq.add_front(b);
         deq.add_back(c);
-        fail_unless!(deq.len() == 3);
+        assert!(deq.len() == 3);
         deq.add_back(d);
-        fail_unless!(deq.len() == 4);
-        fail_unless!(*deq.peek_front() == b);
-        fail_unless!(*deq.peek_back() == d);
-        fail_unless!(deq.pop_front() == b);
-        fail_unless!(deq.pop_back() == d);
-        fail_unless!(deq.pop_back() == c);
-        fail_unless!(deq.pop_back() == a);
-        fail_unless!(deq.len() == 0);
+        assert!(deq.len() == 4);
+        assert!(*deq.peek_front() == b);
+        assert!(*deq.peek_back() == d);
+        assert!(deq.pop_front() == b);
+        assert!(deq.pop_back() == d);
+        assert!(deq.pop_back() == c);
+        assert!(deq.pop_back() == a);
+        assert!(deq.len() == 0);
         deq.add_back(c);
-        fail_unless!(deq.len() == 1);
+        assert!(deq.len() == 1);
         deq.add_front(b);
-        fail_unless!(deq.len() == 2);
+        assert!(deq.len() == 2);
         deq.add_back(d);
-        fail_unless!(deq.len() == 3);
+        assert!(deq.len() == 3);
         deq.add_front(a);
-        fail_unless!(deq.len() == 4);
-        fail_unless!(*deq.get(0) == a);
-        fail_unless!(*deq.get(1) == b);
-        fail_unless!(*deq.get(2) == c);
-        fail_unless!(*deq.get(3) == d);
+        assert!(deq.len() == 4);
+        assert!(*deq.get(0) == a);
+        assert!(*deq.get(1) == b);
+        assert!(*deq.get(2) == c);
+        assert!(*deq.get(3) == d);
     }
 
     #[deriving(Eq)]
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 484220776c3..bc9fc3553fe 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -179,22 +179,22 @@ pub mod reader {
     pub fn doc_as_str(d: Doc) -> ~str { str::from_bytes(doc_data(d)) }
 
     pub fn doc_as_u8(d: Doc) -> u8 {
-        fail_unless!(d.end == d.start + 1u);
+        assert!(d.end == d.start + 1u);
         (*d.data)[d.start]
     }
 
     pub fn doc_as_u16(d: Doc) -> u16 {
-        fail_unless!(d.end == d.start + 2u);
+        assert!(d.end == d.start + 2u);
         io::u64_from_be_bytes(*d.data, d.start, 2u) as u16
     }
 
     pub fn doc_as_u32(d: Doc) -> u32 {
-        fail_unless!(d.end == d.start + 4u);
+        assert!(d.end == d.start + 4u);
         io::u64_from_be_bytes(*d.data, d.start, 4u) as u32
     }
 
     pub fn doc_as_u64(d: Doc) -> u64 {
-        fail_unless!(d.end == d.start + 8u);
+        assert!(d.end == d.start + 8u);
         io::u64_from_be_bytes(*d.data, d.start, 8u)
     }
 
@@ -559,7 +559,7 @@ pub mod writer {
     priv impl Encoder {
         // used internally to emit things like the vector length and so on
         fn _emit_tagged_uint(&self, t: EbmlEncoderTag, v: uint) {
-            fail_unless!(v <= 0xFFFF_FFFF_u);
+            assert!(v <= 0xFFFF_FFFF_u);
             self.wr_tagged_u32(t as uint, v as u32);
         }
 
@@ -713,7 +713,7 @@ mod tests {
             let deser = reader::Decoder(ebml_doc);
             let v1 = serialize::Decodable::decode(&deser);
             debug!("v1 == %?", v1);
-            fail_unless!(v == v1);
+            assert!(v == v1);
         }
 
         test_v(Some(22));
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index ab6844b80ff..74e7ad9dc3f 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -358,8 +358,8 @@ pub mod flatteners {
 
     impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
-            fail_unless!(size_of::<T>() != 0);
-            fail_unless!(size_of::<T>() == buf.len());
+            assert!(size_of::<T>() != 0);
+            assert!(size_of::<T>() == buf.len());
             let addr_of_init: &u8 = unsafe { &*vec::raw::to_ptr(buf) };
             let addr_of_value: &T = unsafe { cast::transmute(addr_of_init) };
             copy *addr_of_value
@@ -368,7 +368,7 @@ pub mod flatteners {
 
     impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
         fn flatten(&self, val: T) -> ~[u8] {
-            fail_unless!(size_of::<T>() != 0);
+            assert!(size_of::<T>() != 0);
             let val: *T = ptr::to_unsafe_ptr(&val);
             let byte_value = val as *u8;
             unsafe { vec::from_buf(byte_value, size_of::<T>()) }
@@ -519,11 +519,11 @@ pub mod bytepipes {
             let mut left = count;
             let mut bytes = ~[];
             while !self.reader.eof() && left > 0 {
-                fail_unless!(left <= count);
-                fail_unless!(left > 0);
+                assert!(left <= count);
+                assert!(left > 0);
                 let new_bytes = self.reader.read_bytes(left);
                 bytes.push_all(new_bytes);
-                fail_unless!(new_bytes.len() <= left);
+                assert!(new_bytes.len() <= left);
                 left -= new_bytes.len();
             }
 
@@ -576,7 +576,7 @@ pub mod bytepipes {
                 return Some(bytes);
             } else if vec::uniq_len(&const self.buf) > 0 {
                 let mut bytes = ::core::util::replace(&mut self.buf, ~[]);
-                fail_unless!(count > bytes.len());
+                assert!(count > bytes.len());
                 match self.try_recv(count - bytes.len()) {
                     Some(rest) => {
                         bytes.push_all(rest);
@@ -587,7 +587,7 @@ pub mod bytepipes {
             } else if vec::uniq_len(&const self.buf) == 0 {
                 match self.port.try_recv() {
                     Some(buf) => {
-                        fail_unless!(!buf.is_empty());
+                        assert!(!buf.is_empty());
                         self.buf = buf;
                         return self.try_recv(count);
                     }
@@ -655,7 +655,7 @@ mod test {
         let port = serial::reader_port(reader);
 
         let res: int = port.recv();
-        fail_unless!(res == 10i);
+        assert!(res == 10i);
     }
 
     #[test]
@@ -669,7 +669,7 @@ mod test {
         }
 
         for int::range(0, 10) |i| {
-            fail_unless!(i == port.recv())
+            assert!(i == port.recv())
         }
     }
 
@@ -684,7 +684,7 @@ mod test {
         }
 
         for int::range(0, 10) |i| {
-            fail_unless!(@i == port.recv())
+            assert!(@i == port.recv())
         }
     }
 
@@ -701,7 +701,7 @@ mod test {
         let port = pod::reader_port(reader);
 
         let res: int = port.recv();
-        fail_unless!(res == 10);
+        assert!(res == 10);
     }
 
     #[test]
@@ -715,7 +715,7 @@ mod test {
         }
 
         for int::range(0, 10) |i| {
-            fail_unless!(i == port.recv())
+            assert!(i == port.recv())
         }
     }
 
@@ -799,7 +799,7 @@ mod test {
                 kill_ch.send(None)
             };
 
-            fail_unless!(listen_res.is_ok());
+            assert!(listen_res.is_ok());
         }
 
         // Client task
@@ -812,7 +812,7 @@ mod test {
             debug!("connecting");
             let iotask = &uv::global_loop::get();
             let connect_result = tcp::connect(copy addr, port, iotask);
-            fail_unless!(connect_result.is_ok());
+            assert!(connect_result.is_ok());
             let sock = result::unwrap(connect_result);
             let socket_buf: tcp::TcpSocketBuf = tcp::socket_buf(sock);
 
@@ -833,7 +833,7 @@ mod test {
             debug!("accepting connection");
             let accept_result = tcp::accept(conn);
             debug!("accepted");
-            fail_unless!(accept_result.is_ok());
+            assert!(accept_result.is_ok());
             let sock = result::unwrap(accept_result);
             res_chan.send(());
 
@@ -845,7 +845,7 @@ mod test {
             for int::range(0, 10) |i| {
                 let j = port.recv();
                 debug!("receieved %?", j);
-                fail_unless!(i == j);
+                assert!(i == j);
             }
 
             // The test is over!
@@ -891,7 +891,7 @@ mod test {
             let bytes = ~[];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
-            fail_unless!(res.is_none());
+            assert!(res.is_none());
         }
 
         #[test]
@@ -908,7 +908,7 @@ mod test {
             let bytes = ~[0];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
-            fail_unless!(res.is_none());
+            assert!(res.is_none());
         }
 
         #[test]
@@ -926,7 +926,7 @@ mod test {
             let bytes = CONTINUE.to_vec() + ~[0];
             let port = loader(bytes);
             let res: Option<int> = port.try_recv();
-            fail_unless!(res.is_none());
+            assert!(res.is_none());
         }
 
         #[test]
@@ -939,7 +939,7 @@ mod test {
         }
 
         fn test_try_recv_none4<P:BytePort>(+loader: PortLoader<P>) {
-            fail_unless!(do task::try || {
+            assert!(do task::try || {
                 static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
                 // The control word is followed by a valid length,
                 // then undeserializable garbage
diff --git a/src/libstd/future.rs b/src/libstd/future.rs
index 8504b3e8ae5..a4887306d2a 100644
--- a/src/libstd/future.rs
+++ b/src/libstd/future.rs
@@ -155,7 +155,7 @@ pub mod test {
     #[test]
     pub fn test_from_value() {
         let f = from_value(~"snail");
-        fail_unless!(f.get() == ~"snail");
+        assert!(f.get() == ~"snail");
     }
 
     #[test]
@@ -163,31 +163,31 @@ pub mod test {
         let (ch, po) = oneshot::init();
         send_one(ch, ~"whale");
         let f = from_port(po);
-        fail_unless!(f.get() == ~"whale");
+        assert!(f.get() == ~"whale");
     }
 
     #[test]
     pub fn test_from_fn() {
         let f = from_fn(|| ~"brail");
-        fail_unless!(f.get() == ~"brail");
+        assert!(f.get() == ~"brail");
     }
 
     #[test]
     pub fn test_interface_get() {
         let f = from_value(~"fail");
-        fail_unless!(f.get() == ~"fail");
+        assert!(f.get() == ~"fail");
     }
 
     #[test]
     pub fn test_get_ref_method() {
         let f = from_value(22);
-        fail_unless!(*f.get_ref() == 22);
+        assert!(*f.get_ref() == 22);
     }
 
     #[test]
     pub fn test_spawn() {
         let f = spawn(|| ~"bale");
-        fail_unless!(f.get() == ~"bale");
+        assert!(f.get() == ~"bale");
     }
 
     #[test]
@@ -204,7 +204,7 @@ pub mod test {
         let f = do spawn { copy expected };
         do task::spawn || {
             let actual = f.get();
-            fail_unless!(actual == expected);
+            assert!(actual == expected);
         }
     }
 }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 4525dc0ae61..df37c48ebe8 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -484,7 +484,7 @@ pub mod groups {
     pub fn reqopt(short_name: &str, long_name: &str,
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        fail_unless!(len == 1 || len == 0);
+        assert!(len == 1 || len == 0);
         return OptGroup { short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -497,7 +497,7 @@ pub mod groups {
     pub fn optopt(short_name: &str, long_name: &str,
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        fail_unless!(len == 1 || len == 0);
+        assert!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -510,7 +510,7 @@ pub mod groups {
     pub fn optflag(short_name: &str, long_name: &str,
                    desc: &str) -> OptGroup {
         let len = short_name.len();
-        fail_unless!(len == 1 || len == 0);
+        assert!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: ~"",
@@ -523,7 +523,7 @@ pub mod groups {
     pub fn optflagopt(short_name: &str, long_name: &str,
                       desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        fail_unless!(len == 1 || len == 0);
+        assert!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -539,7 +539,7 @@ pub mod groups {
     pub fn optmulti(short_name: &str, long_name: &str,
                     desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        fail_unless!(len == 1 || len == 0);
+        assert!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -666,11 +666,11 @@ mod tests {
 
     pub fn check_fail_type(f: Fail_, ft: FailType) {
         match f {
-          ArgumentMissing(_) => fail_unless!(ft == ArgumentMissing_),
-          UnrecognizedOption(_) => fail_unless!(ft == UnrecognizedOption_),
-          OptionMissing(_) => fail_unless!(ft == OptionMissing_),
-          OptionDuplicated(_) => fail_unless!(ft == OptionDuplicated_),
-          UnexpectedArgument(_) => fail_unless!(ft == UnexpectedArgument_)
+          ArgumentMissing(_) => assert!(ft == ArgumentMissing_),
+          UnrecognizedOption(_) => assert!(ft == UnrecognizedOption_),
+          OptionMissing(_) => assert!(ft == OptionMissing_),
+          OptionDuplicated(_) => assert!(ft == OptionDuplicated_),
+          UnexpectedArgument(_) => assert!(ft == UnexpectedArgument_)
         }
     }
 
@@ -683,8 +683,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"test")));
-            fail_unless!((opt_str(m, ~"test") == ~"20"));
+            assert!((opt_present(m, ~"test")));
+            assert!((opt_str(m, ~"test") == ~"20"));
           }
           _ => { fail!(~"test_reqopt_long failed"); }
         }
@@ -730,8 +730,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"t")));
-            fail_unless!((opt_str(m, ~"t") == ~"20"));
+            assert!((opt_present(m, ~"t")));
+            assert!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -779,8 +779,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"test")));
-            fail_unless!((opt_str(m, ~"test") == ~"20"));
+            assert!((opt_present(m, ~"test")));
+            assert!((opt_str(m, ~"test") == ~"20"));
           }
           _ => fail!()
         }
@@ -792,7 +792,7 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
+          Ok(ref m) => assert!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -826,8 +826,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"t")));
-            fail_unless!((opt_str(m, ~"t") == ~"20"));
+            assert!((opt_present(m, ~"t")));
+            assert!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -839,7 +839,7 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
+          Ok(ref m) => assert!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -874,7 +874,7 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(opt_present(m, ~"test")),
+          Ok(ref m) => assert!(opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -885,7 +885,7 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
+          Ok(ref m) => assert!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -921,7 +921,7 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(opt_present(m, ~"t")),
+          Ok(ref m) => assert!(opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -932,7 +932,7 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
+          Ok(ref m) => assert!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -946,7 +946,7 @@ mod tests {
           Ok(ref m) => {
             // The next variable after the flag is just a free argument
 
-            fail_unless!((m.free[0] == ~"20"));
+            assert!((m.free[0] == ~"20"));
           }
           _ => fail!()
         }
@@ -971,7 +971,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_count(m, ~"v") == 1));
+            assert!((opt_count(m, ~"v") == 1));
           }
           _ => fail!()
         }
@@ -984,7 +984,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_count(m, ~"v") == 2));
+            assert!((opt_count(m, ~"v") == 2));
           }
           _ => fail!()
         }
@@ -997,7 +997,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_count(m, ~"v") == 2));
+            assert!((opt_count(m, ~"v") == 2));
           }
           _ => fail!()
         }
@@ -1010,7 +1010,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_count(m, ~"verbose") == 1));
+            assert!((opt_count(m, ~"verbose") == 1));
           }
           _ => fail!()
         }
@@ -1023,7 +1023,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_count(m, ~"verbose") == 2));
+            assert!((opt_count(m, ~"verbose") == 2));
           }
           _ => fail!()
         }
@@ -1037,8 +1037,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"test")));
-            fail_unless!((opt_str(m, ~"test") == ~"20"));
+            assert!((opt_present(m, ~"test")));
+            assert!((opt_str(m, ~"test") == ~"20"));
           }
           _ => fail!()
         }
@@ -1050,7 +1050,7 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
+          Ok(ref m) => assert!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -1073,11 +1073,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-              fail_unless!((opt_present(m, ~"test")));
-              fail_unless!((opt_str(m, ~"test") == ~"20"));
+              assert!((opt_present(m, ~"test")));
+              assert!((opt_str(m, ~"test") == ~"20"));
               let pair = opt_strs(m, ~"test");
-              fail_unless!((pair[0] == ~"20"));
-              fail_unless!((pair[1] == ~"30"));
+              assert!((pair[0] == ~"20"));
+              assert!((pair[1] == ~"30"));
           }
           _ => fail!()
         }
@@ -1090,8 +1090,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"t")));
-            fail_unless!((opt_str(m, ~"t") == ~"20"));
+            assert!((opt_present(m, ~"t")));
+            assert!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -1103,7 +1103,7 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
+          Ok(ref m) => assert!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -1126,11 +1126,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((opt_present(m, ~"t")));
-            fail_unless!((opt_str(m, ~"t") == ~"20"));
+            assert!((opt_present(m, ~"t")));
+            assert!((opt_str(m, ~"t") == ~"20"));
             let pair = opt_strs(m, ~"t");
-            fail_unless!((pair[0] == ~"20"));
-            fail_unless!((pair[1] == ~"30"));
+            assert!((pair[0] == ~"20"));
+            assert!((pair[1] == ~"30"));
           }
           _ => fail!()
         }
@@ -1171,20 +1171,20 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            fail_unless!((m.free[0] == ~"prog"));
-            fail_unless!((m.free[1] == ~"free1"));
-            fail_unless!((opt_str(m, ~"s") == ~"20"));
-            fail_unless!((m.free[2] == ~"free2"));
-            fail_unless!((opt_present(m, ~"flag")));
-            fail_unless!((opt_str(m, ~"long") == ~"30"));
-            fail_unless!((opt_present(m, ~"f")));
+            assert!((m.free[0] == ~"prog"));
+            assert!((m.free[1] == ~"free1"));
+            assert!((opt_str(m, ~"s") == ~"20"));
+            assert!((m.free[2] == ~"free2"));
+            assert!((opt_present(m, ~"flag")));
+            assert!((opt_str(m, ~"long") == ~"30"));
+            assert!((opt_present(m, ~"f")));
             let pair = opt_strs(m, ~"m");
-            fail_unless!((pair[0] == ~"40"));
-            fail_unless!((pair[1] == ~"50"));
+            assert!((pair[0] == ~"40"));
+            assert!((pair[1] == ~"50"));
             let pair = opt_strs(m, ~"n");
-            fail_unless!((pair[0] == ~"-A B"));
-            fail_unless!((pair[1] == ~"-60 70"));
-            fail_unless!((!opt_present(m, ~"notpresent")));
+            assert!((pair[0] == ~"-A B"));
+            assert!((pair[1] == ~"-60 70"));
+            assert!((!opt_present(m, ~"notpresent")));
           }
           _ => fail!()
         }
@@ -1198,18 +1198,18 @@ mod tests {
           result::Ok(m) => m,
           result::Err(_) => fail!()
         };
-        fail_unless!(opts_present(matches, ~[~"e"]));
-        fail_unless!(opts_present(matches, ~[~"encrypt"]));
-        fail_unless!(opts_present(matches, ~[~"encrypt", ~"e"]));
-        fail_unless!(opts_present(matches, ~[~"e", ~"encrypt"]));
-        fail_unless!(!opts_present(matches, ~[~"f"]));
-        fail_unless!(!opts_present(matches, ~[~"thing"]));
-        fail_unless!(!opts_present(matches, ~[]));
+        assert!(opts_present(matches, ~[~"e"]));
+        assert!(opts_present(matches, ~[~"encrypt"]));
+        assert!(opts_present(matches, ~[~"encrypt", ~"e"]));
+        assert!(opts_present(matches, ~[~"e", ~"encrypt"]));
+        assert!(!opts_present(matches, ~[~"f"]));
+        assert!(!opts_present(matches, ~[~"thing"]));
+        assert!(!opts_present(matches, ~[]));
 
-        fail_unless!(opts_str(matches, ~[~"e"]) == ~"foo");
-        fail_unless!(opts_str(matches, ~[~"encrypt"]) == ~"foo");
-        fail_unless!(opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo");
-        fail_unless!(opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo");
+        assert!(opts_str(matches, ~[~"e"]) == ~"foo");
+        assert!(opts_str(matches, ~[~"encrypt"]) == ~"foo");
+        assert!(opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo");
+        assert!(opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo");
     }
 
     #[test]
@@ -1220,17 +1220,17 @@ mod tests {
           result::Ok(m) => m,
           result::Err(_) => fail!()
         };
-        fail_unless!(opts_present(matches, ~[~"L"]));
-        fail_unless!(opts_str(matches, ~[~"L"]) == ~"foo");
-        fail_unless!(opts_present(matches, ~[~"M"]));
-        fail_unless!(opts_str(matches, ~[~"M"]) == ~".");
+        assert!(opts_present(matches, ~[~"L"]));
+        assert!(opts_str(matches, ~[~"L"]) == ~"foo");
+        assert!(opts_present(matches, ~[~"M"]));
+        assert!(opts_str(matches, ~[~"M"]) == ~".");
 
     }
 
     #[test]
     pub fn test_groups_reqopt() {
         let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL");
-        fail_unless!(opt == OptGroup { short_name: ~"b",
+        assert!(opt == OptGroup { short_name: ~"b",
                         long_name: ~"banana",
                         hint: ~"VAL",
                         desc: ~"some bananas",
@@ -1241,7 +1241,7 @@ mod tests {
     #[test]
     pub fn test_groups_optopt() {
         let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL");
-        fail_unless!(opt == OptGroup { short_name: ~"a",
+        assert!(opt == OptGroup { short_name: ~"a",
                         long_name: ~"apple",
                         hint: ~"VAL",
                         desc: ~"some apples",
@@ -1252,7 +1252,7 @@ mod tests {
     #[test]
     pub fn test_groups_optflag() {
         let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis");
-        fail_unless!(opt == OptGroup { short_name: ~"k",
+        assert!(opt == OptGroup { short_name: ~"k",
                         long_name: ~"kiwi",
                         hint: ~"",
                         desc: ~"some kiwis",
@@ -1264,7 +1264,7 @@ mod tests {
     pub fn test_groups_optflagopt() {
         let opt = groups::optflagopt(~"p", ~"pineapple",
                                        ~"some pineapples", ~"VAL");
-        fail_unless!(opt == OptGroup { short_name: ~"p",
+        assert!(opt == OptGroup { short_name: ~"p",
                         long_name: ~"pineapple",
                         hint: ~"VAL",
                         desc: ~"some pineapples",
@@ -1276,7 +1276,7 @@ mod tests {
     pub fn test_groups_optmulti() {
         let opt = groups::optmulti(~"l", ~"lime",
                                      ~"some limes", ~"VAL");
-        fail_unless!(opt == OptGroup { short_name: ~"l",
+        assert!(opt == OptGroup { short_name: ~"l",
                         long_name: ~"lime",
                         hint: ~"VAL",
                         desc: ~"some limes",
@@ -1290,7 +1290,7 @@ mod tests {
         let verbose = groups::reqopt(~"b", ~"banana",
                                        ~"some bananas", ~"VAL");
 
-        fail_unless!(groups::long_to_short(&verbose) == short);
+        assert!(groups::long_to_short(&verbose) == short);
     }
 
     #[test]
@@ -1315,7 +1315,7 @@ mod tests {
                             ~"-p", ~"16", ~"l", ~"35"];
 
         // FIXME #4681: sort options here?
-        fail_unless!(getopts(sample_args, short)
+        assert!(getopts(sample_args, short)
             == groups::getopts(sample_args, verbose));
     }
 
@@ -1347,7 +1347,7 @@ Options:
 
         debug!("expected: <<%s>>", expected);
         debug!("generated: <<%s>>", generated_usage);
-        fail_unless!(generated_usage == expected);
+        assert!(generated_usage == expected);
     }
 
     #[test]
@@ -1376,7 +1376,7 @@ Options:
 
         debug!("expected: <<%s>>", expected);
         debug!("generated: <<%s>>", usage);
-        fail_unless!(usage == expected)
+        assert!(usage == expected)
     }
 }
 
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index b918f8505c8..63d461ed4d3 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -165,28 +165,28 @@ mod tests {
         let full1 = from_vec(~[1]);
         let full2 = from_vec(~['r', 'u']);
 
-        fail_unless!(is_empty(empty));
-        fail_unless!(!is_empty(full1));
-        fail_unless!(!is_empty(full2));
+        assert!(is_empty(empty));
+        assert!(!is_empty(full1));
+        assert!(!is_empty(full2));
     }
 
     #[test]
     pub fn test_from_vec() {
         let l = from_vec(~[0, 1, 2]);
 
-        fail_unless!((head(l) == 0));
+        assert!((head(l) == 0));
 
         let tail_l = tail(l);
-        fail_unless!((head(tail_l) == 1));
+        assert!((head(tail_l) == 1));
 
         let tail_tail_l = tail(tail_l);
-        fail_unless!((head(tail_tail_l) == 2));
+        assert!((head(tail_tail_l) == 2));
     }
 
     #[test]
     pub fn test_from_vec_empty() {
         let empty : @list::List<int> = from_vec(~[]);
-        fail_unless!((empty == @list::Nil::<int>));
+        assert!((empty == @list::Nil::<int>));
     }
 
     #[test]
@@ -194,8 +194,8 @@ mod tests {
         fn add(a: &uint, b: &int) -> uint { return *a + (*b as uint); }
         let l = from_vec(~[0, 1, 2, 3, 4]);
         let empty = @list::Nil::<int>;
-        fail_unless!((list::foldl(0u, l, add) == 10u));
-        fail_unless!((list::foldl(0u, empty, add) == 0u));
+        assert!((list::foldl(0u, l, add) == 10u));
+        assert!((list::foldl(0u, empty, add) == 0u));
     }
 
     #[test]
@@ -204,14 +204,14 @@ mod tests {
             *a - *b
         }
         let l = from_vec(~[1, 2, 3, 4]);
-        fail_unless!((list::foldl(0, l, sub) == -10));
+        assert!((list::foldl(0, l, sub) == -10));
     }
 
     #[test]
     pub fn test_find_success() {
         fn match_(i: &int) -> bool { return *i == 2; }
         let l = from_vec(~[0, 1, 2]);
-        fail_unless!((list::find(l, match_) == option::Some(2)));
+        assert!((list::find(l, match_) == option::Some(2)));
     }
 
     #[test]
@@ -219,31 +219,31 @@ mod tests {
         fn match_(_i: &int) -> bool { return false; }
         let l = from_vec(~[0, 1, 2]);
         let empty = @list::Nil::<int>;
-        fail_unless!((list::find(l, match_) == option::None::<int>));
-        fail_unless!((list::find(empty, match_) == option::None::<int>));
+        assert!((list::find(l, match_) == option::None::<int>));
+        assert!((list::find(empty, match_) == option::None::<int>));
     }
 
     #[test]
     pub fn test_has() {
         let l = from_vec(~[5, 8, 6]);
         let empty = @list::Nil::<int>;
-        fail_unless!((list::has(l, 5)));
-        fail_unless!((!list::has(l, 7)));
-        fail_unless!((list::has(l, 8)));
-        fail_unless!((!list::has(empty, 5)));
+        assert!((list::has(l, 5)));
+        assert!((!list::has(l, 7)));
+        assert!((list::has(l, 8)));
+        assert!((!list::has(empty, 5)));
     }
 
     #[test]
     pub fn test_len() {
         let l = from_vec(~[0, 1, 2]);
         let empty = @list::Nil::<int>;
-        fail_unless!((list::len(l) == 3u));
-        fail_unless!((list::len(empty) == 0u));
+        assert!((list::len(l) == 3u));
+        assert!((list::len(empty) == 0u));
     }
 
     #[test]
     pub fn test_append() {
-        fail_unless!(from_vec(~[1,2,3,4])
+        assert!(from_vec(~[1,2,3,4])
             == list::append(list::from_vec(~[1,2]), list::from_vec(~[3,4])));
     }
 }
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index e20ac624278..8f35376a6f1 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -125,17 +125,17 @@ pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) }
 
 #[test]
 fn test_md4() {
-    fail_unless!(md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0");
-    fail_unless!(md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24");
-    fail_unless!(md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d");
-    fail_unless!(md4_text(~"message digest") ==
+    assert!(md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0");
+    assert!(md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24");
+    assert!(md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d");
+    assert!(md4_text(~"message digest") ==
         ~"d9130a8164549fe818874806e1c7014b");
-    fail_unless!(md4_text(~"abcdefghijklmnopqrstuvwxyz") ==
+    assert!(md4_text(~"abcdefghijklmnopqrstuvwxyz") ==
         ~"d79e1c308aa5bbcdeea8ed63df412da9");
-    fail_unless!(md4_text(
+    assert!(md4_text(
         ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
         0123456789") == ~"043f8582f241db351ce627e153e7f0e4");
-    fail_unless!(md4_text(~"1234567890123456789012345678901234567890123456789\
+    assert!(md4_text(~"1234567890123456789012345678901234567890123456789\
                      0123456789012345678901234567890") ==
         ~"e33b4ddc9c38f2199c3e7b164fcc0536");
 }
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 4fd06f43164..6403e0eb5c4 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -379,7 +379,7 @@ mod test {
     #[test]
     fn test_ip_ipv4_parse_and_format_ip() {
         let localhost_str = ~"127.0.0.1";
-        fail_unless!(format_addr(&v4::parse_addr(localhost_str))
+        assert!(format_addr(&v4::parse_addr(localhost_str))
                 == localhost_str)
     }
     #[test]
@@ -388,14 +388,14 @@ mod test {
         let format_result = format_addr(&v6::parse_addr(localhost_str));
         debug!("results: expected: '%s' actual: '%s'",
             localhost_str, format_result);
-        fail_unless!(format_result == localhost_str);
+        assert!(format_result == localhost_str);
     }
     #[test]
     fn test_ip_ipv4_bad_parse() {
         match v4::try_parse_addr(~"b4df00d") {
           result::Err(ref err_info) => {
             debug!("got error as expected %?", err_info);
-            fail_unless!(true);
+            assert!(true);
           }
           result::Ok(ref addr) => {
             fail!(fmt!("Expected failure, but got addr %?", addr));
@@ -408,7 +408,7 @@ mod test {
         match v6::try_parse_addr(~"::,~2234k;") {
           result::Err(ref err_info) => {
             debug!("got error as expected %?", err_info);
-            fail_unless!(true);
+            assert!(true);
           }
           result::Ok(ref addr) => {
             fail!(fmt!("Expected failure, but got addr %?", addr));
@@ -439,7 +439,7 @@ mod test {
         }
         // at least one result.. this is going to vary from system
         // to system, based on stuff like the contents of /etc/hosts
-        fail_unless!(!results.is_empty());
+        assert!(!results.is_empty());
     }
     #[test]
     #[ignore(reason = "valgrind says it's leaky")]
@@ -447,6 +447,6 @@ mod test {
         let localhost_name = ~"sjkl234m,./sdf";
         let iotask = &uv::global_loop::get();
         let ga_result = get_addr(localhost_name, iotask);
-        fail_unless!(result::is_err(&ga_result));
+        assert!(result::is_err(&ga_result));
     }
 }
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 998b8640b68..8a51af8573f 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -876,7 +876,7 @@ impl io::Reader for TcpSocketBuf {
         let mut count: uint = 0;
 
         loop {
-          fail_unless!(count < len);
+          assert!(count < len);
 
           // If possible, copy up to `len` bytes from the internal
           // `data.buf` into `buf`
@@ -897,7 +897,7 @@ impl io::Reader for TcpSocketBuf {
                 }
           }
 
-          fail_unless!(count <= len);
+          assert!(count <= len);
           if count == len {
               break;
           }
@@ -1589,15 +1589,15 @@ pub mod test {
             server_port,
             expected_req,
             hl_loop);
-        fail_unless!(actual_resp_result.is_ok());
+        assert!(actual_resp_result.is_ok());
         let actual_resp = actual_resp_result.get();
         let actual_req = server_result_po.recv();
         debug!("REQ: expected: '%s' actual: '%s'",
                        expected_req, actual_req);
         debug!("RESP: expected: '%s' actual: '%s'",
                        expected_resp, actual_resp);
-        fail_unless!(str::contains(actual_req, expected_req));
-        fail_unless!(str::contains(actual_resp, expected_resp));
+        assert!(str::contains(actual_req, expected_req));
+        assert!(str::contains(actual_resp, expected_resp));
     }
     pub fn impl_gl_tcp_ipv4_get_peer_addr() {
         let hl_loop = &uv::global_loop::get();
@@ -1630,9 +1630,9 @@ pub mod test {
 
         debug!("testing peer address");
         // This is what we are actually testing!
-        fail_unless!(net::ip::format_addr(&sock.get_peer_addr()) ==
+        assert!(net::ip::format_addr(&sock.get_peer_addr()) ==
             ~"127.0.0.1");
-        fail_unless!(net::ip::get_port(&sock.get_peer_addr()) == 8887);
+        assert!(net::ip::get_port(&sock.get_peer_addr()) == 8887);
 
         // Fulfill the protocol the test server expects
         let resp_bytes = str::to_bytes(~"ping");
@@ -1693,7 +1693,7 @@ pub mod test {
             hl_loop);
         match listen_err {
           AddressInUse => {
-            fail_unless!(true);
+            assert!(true);
           }
           _ => {
             fail!(~"expected address_in_use listen error,"+
@@ -1712,7 +1712,7 @@ pub mod test {
                             hl_loop);
         match listen_err {
           AccessDenied => {
-            fail_unless!(true);
+            assert!(true);
           }
           _ => {
             fail!(~"expected address_in_use listen error,"+
@@ -1749,7 +1749,7 @@ pub mod test {
         let server_addr = ip::v4::parse_addr(server_ip);
         let conn_result = connect(server_addr, server_port, iotask);
         if result::is_err(&conn_result) {
-            fail_unless!(false);
+            assert!(false);
         }
         let sock_buf = @socket_buf(result::unwrap(conn_result));
         buf_write(sock_buf, expected_req);
@@ -1764,8 +1764,8 @@ pub mod test {
                        expected_req, actual_req);
         debug!("RESP: expected: '%s' actual: '%s'",
                        expected_resp, actual_resp);
-        fail_unless!(str::contains(actual_req, expected_req));
-        fail_unless!(str::contains(actual_resp, expected_resp));
+        assert!(str::contains(actual_req, expected_req));
+        assert!(str::contains(actual_resp, expected_resp));
     }
 
     pub fn impl_tcp_socket_impl_reader_handles_eof() {
@@ -1796,7 +1796,7 @@ pub mod test {
         let server_addr = ip::v4::parse_addr(server_ip);
         let conn_result = connect(server_addr, server_port, hl_loop);
         if result::is_err(&conn_result) {
-            fail_unless!(false);
+            assert!(false);
         }
         let sock_buf = @socket_buf(result::unwrap(conn_result));
         buf_write(sock_buf, expected_req);
@@ -1804,7 +1804,7 @@ pub mod test {
         let buf_reader = sock_buf as @Reader;
         let actual_response = str::from_bytes(buf_reader.read_whole_stream());
         debug!("Actual response: %s", actual_response);
-        fail_unless!(expected_resp == actual_response);
+        assert!(expected_resp == actual_response);
     }
 
     fn buf_write<W:io::Writer>(w: &W, val: &str) {
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 9caab11d643..d23784953ef 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -733,83 +733,83 @@ impl to_bytes::IterBytes for Url {
 #[test]
 fn test_split_char_first() {
     let (u,v) = split_char_first(~"hello, sweet world", ',');
-    fail_unless!(u == ~"hello");
-    fail_unless!(v == ~" sweet world");
+    assert!(u == ~"hello");
+    assert!(v == ~" sweet world");
 
     let (u,v) = split_char_first(~"hello sweet world", ',');
-    fail_unless!(u == ~"hello sweet world");
-    fail_unless!(v == ~"");
+    assert!(u == ~"hello sweet world");
+    assert!(v == ~"");
 }
 
 #[test]
 fn test_get_authority() {
     let (u, h, p, r) = get_authority(
         "//user:pass@rust-lang.org/something").unwrap();
-    fail_unless!(u == Some(UserInfo::new(~"user", Some(~"pass"))));
-    fail_unless!(h == ~"rust-lang.org");
-    fail_unless!(p.is_none());
-    fail_unless!(r == ~"/something");
+    assert!(u == Some(UserInfo::new(~"user", Some(~"pass"))));
+    assert!(h == ~"rust-lang.org");
+    assert!(p.is_none());
+    assert!(r == ~"/something");
 
     let (u, h, p, r) = get_authority(
         "//rust-lang.org:8000?something").unwrap();
-    fail_unless!(u.is_none());
-    fail_unless!(h == ~"rust-lang.org");
-    fail_unless!(p == Some(~"8000"));
-    fail_unless!(r == ~"?something");
+    assert!(u.is_none());
+    assert!(h == ~"rust-lang.org");
+    assert!(p == Some(~"8000"));
+    assert!(r == ~"?something");
 
     let (u, h, p, r) = get_authority(
         "//rust-lang.org#blah").unwrap();
-    fail_unless!(u.is_none());
-    fail_unless!(h == ~"rust-lang.org");
-    fail_unless!(p.is_none());
-    fail_unless!(r == ~"#blah");
+    assert!(u.is_none());
+    assert!(h == ~"rust-lang.org");
+    assert!(p.is_none());
+    assert!(r == ~"#blah");
 
     // ipv6 tests
     let (_, h, _, _) = get_authority(
         "//2001:0db8:85a3:0042:0000:8a2e:0370:7334#blah").unwrap();
-    fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
+    assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
 
     let (_, h, p, _) = get_authority(
         "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah").unwrap();
-    fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
-    fail_unless!(p == Some(~"8000"));
+    assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
+    assert!(p == Some(~"8000"));
 
     let (u, h, p, _) = get_authority(
         "//us:p@2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah"
     ).unwrap();
-    fail_unless!(u == Some(UserInfo::new(~"us", Some(~"p"))));
-    fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
-    fail_unless!(p == Some(~"8000"));
+    assert!(u == Some(UserInfo::new(~"us", Some(~"p"))));
+    assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334");
+    assert!(p == Some(~"8000"));
 
     // invalid authorities;
-    fail_unless!(get_authority("//user:pass@rust-lang:something").is_err());
-    fail_unless!(get_authority("//user@rust-lang:something:/path").is_err());
-    fail_unless!(get_authority(
+    assert!(get_authority("//user:pass@rust-lang:something").is_err());
+    assert!(get_authority("//user@rust-lang:something:/path").is_err());
+    assert!(get_authority(
         "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:800a").is_err());
-    fail_unless!(get_authority(
+    assert!(get_authority(
         "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000:00").is_err());
 
     // these parse as empty, because they don't start with '//'
     let (_, h, _, _) = get_authority(~"user:pass@rust-lang").unwrap();
-    fail_unless!(h == ~"");
+    assert!(h == ~"");
     let (_, h, _, _) = get_authority(~"rust-lang.org").unwrap();
-    fail_unless!(h == ~"");
+    assert!(h == ~"");
 }
 
 #[test]
 fn test_get_path() {
     let (p, r) = get_path("/something+%20orother", true).unwrap();
-    fail_unless!(p == ~"/something+ orother");
-    fail_unless!(r == ~"");
+    assert!(p == ~"/something+ orother");
+    assert!(r == ~"");
     let (p, r) = get_path("test@email.com#fragment", false).unwrap();
-    fail_unless!(p == ~"test@email.com");
-    fail_unless!(r == ~"#fragment");
+    assert!(p == ~"test@email.com");
+    assert!(r == ~"#fragment");
     let (p, r) = get_path(~"/gen/:addr=?q=v", false).unwrap();
-    fail_unless!(p == ~"/gen/:addr=");
-    fail_unless!(r == ~"?q=v");
+    assert!(p == ~"/gen/:addr=");
+    assert!(r == ~"?q=v");
 
     //failure cases
-    fail_unless!(get_path(~"something?q", true).is_err());
+    assert!(get_path(~"something?q", true).is_err());
 }
 
 #[cfg(test)]
@@ -826,247 +826,247 @@ mod tests {
 
         let up = from_str(url);
         let u = up.unwrap();
-        fail_unless!(u.scheme == ~"http");
+        assert!(u.scheme == ~"http");
         let userinfo = u.user.get_ref();
-        fail_unless!(userinfo.user == ~"user");
-        fail_unless!(userinfo.pass.get_ref() == &~"pass");
-        fail_unless!(u.host == ~"rust-lang.org");
-        fail_unless!(u.path == ~"/doc");
-        fail_unless!(u.query == ~[(~"s", ~"v")]);
-        fail_unless!(u.fragment.get_ref() == &~"something");
+        assert!(userinfo.user == ~"user");
+        assert!(userinfo.pass.get_ref() == &~"pass");
+        assert!(u.host == ~"rust-lang.org");
+        assert!(u.path == ~"/doc");
+        assert!(u.query == ~[(~"s", ~"v")]);
+        assert!(u.fragment.get_ref() == &~"something");
     }
 
     #[test]
     pub fn test_url_parse_host_slash() {
         let urlstr = ~"http://0.42.42.42/";
         let url = from_str(urlstr).unwrap();
-        fail_unless!(url.host == ~"0.42.42.42");
-        fail_unless!(url.path == ~"/");
+        assert!(url.host == ~"0.42.42.42");
+        assert!(url.path == ~"/");
     }
 
     #[test]
     pub fn test_url_with_underscores() {
         let urlstr = ~"http://dotcom.com/file_name.html";
         let url = from_str(urlstr).unwrap();
-        fail_unless!(url.path == ~"/file_name.html");
+        assert!(url.path == ~"/file_name.html");
     }
 
     #[test]
     pub fn test_url_with_dashes() {
         let urlstr = ~"http://dotcom.com/file-name.html";
         let url = from_str(urlstr).unwrap();
-        fail_unless!(url.path == ~"/file-name.html");
+        assert!(url.path == ~"/file-name.html");
     }
 
     #[test]
     pub fn test_no_scheme() {
-        fail_unless!(get_scheme("noschemehere.html").is_err());
+        assert!(get_scheme("noschemehere.html").is_err());
     }
 
     #[test]
     pub fn test_invalid_scheme_errors() {
-        fail_unless!(from_str("99://something").is_err());
-        fail_unless!(from_str("://something").is_err());
+        assert!(from_str("99://something").is_err());
+        assert!(from_str("://something").is_err());
     }
 
     #[test]
     pub fn test_full_url_parse_and_format() {
         let url = ~"http://user:pass@rust-lang.org/doc?s=v#something";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_userless_url_parse_and_format() {
         let url = ~"http://rust-lang.org/doc?s=v#something";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_queryless_url_parse_and_format() {
         let url = ~"http://user:pass@rust-lang.org/doc#something";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_empty_query_url_parse_and_format() {
         let url = ~"http://user:pass@rust-lang.org/doc?#something";
         let should_be = ~"http://user:pass@rust-lang.org/doc#something";
-        fail_unless!(from_str(url).unwrap().to_str() == should_be);
+        assert!(from_str(url).unwrap().to_str() == should_be);
     }
 
     #[test]
     pub fn test_fragmentless_url_parse_and_format() {
         let url = ~"http://user:pass@rust-lang.org/doc?q=v";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_minimal_url_parse_and_format() {
         let url = ~"http://rust-lang.org/doc";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_scheme_host_only_url_parse_and_format() {
         let url = ~"http://rust-lang.org";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_pathless_url_parse_and_format() {
         let url = ~"http://user:pass@rust-lang.org?q=v#something";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_scheme_host_fragment_only_url_parse_and_format() {
         let url = ~"http://rust-lang.org#something";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_url_component_encoding() {
         let url = ~"http://rust-lang.org/doc%20uments?ba%25d%20=%23%26%2B";
         let u = from_str(url).unwrap();
-        fail_unless!(u.path == ~"/doc uments");
-        fail_unless!(u.query == ~[(~"ba%d ", ~"#&+")]);
+        assert!(u.path == ~"/doc uments");
+        assert!(u.query == ~[(~"ba%d ", ~"#&+")]);
     }
 
     #[test]
     pub fn test_url_without_authority() {
         let url = ~"mailto:test@email.com";
-        fail_unless!(from_str(url).unwrap().to_str() == url);
+        assert!(from_str(url).unwrap().to_str() == url);
     }
 
     #[test]
     pub fn test_encode() {
-        fail_unless!(encode("") == ~"");
-        fail_unless!(encode("http://example.com") == ~"http://example.com");
-        fail_unless!(encode("foo bar% baz") == ~"foo%20bar%25%20baz");
-        fail_unless!(encode(" ") == ~"%20");
-        fail_unless!(encode("!") == ~"!");
-        fail_unless!(encode("\"") == ~"\"");
-        fail_unless!(encode("#") == ~"#");
-        fail_unless!(encode("$") == ~"$");
-        fail_unless!(encode("%") == ~"%25");
-        fail_unless!(encode("&") == ~"&");
-        fail_unless!(encode("'") == ~"%27");
-        fail_unless!(encode("(") == ~"(");
-        fail_unless!(encode(")") == ~")");
-        fail_unless!(encode("*") == ~"*");
-        fail_unless!(encode("+") == ~"+");
-        fail_unless!(encode(",") == ~",");
-        fail_unless!(encode("/") == ~"/");
-        fail_unless!(encode(":") == ~":");
-        fail_unless!(encode(";") == ~";");
-        fail_unless!(encode("=") == ~"=");
-        fail_unless!(encode("?") == ~"?");
-        fail_unless!(encode("@") == ~"@");
-        fail_unless!(encode("[") == ~"[");
-        fail_unless!(encode("]") == ~"]");
+        assert!(encode("") == ~"");
+        assert!(encode("http://example.com") == ~"http://example.com");
+        assert!(encode("foo bar% baz") == ~"foo%20bar%25%20baz");
+        assert!(encode(" ") == ~"%20");
+        assert!(encode("!") == ~"!");
+        assert!(encode("\"") == ~"\"");
+        assert!(encode("#") == ~"#");
+        assert!(encode("$") == ~"$");
+        assert!(encode("%") == ~"%25");
+        assert!(encode("&") == ~"&");
+        assert!(encode("'") == ~"%27");
+        assert!(encode("(") == ~"(");
+        assert!(encode(")") == ~")");
+        assert!(encode("*") == ~"*");
+        assert!(encode("+") == ~"+");
+        assert!(encode(",") == ~",");
+        assert!(encode("/") == ~"/");
+        assert!(encode(":") == ~":");
+        assert!(encode(";") == ~";");
+        assert!(encode("=") == ~"=");
+        assert!(encode("?") == ~"?");
+        assert!(encode("@") == ~"@");
+        assert!(encode("[") == ~"[");
+        assert!(encode("]") == ~"]");
     }
 
     #[test]
     pub fn test_encode_component() {
-        fail_unless!(encode_component("") == ~"");
-        fail_unless!(encode_component("http://example.com") ==
+        assert!(encode_component("") == ~"");
+        assert!(encode_component("http://example.com") ==
             ~"http%3A%2F%2Fexample.com");
-        fail_unless!(encode_component("foo bar% baz") ==
+        assert!(encode_component("foo bar% baz") ==
             ~"foo%20bar%25%20baz");
-        fail_unless!(encode_component(" ") == ~"%20");
-        fail_unless!(encode_component("!") == ~"%21");
-        fail_unless!(encode_component("#") == ~"%23");
-        fail_unless!(encode_component("$") == ~"%24");
-        fail_unless!(encode_component("%") == ~"%25");
-        fail_unless!(encode_component("&") == ~"%26");
-        fail_unless!(encode_component("'") == ~"%27");
-        fail_unless!(encode_component("(") == ~"%28");
-        fail_unless!(encode_component(")") == ~"%29");
-        fail_unless!(encode_component("*") == ~"%2A");
-        fail_unless!(encode_component("+") == ~"%2B");
-        fail_unless!(encode_component(",") == ~"%2C");
-        fail_unless!(encode_component("/") == ~"%2F");
-        fail_unless!(encode_component(":") == ~"%3A");
-        fail_unless!(encode_component(";") == ~"%3B");
-        fail_unless!(encode_component("=") == ~"%3D");
-        fail_unless!(encode_component("?") == ~"%3F");
-        fail_unless!(encode_component("@") == ~"%40");
-        fail_unless!(encode_component("[") == ~"%5B");
-        fail_unless!(encode_component("]") == ~"%5D");
+        assert!(encode_component(" ") == ~"%20");
+        assert!(encode_component("!") == ~"%21");
+        assert!(encode_component("#") == ~"%23");
+        assert!(encode_component("$") == ~"%24");
+        assert!(encode_component("%") == ~"%25");
+        assert!(encode_component("&") == ~"%26");
+        assert!(encode_component("'") == ~"%27");
+        assert!(encode_component("(") == ~"%28");
+        assert!(encode_component(")") == ~"%29");
+        assert!(encode_component("*") == ~"%2A");
+        assert!(encode_component("+") == ~"%2B");
+        assert!(encode_component(",") == ~"%2C");
+        assert!(encode_component("/") == ~"%2F");
+        assert!(encode_component(":") == ~"%3A");
+        assert!(encode_component(";") == ~"%3B");
+        assert!(encode_component("=") == ~"%3D");
+        assert!(encode_component("?") == ~"%3F");
+        assert!(encode_component("@") == ~"%40");
+        assert!(encode_component("[") == ~"%5B");
+        assert!(encode_component("]") == ~"%5D");
     }
 
     #[test]
     pub fn test_decode() {
-        fail_unless!(decode("") == ~"");
-        fail_unless!(decode("abc/def 123") == ~"abc/def 123");
-        fail_unless!(decode("abc%2Fdef%20123") == ~"abc%2Fdef 123");
-        fail_unless!(decode("%20") == ~" ");
-        fail_unless!(decode("%21") == ~"%21");
-        fail_unless!(decode("%22") == ~"%22");
-        fail_unless!(decode("%23") == ~"%23");
-        fail_unless!(decode("%24") == ~"%24");
-        fail_unless!(decode("%25") == ~"%");
-        fail_unless!(decode("%26") == ~"%26");
-        fail_unless!(decode("%27") == ~"'");
-        fail_unless!(decode("%28") == ~"%28");
-        fail_unless!(decode("%29") == ~"%29");
-        fail_unless!(decode("%2A") == ~"%2A");
-        fail_unless!(decode("%2B") == ~"%2B");
-        fail_unless!(decode("%2C") == ~"%2C");
-        fail_unless!(decode("%2F") == ~"%2F");
-        fail_unless!(decode("%3A") == ~"%3A");
-        fail_unless!(decode("%3B") == ~"%3B");
-        fail_unless!(decode("%3D") == ~"%3D");
-        fail_unless!(decode("%3F") == ~"%3F");
-        fail_unless!(decode("%40") == ~"%40");
-        fail_unless!(decode("%5B") == ~"%5B");
-        fail_unless!(decode("%5D") == ~"%5D");
+        assert!(decode("") == ~"");
+        assert!(decode("abc/def 123") == ~"abc/def 123");
+        assert!(decode("abc%2Fdef%20123") == ~"abc%2Fdef 123");
+        assert!(decode("%20") == ~" ");
+        assert!(decode("%21") == ~"%21");
+        assert!(decode("%22") == ~"%22");
+        assert!(decode("%23") == ~"%23");
+        assert!(decode("%24") == ~"%24");
+        assert!(decode("%25") == ~"%");
+        assert!(decode("%26") == ~"%26");
+        assert!(decode("%27") == ~"'");
+        assert!(decode("%28") == ~"%28");
+        assert!(decode("%29") == ~"%29");
+        assert!(decode("%2A") == ~"%2A");
+        assert!(decode("%2B") == ~"%2B");
+        assert!(decode("%2C") == ~"%2C");
+        assert!(decode("%2F") == ~"%2F");
+        assert!(decode("%3A") == ~"%3A");
+        assert!(decode("%3B") == ~"%3B");
+        assert!(decode("%3D") == ~"%3D");
+        assert!(decode("%3F") == ~"%3F");
+        assert!(decode("%40") == ~"%40");
+        assert!(decode("%5B") == ~"%5B");
+        assert!(decode("%5D") == ~"%5D");
     }
 
     #[test]
     pub fn test_decode_component() {
-        fail_unless!(decode_component("") == ~"");
-        fail_unless!(decode_component("abc/def 123") == ~"abc/def 123");
-        fail_unless!(decode_component("abc%2Fdef%20123") == ~"abc/def 123");
-        fail_unless!(decode_component("%20") == ~" ");
-        fail_unless!(decode_component("%21") == ~"!");
-        fail_unless!(decode_component("%22") == ~"\"");
-        fail_unless!(decode_component("%23") == ~"#");
-        fail_unless!(decode_component("%24") == ~"$");
-        fail_unless!(decode_component("%25") == ~"%");
-        fail_unless!(decode_component("%26") == ~"&");
-        fail_unless!(decode_component("%27") == ~"'");
-        fail_unless!(decode_component("%28") == ~"(");
-        fail_unless!(decode_component("%29") == ~")");
-        fail_unless!(decode_component("%2A") == ~"*");
-        fail_unless!(decode_component("%2B") == ~"+");
-        fail_unless!(decode_component("%2C") == ~",");
-        fail_unless!(decode_component("%2F") == ~"/");
-        fail_unless!(decode_component("%3A") == ~":");
-        fail_unless!(decode_component("%3B") == ~";");
-        fail_unless!(decode_component("%3D") == ~"=");
-        fail_unless!(decode_component("%3F") == ~"?");
-        fail_unless!(decode_component("%40") == ~"@");
-        fail_unless!(decode_component("%5B") == ~"[");
-        fail_unless!(decode_component("%5D") == ~"]");
+        assert!(decode_component("") == ~"");
+        assert!(decode_component("abc/def 123") == ~"abc/def 123");
+        assert!(decode_component("abc%2Fdef%20123") == ~"abc/def 123");
+        assert!(decode_component("%20") == ~" ");
+        assert!(decode_component("%21") == ~"!");
+        assert!(decode_component("%22") == ~"\"");
+        assert!(decode_component("%23") == ~"#");
+        assert!(decode_component("%24") == ~"$");
+        assert!(decode_component("%25") == ~"%");
+        assert!(decode_component("%26") == ~"&");
+        assert!(decode_component("%27") == ~"'");
+        assert!(decode_component("%28") == ~"(");
+        assert!(decode_component("%29") == ~")");
+        assert!(decode_component("%2A") == ~"*");
+        assert!(decode_component("%2B") == ~"+");
+        assert!(decode_component("%2C") == ~",");
+        assert!(decode_component("%2F") == ~"/");
+        assert!(decode_component("%3A") == ~":");
+        assert!(decode_component("%3B") == ~";");
+        assert!(decode_component("%3D") == ~"=");
+        assert!(decode_component("%3F") == ~"?");
+        assert!(decode_component("%40") == ~"@");
+        assert!(decode_component("%5B") == ~"[");
+        assert!(decode_component("%5D") == ~"]");
     }
 
     #[test]
     pub fn test_encode_form_urlencoded() {
         let mut m = LinearMap::new();
-        fail_unless!(encode_form_urlencoded(&m) == ~"");
+        assert!(encode_form_urlencoded(&m) == ~"");
 
         m.insert(~"", ~[]);
         m.insert(~"foo", ~[]);
-        fail_unless!(encode_form_urlencoded(&m) == ~"");
+        assert!(encode_form_urlencoded(&m) == ~"");
 
         let mut m = LinearMap::new();
         m.insert(~"foo", ~[~"bar", ~"123"]);
-        fail_unless!(encode_form_urlencoded(&m) == ~"foo=bar&foo=123");
+        assert!(encode_form_urlencoded(&m) == ~"foo=bar&foo=123");
 
         let mut m = LinearMap::new();
         m.insert(~"foo bar", ~[~"abc", ~"12 = 34"]);
-        fail_unless!(encode_form_urlencoded(&m) ==
+        assert!(encode_form_urlencoded(&m) ==
             ~"foo+bar=abc&foo+bar=12+%3D+34");
     }
 
@@ -1075,13 +1075,13 @@ mod tests {
         // FIXME #4449: Commented out because this causes an ICE, but only
         // on FreeBSD
         /*
-        fail_unless!(decode_form_urlencoded(~[]).len() == 0);
+        assert!(decode_form_urlencoded(~[]).len() == 0);
 
         let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34");
         let form = decode_form_urlencoded(s);
-        fail_unless!(form.len() == 2);
-        fail_unless!(form.get_ref(&~"a") == &~[~"1"]);
-        fail_unless!(form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"]);
+        assert!(form.len() == 2);
+        assert!(form.get_ref(&~"a") == &~[~"1"]);
+        assert!(form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"]);
         */
     }
 }
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 6f69ac4e1bd..bb83cfc494b 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -68,7 +68,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
                             cast::reinterpret_cast(&slice);
                         info!("slice: %?",
                                        (base, vec::len(slice), end - base));
-                        fail_unless!((vec::len(slice) == end - base));
+                        assert!((vec::len(slice) == end - base));
                         f(base, slice)
                     }
                 };
@@ -79,12 +79,12 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
         info!("tasks spawned");
 
         info!("num_tasks: %?", (num_tasks, futures.len()));
-        fail_unless!((num_tasks == futures.len()));
+        assert!((num_tasks == futures.len()));
 
         let r = do futures.map() |ys| {
             ys.get()
         };
-        fail_unless!((r.len() == futures.len()));
+        assert!((r.len() == futures.len()));
         r
     }
 }
@@ -115,7 +115,7 @@ pub fn mapi<A:Copy + Owned,B:Copy + Owned>(
     });
     let r = vec::concat(slices);
     info!("%?", (r.len(), xs.len()));
-    fail_unless!((r.len() == xs.len()));
+    assert!((r.len() == xs.len()));
     r
 }
 
diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs
index ff00d26882d..1fb79fcab28 100644
--- a/src/libstd/priority_queue.rs
+++ b/src/libstd/priority_queue.rs
@@ -197,87 +197,87 @@ mod tests {
         let mut sorted = merge_sort(data, le);
         let mut heap = from_vec(data);
         while !heap.is_empty() {
-            fail_unless!(heap.top() == sorted.last());
-            fail_unless!(heap.pop() == sorted.pop());
+            assert!(heap.top() == sorted.last());
+            assert!(heap.pop() == sorted.pop());
         }
     }
 
     #[test]
     fn test_push() {
         let mut heap = from_vec(~[2, 4, 9]);
-        fail_unless!(heap.len() == 3);
-        fail_unless!(*heap.top() == 9);
+        assert!(heap.len() == 3);
+        assert!(*heap.top() == 9);
         heap.push(11);
-        fail_unless!(heap.len() == 4);
-        fail_unless!(*heap.top() == 11);
+        assert!(heap.len() == 4);
+        assert!(*heap.top() == 11);
         heap.push(5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(*heap.top() == 11);
+        assert!(heap.len() == 5);
+        assert!(*heap.top() == 11);
         heap.push(27);
-        fail_unless!(heap.len() == 6);
-        fail_unless!(*heap.top() == 27);
+        assert!(heap.len() == 6);
+        assert!(*heap.top() == 27);
         heap.push(3);
-        fail_unless!(heap.len() == 7);
-        fail_unless!(*heap.top() == 27);
+        assert!(heap.len() == 7);
+        assert!(*heap.top() == 27);
         heap.push(103);
-        fail_unless!(heap.len() == 8);
-        fail_unless!(*heap.top() == 103);
+        assert!(heap.len() == 8);
+        assert!(*heap.top() == 103);
     }
 
     #[test]
     fn test_push_unique() {
         let mut heap = from_vec(~[~2, ~4, ~9]);
-        fail_unless!(heap.len() == 3);
-        fail_unless!(*heap.top() == ~9);
+        assert!(heap.len() == 3);
+        assert!(*heap.top() == ~9);
         heap.push(~11);
-        fail_unless!(heap.len() == 4);
-        fail_unless!(*heap.top() == ~11);
+        assert!(heap.len() == 4);
+        assert!(*heap.top() == ~11);
         heap.push(~5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(*heap.top() == ~11);
+        assert!(heap.len() == 5);
+        assert!(*heap.top() == ~11);
         heap.push(~27);
-        fail_unless!(heap.len() == 6);
-        fail_unless!(*heap.top() == ~27);
+        assert!(heap.len() == 6);
+        assert!(*heap.top() == ~27);
         heap.push(~3);
-        fail_unless!(heap.len() == 7);
-        fail_unless!(*heap.top() == ~27);
+        assert!(heap.len() == 7);
+        assert!(*heap.top() == ~27);
         heap.push(~103);
-        fail_unless!(heap.len() == 8);
-        fail_unless!(*heap.top() == ~103);
+        assert!(heap.len() == 8);
+        assert!(*heap.top() == ~103);
     }
 
     #[test]
     fn test_push_pop() {
         let mut heap = from_vec(~[5, 5, 2, 1, 3]);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.push_pop(6) == 6);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.push_pop(0) == 5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.push_pop(4) == 5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.push_pop(1) == 4);
-        fail_unless!(heap.len() == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.push_pop(6) == 6);
+        assert!(heap.len() == 5);
+        assert!(heap.push_pop(0) == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.push_pop(4) == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.push_pop(1) == 4);
+        assert!(heap.len() == 5);
     }
 
     #[test]
     fn test_replace() {
         let mut heap = from_vec(~[5, 5, 2, 1, 3]);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.replace(6) == 5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.replace(0) == 6);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.replace(4) == 5);
-        fail_unless!(heap.len() == 5);
-        fail_unless!(heap.replace(1) == 4);
-        fail_unless!(heap.len() == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.replace(6) == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.replace(0) == 6);
+        assert!(heap.len() == 5);
+        assert!(heap.replace(4) == 5);
+        assert!(heap.len() == 5);
+        assert!(heap.replace(1) == 4);
+        assert!(heap.len() == 5);
     }
 
     fn check_to_vec(data: ~[int]) {
         let heap = from_vec(data);
-        fail_unless!(merge_sort(heap.to_vec(), le) == merge_sort(data, le));
-        fail_unless!(heap.to_sorted_vec() == merge_sort(data, le));
+        assert!(merge_sort(heap.to_vec(), le) == merge_sort(data, le));
+        assert!(heap.to_sorted_vec() == merge_sort(data, le));
     }
 
     #[test]
@@ -305,7 +305,7 @@ mod tests {
     #[test]
     fn test_empty_maybe_pop() {
         let mut heap = new::<int>();
-        fail_unless!(heap.maybe_pop().is_none());
+        assert!(heap.maybe_pop().is_none());
     }
 
     #[test]
@@ -316,7 +316,7 @@ mod tests {
     #[test]
     fn test_empty_maybe_top() {
         let empty = new::<int>();
-        fail_unless!(empty.maybe_top().is_none());
+        assert!(empty.maybe_top().is_none());
     }
 
     #[test]
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 51cf08c8ca1..61f50069d89 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -704,7 +704,7 @@ pub mod node {
      */
     pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint,
                              char_len: uint) -> @Node {
-        fail_unless!((byte_start + byte_len <= str::len(*str)));
+        assert!((byte_start + byte_len <= str::len(*str)));
         let candidate = @Leaf(Leaf {
             byte_offset: byte_start,
             byte_len: byte_len,
@@ -1313,8 +1313,8 @@ mod tests {
 
     #[test]
     fn trivial() {
-        fail_unless!(char_len(empty()) == 0u);
-        fail_unless!(byte_len(empty()) == 0u);
+        assert!(char_len(empty()) == 0u);
+        assert!(byte_len(empty()) == 0u);
     }
 
     #[test]
@@ -1322,8 +1322,8 @@ mod tests {
         let sample = @~"0123456789ABCDE";
         let r      = of_str(sample);
 
-        fail_unless!(char_len(r) == str::char_len(*sample));
-        fail_unless!(rope_to_string(r) == *sample);
+        assert!(char_len(r) == str::char_len(*sample));
+        assert!(rope_to_string(r) == *sample);
     }
 
     #[test]
@@ -1338,8 +1338,8 @@ mod tests {
         }
         let sample = @*buf;
         let r      = of_str(sample);
-        fail_unless!(char_len(r) == str::char_len(*sample));
-        fail_unless!(rope_to_string(r) == *sample);
+        assert!(char_len(r) == str::char_len(*sample));
+        assert!(rope_to_string(r) == *sample);
 
         let mut string_iter = 0u;
         let string_len  = str::len(*sample);
@@ -1359,7 +1359,7 @@ mod tests {
             }
         }
 
-        fail_unless!(equal);
+        assert!(equal);
     }
 
     #[test]
@@ -1384,7 +1384,7 @@ mod tests {
             }
         }
 
-        fail_unless!(len == str::char_len(*sample));
+        assert!(len == str::char_len(*sample));
     }
 
     #[test]
@@ -1405,11 +1405,11 @@ mod tests {
         while i < 8 { r2 = append_rope(r2, r2); i+= 1;}
 
 
-        fail_unless!(eq(r1, r2));
+        assert!(eq(r1, r2));
         let r3 = bal(r2);
-        fail_unless!(char_len(r1) == char_len(r3));
+        assert!(char_len(r1) == char_len(r3));
 
-        fail_unless!(eq(r1, r3));
+        assert!(eq(r1, r3));
     }
 
     #[test]
@@ -1426,23 +1426,23 @@ mod tests {
         for uint::range(0u, char_len(r)) |i| {
             r2 = append_char(r2, char_at(r, i));
         }
-        fail_unless!(eq(r, r2));
+        assert!(eq(r, r2));
 
         let mut r3 = empty();
         for uint::range(0u, char_len(r)) |i| {
             r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u));
         }
-        fail_unless!(eq(r, r3));
+        assert!(eq(r, r3));
 
         //Additional sanity checks
         let balr = bal(r);
         let bal2 = bal(r2);
         let bal3 = bal(r3);
-        fail_unless!(eq(r, balr));
-        fail_unless!(eq(r, bal2));
-        fail_unless!(eq(r, bal3));
-        fail_unless!(eq(r2, r3));
-        fail_unless!(eq(bal2, bal3));
+        assert!(eq(r, balr));
+        assert!(eq(r, bal2));
+        assert!(eq(r, bal3));
+        assert!(eq(r2, r3));
+        assert!(eq(bal2, bal3));
     }
 
     #[test]
@@ -1457,6 +1457,6 @@ mod tests {
         //Same rope, obtained with rope::concat
         let r2 = concat(vec::from_elem(10u, chunk));
 
-        fail_unless!(eq(r, r2));
+        assert!(eq(r, r2));
     }
 }
diff --git a/src/libstd/semver.rs b/src/libstd/semver.rs
index 50579db4707..83fab365d8d 100644
--- a/src/libstd/semver.rs
+++ b/src/libstd/semver.rs
@@ -239,74 +239,74 @@ pub fn parse(s: &str) -> Option<Version> {
 
 #[test]
 fn test_parse() {
-    fail_unless!(parse("") == None);
-    fail_unless!(parse("  ") == None);
-    fail_unless!(parse("1") == None);
-    fail_unless!(parse("1.2") == None);
-    fail_unless!(parse("1.2") == None);
-    fail_unless!(parse("1") == None);
-    fail_unless!(parse("1.2") == None);
-    fail_unless!(parse("1.2.3-") == None);
-    fail_unless!(parse("a.b.c") == None);
-    fail_unless!(parse("1.2.3 abc") == None);
-
-    fail_unless!(parse("1.2.3") == Some(Version {
+    assert!(parse("") == None);
+    assert!(parse("  ") == None);
+    assert!(parse("1") == None);
+    assert!(parse("1.2") == None);
+    assert!(parse("1.2") == None);
+    assert!(parse("1") == None);
+    assert!(parse("1.2") == None);
+    assert!(parse("1.2.3-") == None);
+    assert!(parse("a.b.c") == None);
+    assert!(parse("1.2.3 abc") == None);
+
+    assert!(parse("1.2.3") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[],
         build: ~[],
     }));
-    fail_unless!(parse("  1.2.3  ") == Some(Version {
+    assert!(parse("  1.2.3  ") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[],
         build: ~[],
     }));
-    fail_unless!(parse("1.2.3-alpha1") == Some(Version {
+    assert!(parse("1.2.3-alpha1") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[AlphaNumeric(~"alpha1")],
         build: ~[]
     }));
-    fail_unless!(parse("  1.2.3-alpha1  ") == Some(Version {
+    assert!(parse("  1.2.3-alpha1  ") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[AlphaNumeric(~"alpha1")],
         build: ~[]
     }));
-    fail_unless!(parse("1.2.3+build5") == Some(Version {
+    assert!(parse("1.2.3+build5") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[],
         build: ~[AlphaNumeric(~"build5")]
     }));
-    fail_unless!(parse("  1.2.3+build5  ") == Some(Version {
+    assert!(parse("  1.2.3+build5  ") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[],
         build: ~[AlphaNumeric(~"build5")]
     }));
-    fail_unless!(parse("1.2.3-alpha1+build5") == Some(Version {
+    assert!(parse("1.2.3-alpha1+build5") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[AlphaNumeric(~"alpha1")],
         build: ~[AlphaNumeric(~"build5")]
     }));
-    fail_unless!(parse("  1.2.3-alpha1+build5  ") == Some(Version {
+    assert!(parse("  1.2.3-alpha1+build5  ") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
         pre: ~[AlphaNumeric(~"alpha1")],
         build: ~[AlphaNumeric(~"build5")]
     }));
-    fail_unless!(parse("1.2.3-1.alpha1.9+build5.7.3aedf  ") == Some(Version {
+    assert!(parse("1.2.3-1.alpha1.9+build5.7.3aedf  ") == Some(Version {
         major: 1u,
         minor: 2u,
         patch: 3u,
@@ -320,54 +320,54 @@ fn test_parse() {
 
 #[test]
 fn test_eq() {
-    fail_unless!(parse("1.2.3")        == parse("1.2.3"));
-    fail_unless!(parse("1.2.3-alpha1") == parse("1.2.3-alpha1"));
+    assert!(parse("1.2.3")        == parse("1.2.3"));
+    assert!(parse("1.2.3-alpha1") == parse("1.2.3-alpha1"));
 }
 
 #[test]
 fn test_ne() {
-    fail_unless!(parse("0.0.0")       != parse("0.0.1"));
-    fail_unless!(parse("0.0.0")       != parse("0.1.0"));
-    fail_unless!(parse("0.0.0")       != parse("1.0.0"));
-    fail_unless!(parse("1.2.3-alpha") != parse("1.2.3-beta"));
+    assert!(parse("0.0.0")       != parse("0.0.1"));
+    assert!(parse("0.0.0")       != parse("0.1.0"));
+    assert!(parse("0.0.0")       != parse("1.0.0"));
+    assert!(parse("1.2.3-alpha") != parse("1.2.3-beta"));
 }
 
 #[test]
 fn test_lt() {
-    fail_unless!(parse("0.0.0")        < parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.0.0")        < parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.2.0")        < parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.2.3-alpha1") < parse("1.2.3"));
-    fail_unless!(parse("1.2.3-alpha1") < parse("1.2.3-alpha2"));
-    fail_unless!(!(parse("1.2.3-alpha2") < parse("1.2.3-alpha2")));
+    assert!(parse("0.0.0")        < parse("1.2.3-alpha2"));
+    assert!(parse("1.0.0")        < parse("1.2.3-alpha2"));
+    assert!(parse("1.2.0")        < parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3-alpha1") < parse("1.2.3"));
+    assert!(parse("1.2.3-alpha1") < parse("1.2.3-alpha2"));
+    assert!(!(parse("1.2.3-alpha2") < parse("1.2.3-alpha2")));
 }
 
 #[test]
 fn test_le() {
-    fail_unless!(parse("0.0.0")        <= parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.0.0")        <= parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.2.0")        <= parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.2.3-alpha1") <= parse("1.2.3-alpha2"));
-    fail_unless!(parse("1.2.3-alpha2") <= parse("1.2.3-alpha2"));
+    assert!(parse("0.0.0")        <= parse("1.2.3-alpha2"));
+    assert!(parse("1.0.0")        <= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.0")        <= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3-alpha1") <= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3-alpha2") <= parse("1.2.3-alpha2"));
 }
 
 #[test]
 fn test_gt() {
-    fail_unless!(parse("1.2.3-alpha2") > parse("0.0.0"));
-    fail_unless!(parse("1.2.3-alpha2") > parse("1.0.0"));
-    fail_unless!(parse("1.2.3-alpha2") > parse("1.2.0"));
-    fail_unless!(parse("1.2.3-alpha2") > parse("1.2.3-alpha1"));
-    fail_unless!(parse("1.2.3")        > parse("1.2.3-alpha2"));
-    fail_unless!(!(parse("1.2.3-alpha2") > parse("1.2.3-alpha2")));
+    assert!(parse("1.2.3-alpha2") > parse("0.0.0"));
+    assert!(parse("1.2.3-alpha2") > parse("1.0.0"));
+    assert!(parse("1.2.3-alpha2") > parse("1.2.0"));
+    assert!(parse("1.2.3-alpha2") > parse("1.2.3-alpha1"));
+    assert!(parse("1.2.3")        > parse("1.2.3-alpha2"));
+    assert!(!(parse("1.2.3-alpha2") > parse("1.2.3-alpha2")));
 }
 
 #[test]
 fn test_ge() {
-    fail_unless!(parse("1.2.3-alpha2") >= parse("0.0.0"));
-    fail_unless!(parse("1.2.3-alpha2") >= parse("1.0.0"));
-    fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.0"));
-    fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha1"));
-    fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3-alpha2") >= parse("0.0.0"));
+    assert!(parse("1.2.3-alpha2") >= parse("1.0.0"));
+    assert!(parse("1.2.3-alpha2") >= parse("1.2.0"));
+    assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha1"));
+    assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha2"));
 }
 
 #[test]
@@ -388,7 +388,7 @@ fn test_spec_order() {
     while i < vs.len() {
         let a = parse(vs[i-1]).get();
         let b = parse(vs[i]).get();
-        fail_unless!(a < b);
+        assert!(a < b);
         i += 1;
     }
 }
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index b603e2eb1cc..1a2d4a87d98 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -74,7 +74,7 @@ pub fn sha1() -> @Sha1 {
           work_buf: @mut ~[u32]};
 
     fn add_input(st: &mut Sha1State, msg: &const [u8]) {
-        fail_unless!((!st.computed));
+        assert!((!st.computed));
         for vec::each_const(msg) |element| {
             st.msg_block[st.msg_block_idx] = *element;
             st.msg_block_idx += 1u;
@@ -90,8 +90,8 @@ pub fn sha1() -> @Sha1 {
         }
     }
     fn process_msg_block(st: &mut Sha1State) {
-        fail_unless!((vec::len(st.h) == digest_buf_len));
-        fail_unless!((vec::uniq_len(st.work_buf) == work_buf_len));
+        assert!((vec::len(st.h) == digest_buf_len));
+        assert!((vec::uniq_len(st.work_buf) == work_buf_len));
         let mut t: int; // Loop counter
         let mut w = st.work_buf;
 
@@ -192,7 +192,7 @@ pub fn sha1() -> @Sha1 {
      * can be assumed that the message digest has been computed.
      */
     fn pad_msg(st: &mut Sha1State) {
-        fail_unless!((vec::len((*st).msg_block) == msg_block_len));
+        assert!((vec::len((*st).msg_block) == msg_block_len));
 
         /*
          * Check to see if the current message block is too small to hold
@@ -230,7 +230,7 @@ pub fn sha1() -> @Sha1 {
 
     impl Sha1 for Sha1State {
         fn reset(&mut self) {
-            fail_unless!((vec::len(self.h) == digest_buf_len));
+            assert!((vec::len(self.h) == digest_buf_len));
             self.len_low = 0u32;
             self.len_high = 0u32;
             self.msg_block_idx = 0u;
@@ -366,13 +366,13 @@ mod tests {
             ];
             let tests = fips_180_1_tests + wikipedia_tests;
             fn check_vec_eq(v0: ~[u8], v1: ~[u8]) {
-                fail_unless!((vec::len::<u8>(v0) == vec::len::<u8>(v1)));
+                assert!((vec::len::<u8>(v0) == vec::len::<u8>(v1)));
                 let len = vec::len::<u8>(v0);
                 let mut i = 0u;
                 while i < len {
                     let a = v0[i];
                     let b = v1[i];
-                    fail_unless!((a == b));
+                    assert!((a == b));
                     i += 1u;
                 }
             }
@@ -385,8 +385,8 @@ mod tests {
                 check_vec_eq(t.output, out);
 
                 let out_str = sh.result_str();
-                fail_unless!((out_str.len() == 40));
-                fail_unless!((out_str == t.output_str));
+                assert!((out_str.len() == 40));
+                assert!((out_str == t.output_str));
 
                 sh.reset();
             }
@@ -406,8 +406,8 @@ mod tests {
                 check_vec_eq(t.output, out);
 
                 let out_str = sh.result_str();
-                fail_unless!((out_str.len() == 40));
-                fail_unless!((out_str == t.output_str));
+                assert!((out_str.len() == 40));
+                assert!((out_str == t.output_str));
 
                 sh.reset();
             }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 16f7c0ba860..b6c5ec03068 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -177,9 +177,9 @@ mod tests {
     #[test]
     fn test_find_mut() {
         let mut m = SmallIntMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
+        assert!(m.insert(1, 12));
+        assert!(m.insert(2, 8));
+        assert!(m.insert(5, 14));
         let new = 100;
         match m.find_mut(&5) {
             None => fail!(), Some(x) => *x = new
@@ -190,30 +190,30 @@ mod tests {
     #[test]
     fn test_len() {
         let mut map = SmallIntMap::new();
-        fail_unless!(map.len() == 0);
-        fail_unless!(map.is_empty());
-        fail_unless!(map.insert(5, 20));
-        fail_unless!(map.len() == 1);
-        fail_unless!(!map.is_empty());
-        fail_unless!(map.insert(11, 12));
-        fail_unless!(map.len() == 2);
-        fail_unless!(!map.is_empty());
-        fail_unless!(map.insert(14, 22));
-        fail_unless!(map.len() == 3);
-        fail_unless!(!map.is_empty());
+        assert!(map.len() == 0);
+        assert!(map.is_empty());
+        assert!(map.insert(5, 20));
+        assert!(map.len() == 1);
+        assert!(!map.is_empty());
+        assert!(map.insert(11, 12));
+        assert!(map.len() == 2);
+        assert!(!map.is_empty());
+        assert!(map.insert(14, 22));
+        assert!(map.len() == 3);
+        assert!(!map.is_empty());
     }
 
     #[test]
     fn test_clear() {
         let mut map = SmallIntMap::new();
-        fail_unless!(map.insert(5, 20));
-        fail_unless!(map.insert(11, 12));
-        fail_unless!(map.insert(14, 22));
+        assert!(map.insert(5, 20));
+        assert!(map.insert(11, 12));
+        assert!(map.insert(14, 22));
         map.clear();
-        fail_unless!(map.is_empty());
-        fail_unless!(map.find(&5).is_none());
-        fail_unless!(map.find(&11).is_none());
-        fail_unless!(map.find(&14).is_none());
+        assert!(map.is_empty());
+        assert!(map.find(&5).is_none());
+        assert!(map.find(&11).is_none());
+        assert!(map.find(&14).is_none());
     }
 
     #[test]
@@ -238,11 +238,11 @@ mod tests {
         map.update_with_key(3, 2, addMoreToCount);
 
         // check the total counts
-        fail_unless!(map.find(&3).get() == &10);
-        fail_unless!(map.find(&5).get() == &3);
-        fail_unless!(map.find(&9).get() == &1);
+        assert!(map.find(&3).get() == &10);
+        assert!(map.find(&5).get() == &3);
+        assert!(map.find(&9).get() == &1);
 
         // sadly, no sevens were counted
-        fail_unless!(map.find(&7).is_none());
+        assert!(map.find(&7).is_none());
     }
 }
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 761a17352a9..40a12895175 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -223,7 +223,7 @@ pub fn tim_sort<T:Copy + Ord>(array: &mut [T]) {
 fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) {
     let size = array.len();
     let mut start = start;
-    fail_unless!(start <= size);
+    assert!(start <= size);
 
     if start == 0 { start += 1; }
 
@@ -231,7 +231,7 @@ fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) {
         let pivot = array[start];
         let mut left = 0;
         let mut right = start;
-        fail_unless!(left <= right);
+        assert!(left <= right);
 
         while left < right {
             let mid = (left + right) >> 1;
@@ -241,7 +241,7 @@ fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) {
                 left = mid+1;
             }
         }
-        fail_unless!(left == right);
+        assert!(left == right);
         let mut n = start-left;
 
         copy_vec(array, left+1, array, left, n);
@@ -272,7 +272,7 @@ fn min_run_length(n: uint) -> uint {
 
 fn count_run_ascending<T:Copy + Ord>(array: &mut [T]) -> uint {
     let size = array.len();
-    fail_unless!(size > 0);
+    assert!(size > 0);
     if size == 1 { return 1; }
 
     let mut run = 2;
@@ -295,7 +295,7 @@ fn gallop_left<T:Copy + Ord>(key: &const T,
                              hint: uint)
                           -> uint {
     let size = array.len();
-    fail_unless!(size != 0 && hint < size);
+    assert!(size != 0 && hint < size);
 
     let mut last_ofs = 0;
     let mut ofs = 1;
@@ -326,7 +326,7 @@ fn gallop_left<T:Copy + Ord>(key: &const T,
         last_ofs = hint - ofs;
         ofs = hint - tmp;
     }
-    fail_unless!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
+    assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
 
     last_ofs += 1;
     while last_ofs < ofs {
@@ -337,7 +337,7 @@ fn gallop_left<T:Copy + Ord>(key: &const T,
             ofs = m;
         }
     }
-    fail_unless!(last_ofs == ofs);
+    assert!(last_ofs == ofs);
     return ofs;
 }
 
@@ -346,7 +346,7 @@ fn gallop_right<T:Copy + Ord>(key: &const T,
                               hint: uint)
                            -> uint {
     let size = array.len();
-    fail_unless!(size != 0 && hint < size);
+    assert!(size != 0 && hint < size);
 
     let mut last_ofs = 0;
     let mut ofs = 1;
@@ -378,7 +378,7 @@ fn gallop_right<T:Copy + Ord>(key: &const T,
         ofs = hint - tmp;
     }
 
-    fail_unless!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
+    assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size);
 
     last_ofs += 1;
     while last_ofs < ofs {
@@ -390,7 +390,7 @@ fn gallop_right<T:Copy + Ord>(key: &const T,
             ofs = m;
         }
     }
-    fail_unless!(last_ofs == ofs);
+    assert!(last_ofs == ofs);
     return ofs;
 }
 
@@ -420,16 +420,16 @@ impl<T:Copy + Ord> MergeState<T> {
 
     fn merge_at(&mut self, n: uint, array: &mut [T]) {
         let mut size = self.runs.len();
-        fail_unless!(size >= 2);
-        fail_unless!(n == size-2 || n == size-3);
+        assert!(size >= 2);
+        assert!(n == size-2 || n == size-3);
 
         let mut b1 = self.runs[n].base;
         let mut l1 = self.runs[n].len;
         let b2 = self.runs[n+1].base;
         let l2 = self.runs[n+1].len;
 
-        fail_unless!(l1 > 0 && l2 > 0);
-        fail_unless!(b1 + l1 == b2);
+        assert!(l1 > 0 && l2 > 0);
+        assert!(b1 + l1 == b2);
 
         self.runs[n].len = l1 + l2;
         if n == size-3 {
@@ -458,7 +458,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
     fn merge_lo(&mut self, array: &mut [T], base1: uint, len1: uint,
                 base2: uint, len2: uint) {
-        fail_unless!(len1 != 0 && len2 != 0 && base1+len1 == base2);
+        assert!(len1 != 0 && len2 != 0 && base1+len1 == base2);
 
         let mut tmp = ~[];
         for uint::range(base1, base1+len1) |i| {
@@ -491,7 +491,7 @@ impl<T:Copy + Ord> MergeState<T> {
             let mut break_outer = false;
 
             loop {
-                fail_unless!(len1 > 1 && len2 != 0);
+                assert!(len1 > 1 && len2 != 0);
                 if array[c2] < tmp[c1] {
                     array[dest] <-> array[c2];
                     dest += 1; c2 += 1; len2 -= 1;
@@ -515,7 +515,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
             // Start to gallop
             loop {
-                fail_unless!(len1 > 1 && len2 != 0);
+                assert!(len1 > 1 && len2 != 0);
 
                 let tmp_view = vec::const_slice(tmp, c1, c1+len1);
                 count1 = gallop_right(&const array[c2], tmp_view, 0);
@@ -550,21 +550,21 @@ impl<T:Copy + Ord> MergeState<T> {
         self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop };
 
         if len1 == 1 {
-            fail_unless!(len2 > 0);
+            assert!(len2 > 0);
             copy_vec(array, dest, array, c2, len2);
             array[dest+len2] <-> tmp[c1];
         } else if len1 == 0 {
             fail!(~"Comparison violates its contract!");
         } else {
-            fail_unless!(len2 == 0);
-            fail_unless!(len1 > 1);
+            assert!(len2 == 0);
+            assert!(len1 > 1);
             copy_vec(array, dest, tmp, c1, len1);
         }
     }
 
     fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint,
                 base2: uint, len2: uint) {
-        fail_unless!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
+        assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
 
         let mut tmp = ~[];
         for uint::range(base2, base2+len2) |i| {
@@ -599,7 +599,7 @@ impl<T:Copy + Ord> MergeState<T> {
             let mut break_outer = false;
 
             loop {
-                fail_unless!(len1 != 0 && len2 > 1);
+                assert!(len1 != 0 && len2 > 1);
                 if tmp[c2] < array[c1] {
                     array[dest] <-> array[c1];
                     dest -= 1; c1 -= 1; len1 -= 1;
@@ -623,7 +623,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
             // Start to gallop
             loop {
-                fail_unless!(len2 > 1 && len1 != 0);
+                assert!(len2 > 1 && len1 != 0);
 
                 let tmp_view = vec::mut_slice(array, base1, base1+len1);
                 count1 = len1 - gallop_right(
@@ -669,7 +669,7 @@ impl<T:Copy + Ord> MergeState<T> {
         self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop };
 
         if len2 == 1 {
-            fail_unless!(len1 > 0);
+            assert!(len1 > 0);
             dest -= len1;
             c1 -= len1;
             copy_vec(array, dest+1, array, c1+1, len1);
@@ -677,8 +677,8 @@ impl<T:Copy + Ord> MergeState<T> {
         } else if len2 == 0 {
             fail!(~"Comparison violates its contract!");
         } else {
-            fail_unless!(len1 == 0);
-            fail_unless!(len2 != 0);
+            assert!(len1 == 0);
+            assert!(len2 != 0);
             copy_vec(array, dest-(len2-1), tmp, 0, len2);
         }
     }
@@ -718,7 +718,7 @@ fn copy_vec<T:Copy>(dest: &mut [T],
                     from: &const [T],
                     s2: uint,
                     len: uint) {
-    fail_unless!(s1+len <= dest.len() && s2+len <= from.len());
+    assert!(s1+len <= dest.len() && s2+len <= from.len());
 
     let mut slice = ~[];
     for uint::range(s2, s2+len) |i| {
@@ -742,7 +742,7 @@ mod test_qsort3 {
         let mut i = 0;
         while i < len {
             // debug!(v2[i]);
-            fail_unless!((v2[i] == v1[i]));
+            assert!((v2[i] == v1[i]));
             i += 1;
         }
     }
@@ -787,7 +787,7 @@ mod test_qsort {
         let mut i = 0u;
         while i < len {
             // debug!(v2[i]);
-            fail_unless!((v2[i] == v1[i]));
+            assert!((v2[i] == v1[i]));
             i += 1;
         }
     }
@@ -832,7 +832,7 @@ mod test_qsort {
         for vec::each(pairs) |p| {
             let (a, b) = *p;
             debug!("%d %d", a, b);
-            fail_unless!((a == b));
+            assert!((a == b));
         }
     }
 }
@@ -853,7 +853,7 @@ mod tests {
         let mut i = 0u;
         while i < len {
             debug!(v3[i]);
-            fail_unless!((v3[i] == v2[i]));
+            assert!((v3[i] == v2[i]));
             i += 1;
         }
     }
@@ -880,7 +880,7 @@ mod tests {
         pub fn le(a: &int, b: &int) -> bool { *a <= *b }
         let mut v1 = ~[3, 2, 1];
         let v2 = merge_sort(v1, le);
-        fail_unless!(v2 == ~[1, 2, 3]);
+        assert!(v2 == ~[1, 2, 3]);
     }
 
     #[test]
@@ -901,7 +901,7 @@ mod tests {
         let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob",
                        "JOE Bob", "JOE BOB", "Sally Mae"];
         let names3 = merge_sort(names1, ile);
-        fail_unless!(names3 == names2);
+        assert!(names3 == names2);
     }
 }
 
@@ -938,7 +938,7 @@ mod test_tim_sort {
         let mut i = 0u;
         while i < len {
             // debug!(v2[i]);
-            fail_unless!((v2[i] == v1[i]));
+            assert!((v2[i] == v1[i]));
             i += 1u;
         }
     }
diff --git a/src/libstd/stats.rs b/src/libstd/stats.rs
index 04059a49511..6513a671ab3 100644
--- a/src/libstd/stats.rs
+++ b/src/libstd/stats.rs
@@ -36,22 +36,22 @@ impl<'self> Stats for &'self [f64] {
     }
 
     fn min(self) -> f64 {
-        fail_unless!(self.len() != 0);
+        assert!(self.len() != 0);
         vec::foldl(self[0], self, |p,q| cmp::min(p, *q))
     }
 
     fn max(self) -> f64 {
-        fail_unless!(self.len() != 0);
+        assert!(self.len() != 0);
         vec::foldl(self[0], self, |p,q| cmp::max(p, *q))
     }
 
     fn mean(self) -> f64 {
-        fail_unless!(self.len() != 0);
+        assert!(self.len() != 0);
         self.sum() / (self.len() as f64)
     }
 
     fn median(self) -> f64 {
-        fail_unless!(self.len() != 0);
+        assert!(self.len() != 0);
         let mut tmp = vec::from_slice(self);
         sort::tim_sort(tmp);
         if tmp.len() & 1 == 0 {
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index ea9455b1e98..99b3a122d9f 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -595,7 +595,7 @@ pub impl RWlock {
             do task::unkillable {
                 let mut first_reader = false;
                 do self.state.with |state| {
-                    fail_unless!(!state.read_mode);
+                    assert!(!state.read_mode);
                     state.read_mode = true;
                     first_reader = (state.read_count == 0);
                     state.read_count += 1;
@@ -626,8 +626,8 @@ impl<'self> Drop for RWlockReleaseRead<'self> {
             do task::unkillable {
                 let mut last_reader = false;
                 do self.lock.state.with |state| {
-                    fail_unless!(state.read_mode);
-                    fail_unless!(state.read_count > 0);
+                    assert!(state.read_mode);
+                    assert!(state.read_count > 0);
                     state.read_count -= 1;
                     if state.read_count == 0 {
                         last_reader = true;
@@ -663,7 +663,7 @@ impl<'self> Drop for RWlockReleaseDowngrade<'self> {
                 let mut writer_or_last_reader = false;
                 do self.lock.state.with |state| {
                     if state.read_mode {
-                        fail_unless!(state.read_count > 0);
+                        assert!(state.read_count > 0);
                         state.read_count -= 1;
                         if state.read_count == 0 {
                             // Case 1: Writer downgraded & was the last reader
@@ -852,7 +852,7 @@ mod tests {
         access_shared(sharedstate, m, 10);
         let _ = p.recv();
 
-        fail_unless!(*sharedstate == 20);
+        assert!(*sharedstate == 20);
 
         fn access_shared(sharedstate: &mut int, m: &Mutex, n: uint) {
             for n.times {
@@ -874,7 +874,7 @@ mod tests {
             do task::spawn || {
                 do m2.lock_cond |cond| {
                     let woken = cond.signal();
-                    fail_unless!(woken);
+                    assert!(woken);
                 }
             }
             cond.wait();
@@ -892,7 +892,7 @@ mod tests {
         let _ = port.recv(); // Wait until child gets in the mutex
         do m.lock_cond |cond| {
             let woken = cond.signal();
-            fail_unless!(woken);
+            assert!(woken);
         }
         let _ = port.recv(); // Wait until child wakes up
     }
@@ -918,7 +918,7 @@ mod tests {
         for ports.each |port| { let _ = port.recv(); }
         do m.lock_cond |cond| {
             let num_woken = cond.broadcast();
-            fail_unless!(num_woken == num_waiters);
+            assert!(num_woken == num_waiters);
         }
         // wait until all children wake up
         for ports.each |port| { let _ = port.recv(); }
@@ -939,7 +939,7 @@ mod tests {
             do m.lock_cond |_x| { }
         };
         do m2.lock_cond |cond| {
-            fail_unless!(!cond.signal());
+            assert!(!cond.signal());
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -953,7 +953,7 @@ mod tests {
                 fail!();
             }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         // child task must have finished by the time try returns
         do m.lock { }
     }
@@ -976,11 +976,11 @@ mod tests {
                 cond.wait(); // block forever
             }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         // child task must have finished by the time try returns
         do m.lock_cond |cond| {
             let woken = cond.signal();
-            fail_unless!(!woken);
+            assert!(!woken);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -1013,12 +1013,12 @@ mod tests {
             c.send(sibling_convos); // let parent wait on all children
             fail!();
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         // child task must have finished by the time try returns
         for vec::each(p.recv()) |p| { p.recv(); } // wait on all its siblings
         do m.lock_cond |cond| {
             let woken = cond.broadcast();
-            fail_unless!(woken == 0);
+            assert!(woken == 0);
         }
         struct SendOnFailure {
             c: comm::Chan<()>,
@@ -1069,7 +1069,7 @@ mod tests {
                 }
             }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
     }
     #[test] #[ignore(cfg(windows))]
     pub fn test_mutex_no_condvars() {
@@ -1077,17 +1077,17 @@ mod tests {
             let m = ~mutex_with_condvars(0);
             do m.lock_cond |cond| { cond.wait(); }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         let result = do task::try {
             let m = ~mutex_with_condvars(0);
             do m.lock_cond |cond| { cond.signal(); }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         let result = do task::try {
             let m = ~mutex_with_condvars(0);
             do m.lock_cond |cond| { cond.broadcast(); }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
     }
     /************************************************************************
      * Reader/writer lock tests
@@ -1129,7 +1129,7 @@ mod tests {
         access_shared(sharedstate, x, mode2, 10);
         let _ = p.recv();
 
-        fail_unless!(*sharedstate == 20);
+        assert!(*sharedstate == 20);
 
         fn access_shared(sharedstate: &mut int, x: &RWlock, mode: RWlockMode,
                          n: uint) {
@@ -1223,7 +1223,7 @@ mod tests {
             do task::spawn || {
                 do x2.write_cond |cond| {
                     let woken = cond.signal();
-                    fail_unless!(woken);
+                    assert!(woken);
                 }
             }
             cond.wait();
@@ -1242,7 +1242,7 @@ mod tests {
         do x.read { } // Must be able to get in as a reader in the meantime
         do x.write_cond |cond| { // Or as another writer
             let woken = cond.signal();
-            fail_unless!(woken);
+            assert!(woken);
         }
         let _ = port.recv(); // Wait until child wakes up
         do x.read { } // Just for good measure
@@ -1281,7 +1281,7 @@ mod tests {
         for ports.each |port| { let _ = port.recv(); }
         do lock_cond(x, dg2) |cond| {
             let num_woken = cond.broadcast();
-            fail_unless!(num_woken == num_waiters);
+            assert!(num_woken == num_waiters);
         }
         // wait until all children wake up
         for ports.each |port| { let _ = port.recv(); }
@@ -1308,7 +1308,7 @@ mod tests {
                 fail!();
             }
         };
-        fail_unless!(result.is_err());
+        assert!(result.is_err());
         // child task must have finished by the time try returns
         do lock_rwlock_in_mode(x, mode2) { }
     }
diff --git a/src/libstd/task_pool.rs b/src/libstd/task_pool.rs
index dbfe3d6a8b5..aed6721b78e 100644
--- a/src/libstd/task_pool.rs
+++ b/src/libstd/task_pool.rs
@@ -49,7 +49,7 @@ pub impl<T> TaskPool<T> {
            opt_sched_mode: Option<SchedMode>,
            init_fn_factory: ~fn() -> ~fn(uint) -> T)
         -> TaskPool<T> {
-        fail_unless!(n_tasks >= 1);
+        assert!(n_tasks >= 1);
 
         let channels = do vec::from_fn(n_tasks) |i| {
             let (port, chan) = comm::stream::<Msg<T>>();
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 7704ec158e5..895ccbc820b 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -30,5 +30,5 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
 fn test_mkdtemp() {
     let p = mkdtemp(&Path("."), "foobar").unwrap();
     os::remove_dir(&p);
-    fail_unless!(str::ends_with(p.to_str(), "foobar"));
+    assert!(str::ends_with(p.to_str(), "foobar"));
 }
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index a6c8884e05d..022f1f8564e 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -60,7 +60,7 @@ pub fn color_supported() -> bool {
 }
 
 pub fn set_color(writer: @io::Writer, first_char: u8, color: u8) {
-    fail_unless!((color < 16u8));
+    assert!((color < 16u8));
     esc(writer);
     let mut color = color;
     if color >= 8u8 { writer.write(~['1' as u8, ';' as u8]); color -= 8u8; }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 853a17abb55..7c5591d839e 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -282,7 +282,7 @@ pub fn run_tests_console(opts: &TestOpts,
 
     run_tests(opts, tests, |x| callback(&x, st));
 
-    fail_unless!(st.passed + st.failed +
+    assert!(st.passed + st.failed +
                  st.ignored + st.benchmarked == st.total);
     let success = st.failed == 0u;
 
@@ -403,7 +403,7 @@ fn should_sort_failures_before_printing_them() {
 
     let apos = str::find_str(s, ~"a").get();
     let bpos = str::find_str(s, ~"b").get();
-    fail_unless!(apos < bpos);
+    assert!(apos < bpos);
 }
 
 fn use_color() -> bool { return get_concurrency() == 1; }
@@ -797,7 +797,7 @@ mod tests {
         let ch = SharedChan(ch);
         run_test(false, desc, ch);
         let (_, res) = p.recv();
-        fail_unless!(res != TrOk);
+        assert!(res != TrOk);
     }
 
     #[test]
@@ -815,7 +815,7 @@ mod tests {
         let ch = SharedChan(ch);
         run_test(false, desc, ch);
         let (_, res) = p.recv();
-        fail_unless!(res == TrIgnored);
+        assert!(res == TrIgnored);
     }
 
     #[test]
@@ -834,7 +834,7 @@ mod tests {
         let ch = SharedChan(ch);
         run_test(false, desc, ch);
         let (_, res) = p.recv();
-        fail_unless!(res == TrOk);
+        assert!(res == TrOk);
     }
 
     #[test]
@@ -852,7 +852,7 @@ mod tests {
         let ch = SharedChan(ch);
         run_test(false, desc, ch);
         let (_, res) = p.recv();
-        fail_unless!(res == TrFailed);
+        assert!(res == TrFailed);
     }
 
     #[test]
@@ -862,7 +862,7 @@ mod tests {
           either::Left(copy o) => o,
           _ => fail!(~"Malformed arg in first_free_arg_should_be_a_filter")
         };
-        fail_unless!(~"filter" == opts.filter.get());
+        assert!(~"filter" == opts.filter.get());
     }
 
     #[test]
@@ -872,7 +872,7 @@ mod tests {
           either::Left(copy o) => o,
           _ => fail!(~"Malformed arg in parse_ignored_flag")
         };
-        fail_unless!((opts.run_ignored));
+        assert!((opts.run_ignored));
     }
 
     #[test]
@@ -912,9 +912,9 @@ mod tests {
         ];
         let filtered = filter_tests(&opts, tests);
 
-        fail_unless!((vec::len(filtered) == 1));
-        fail_unless!((filtered[0].desc.name.to_str() == ~"1"));
-        fail_unless!((filtered[0].desc.ignore == false));
+        assert!((vec::len(filtered) == 1));
+        assert!((filtered[0].desc.name.to_str() == ~"1"));
+        assert!((filtered[0].desc.ignore == false));
     }
 
     #[test]
@@ -969,7 +969,7 @@ mod tests {
         for vec::each(pairs) |p| {
             match *p {
                 (ref a, ref b) => {
-                    fail_unless!((*a == b.desc.name.to_str()));
+                    assert!((*a == b.desc.name.to_str()));
                 }
             }
         }
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 9ac302ed890..3af193e8748 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -53,7 +53,7 @@ pub struct Timespec { sec: i64, nsec: i32 }
  */
 pub impl Timespec {
     fn new(sec: i64, nsec: i32) -> Timespec {
-        fail_unless!(nsec >= 0 && nsec < NSEC_PER_SEC);
+        assert!(nsec >= 0 && nsec < NSEC_PER_SEC);
         Timespec { sec: sec, nsec: nsec }
     }
 }
@@ -883,17 +883,17 @@ mod tests {
         let tv1 = get_time();
         debug!("tv1=%? sec + %? nsec", tv1.sec as uint, tv1.nsec as uint);
 
-        fail_unless!(tv1.sec > some_recent_date);
-        fail_unless!(tv1.nsec < 1000000000i32);
+        assert!(tv1.sec > some_recent_date);
+        assert!(tv1.nsec < 1000000000i32);
 
         let tv2 = get_time();
         debug!("tv2=%? sec + %? nsec", tv2.sec as uint, tv2.nsec as uint);
 
-        fail_unless!(tv2.sec >= tv1.sec);
-        fail_unless!(tv2.sec < some_future_date);
-        fail_unless!(tv2.nsec < 1000000000i32);
+        assert!(tv2.sec >= tv1.sec);
+        assert!(tv2.sec < some_future_date);
+        assert!(tv2.nsec < 1000000000i32);
         if tv2.sec == tv1.sec {
-            fail_unless!(tv2.nsec >= tv1.nsec);
+            assert!(tv2.nsec >= tv1.nsec);
         }
     }
 
@@ -902,16 +902,16 @@ mod tests {
         let ns1 = precise_time_ns();
 
         debug!("s0=%s sec", float::to_str_digits(s0, 9u));
-        fail_unless!(s0 > 0.);
+        assert!(s0 > 0.);
         let ns0 = (s0 * 1000000000.) as u64;
         debug!("ns0=%? ns", ns0);
 
         debug!("ns1=%? ns", ns0);
-        fail_unless!(ns1 >= ns0);
+        assert!(ns1 >= ns0);
 
         let ns2 = precise_time_ns();
         debug!("ns2=%? ns", ns0);
-        fail_unless!(ns2 >= ns1);
+        assert!(ns2 >= ns1);
     }
 
     pub fn test_at_utc() {
@@ -921,18 +921,18 @@ mod tests {
         let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
-        fail_unless!(utc.tm_sec == 30_i32);
-        fail_unless!(utc.tm_min == 31_i32);
-        fail_unless!(utc.tm_hour == 23_i32);
-        fail_unless!(utc.tm_mday == 13_i32);
-        fail_unless!(utc.tm_mon == 1_i32);
-        fail_unless!(utc.tm_year == 109_i32);
-        fail_unless!(utc.tm_wday == 5_i32);
-        fail_unless!(utc.tm_yday == 43_i32);
-        fail_unless!(utc.tm_isdst == 0_i32);
-        fail_unless!(utc.tm_gmtoff == 0_i32);
-        fail_unless!(utc.tm_zone == ~"UTC");
-        fail_unless!(utc.tm_nsec == 54321_i32);
+        assert!(utc.tm_sec == 30_i32);
+        assert!(utc.tm_min == 31_i32);
+        assert!(utc.tm_hour == 23_i32);
+        assert!(utc.tm_mday == 13_i32);
+        assert!(utc.tm_mon == 1_i32);
+        assert!(utc.tm_year == 109_i32);
+        assert!(utc.tm_wday == 5_i32);
+        assert!(utc.tm_yday == 43_i32);
+        assert!(utc.tm_isdst == 0_i32);
+        assert!(utc.tm_gmtoff == 0_i32);
+        assert!(utc.tm_zone == ~"UTC");
+        assert!(utc.tm_nsec == 54321_i32);
     }
 
     pub fn test_at() {
@@ -944,23 +944,23 @@ mod tests {
 
         error!("time_at: %?", local);
 
-        fail_unless!(local.tm_sec == 30_i32);
-        fail_unless!(local.tm_min == 31_i32);
-        fail_unless!(local.tm_hour == 15_i32);
-        fail_unless!(local.tm_mday == 13_i32);
-        fail_unless!(local.tm_mon == 1_i32);
-        fail_unless!(local.tm_year == 109_i32);
-        fail_unless!(local.tm_wday == 5_i32);
-        fail_unless!(local.tm_yday == 43_i32);
-        fail_unless!(local.tm_isdst == 0_i32);
-        fail_unless!(local.tm_gmtoff == -28800_i32);
+        assert!(local.tm_sec == 30_i32);
+        assert!(local.tm_min == 31_i32);
+        assert!(local.tm_hour == 15_i32);
+        assert!(local.tm_mday == 13_i32);
+        assert!(local.tm_mon == 1_i32);
+        assert!(local.tm_year == 109_i32);
+        assert!(local.tm_wday == 5_i32);
+        assert!(local.tm_yday == 43_i32);
+        assert!(local.tm_isdst == 0_i32);
+        assert!(local.tm_gmtoff == -28800_i32);
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.
         let zone = &local.tm_zone;
-        fail_unless!(*zone == ~"PST" || *zone == ~"Pacific Standard Time");
+        assert!(*zone == ~"PST" || *zone == ~"Pacific Standard Time");
 
-        fail_unless!(local.tm_nsec == 54321_i32);
+        assert!(local.tm_nsec == 54321_i32);
     }
 
     pub fn test_to_timespec() {
@@ -970,8 +970,8 @@ mod tests {
         let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
-        fail_unless!(utc.to_timespec() == time);
-        fail_unless!(utc.to_local().to_timespec() == time);
+        assert!(utc.to_timespec() == time);
+        assert!(utc.to_local().to_timespec() == time);
     }
 
     pub fn test_conversions() {
@@ -982,12 +982,12 @@ mod tests {
         let utc = at_utc(time);
         let local = at(time);
 
-        fail_unless!(local.to_local() == local);
-        fail_unless!(local.to_utc() == utc);
-        fail_unless!(local.to_utc().to_local() == local);
-        fail_unless!(utc.to_utc() == utc);
-        fail_unless!(utc.to_local() == local);
-        fail_unless!(utc.to_local().to_utc() == utc);
+        assert!(local.to_local() == local);
+        assert!(local.to_utc() == utc);
+        assert!(local.to_utc().to_local() == local);
+        assert!(utc.to_utc() == utc);
+        assert!(utc.to_local() == local);
+        assert!(utc.to_local().to_utc() == utc);
     }
 
     pub fn test_strptime() {
@@ -996,41 +996,41 @@ mod tests {
 
         match strptime(~"", ~"") {
           Ok(ref tm) => {
-            fail_unless!(tm.tm_sec == 0_i32);
-            fail_unless!(tm.tm_min == 0_i32);
-            fail_unless!(tm.tm_hour == 0_i32);
-            fail_unless!(tm.tm_mday == 0_i32);
-            fail_unless!(tm.tm_mon == 0_i32);
-            fail_unless!(tm.tm_year == 0_i32);
-            fail_unless!(tm.tm_wday == 0_i32);
-            fail_unless!(tm.tm_isdst== 0_i32);
-            fail_unless!(tm.tm_gmtoff == 0_i32);
-            fail_unless!(tm.tm_zone == ~"");
-            fail_unless!(tm.tm_nsec == 0_i32);
+            assert!(tm.tm_sec == 0_i32);
+            assert!(tm.tm_min == 0_i32);
+            assert!(tm.tm_hour == 0_i32);
+            assert!(tm.tm_mday == 0_i32);
+            assert!(tm.tm_mon == 0_i32);
+            assert!(tm.tm_year == 0_i32);
+            assert!(tm.tm_wday == 0_i32);
+            assert!(tm.tm_isdst== 0_i32);
+            assert!(tm.tm_gmtoff == 0_i32);
+            assert!(tm.tm_zone == ~"");
+            assert!(tm.tm_nsec == 0_i32);
           }
           Err(_) => ()
         }
 
         let format = ~"%a %b %e %T %Y";
-        fail_unless!(strptime(~"", format) == Err(~"Invalid time"));
-        fail_unless!(strptime(~"Fri Feb 13 15:31:30", format)
+        assert!(strptime(~"", format) == Err(~"Invalid time"));
+        assert!(strptime(~"Fri Feb 13 15:31:30", format)
             == Err(~"Invalid time"));
 
         match strptime(~"Fri Feb 13 15:31:30 2009", format) {
           Err(copy e) => fail!(e),
           Ok(ref tm) => {
-            fail_unless!(tm.tm_sec == 30_i32);
-            fail_unless!(tm.tm_min == 31_i32);
-            fail_unless!(tm.tm_hour == 15_i32);
-            fail_unless!(tm.tm_mday == 13_i32);
-            fail_unless!(tm.tm_mon == 1_i32);
-            fail_unless!(tm.tm_year == 109_i32);
-            fail_unless!(tm.tm_wday == 5_i32);
-            fail_unless!(tm.tm_yday == 0_i32);
-            fail_unless!(tm.tm_isdst == 0_i32);
-            fail_unless!(tm.tm_gmtoff == 0_i32);
-            fail_unless!(tm.tm_zone == ~"");
-            fail_unless!(tm.tm_nsec == 0_i32);
+            assert!(tm.tm_sec == 30_i32);
+            assert!(tm.tm_min == 31_i32);
+            assert!(tm.tm_hour == 15_i32);
+            assert!(tm.tm_mday == 13_i32);
+            assert!(tm.tm_mon == 1_i32);
+            assert!(tm.tm_year == 109_i32);
+            assert!(tm.tm_wday == 5_i32);
+            assert!(tm.tm_yday == 0_i32);
+            assert!(tm.tm_isdst == 0_i32);
+            assert!(tm.tm_gmtoff == 0_i32);
+            assert!(tm.tm_zone == ~"");
+            assert!(tm.tm_nsec == 0_i32);
           }
         }
 
@@ -1050,7 +1050,7 @@ mod tests {
             ~"Friday",
             ~"Saturday"
         ]) |day| {
-            fail_unless!(test(*day, ~"%A"));
+            assert!(test(*day, ~"%A"));
         }
 
         for vec::each([
@@ -1062,7 +1062,7 @@ mod tests {
             ~"Fri",
             ~"Sat"
         ]) |day| {
-            fail_unless!(test(*day, ~"%a"));
+            assert!(test(*day, ~"%a"));
         }
 
         for vec::each([
@@ -1079,7 +1079,7 @@ mod tests {
             ~"November",
             ~"December"
         ]) |day| {
-            fail_unless!(test(*day, ~"%B"));
+            assert!(test(*day, ~"%B"));
         }
 
         for vec::each([
@@ -1096,56 +1096,56 @@ mod tests {
             ~"Nov",
             ~"Dec"
         ]) |day| {
-            fail_unless!(test(*day, ~"%b"));
+            assert!(test(*day, ~"%b"));
         }
 
-        fail_unless!(test(~"19", ~"%C"));
-        fail_unless!(test(~"Fri Feb 13 23:31:30 2009", ~"%c"));
-        fail_unless!(test(~"02/13/09", ~"%D"));
-        fail_unless!(test(~"03", ~"%d"));
-        fail_unless!(test(~"13", ~"%d"));
-        fail_unless!(test(~" 3", ~"%e"));
-        fail_unless!(test(~"13", ~"%e"));
-        fail_unless!(test(~"2009-02-13", ~"%F"));
-        fail_unless!(test(~"03", ~"%H"));
-        fail_unless!(test(~"13", ~"%H"));
-        fail_unless!(test(~"03", ~"%I")); // FIXME (#2350): flesh out
-        fail_unless!(test(~"11", ~"%I")); // FIXME (#2350): flesh out
-        fail_unless!(test(~"044", ~"%j"));
-        fail_unless!(test(~" 3", ~"%k"));
-        fail_unless!(test(~"13", ~"%k"));
-        fail_unless!(test(~" 1", ~"%l"));
-        fail_unless!(test(~"11", ~"%l"));
-        fail_unless!(test(~"03", ~"%M"));
-        fail_unless!(test(~"13", ~"%M"));
-        fail_unless!(test(~"\n", ~"%n"));
-        fail_unless!(test(~"am", ~"%P"));
-        fail_unless!(test(~"pm", ~"%P"));
-        fail_unless!(test(~"AM", ~"%p"));
-        fail_unless!(test(~"PM", ~"%p"));
-        fail_unless!(test(~"23:31", ~"%R"));
-        fail_unless!(test(~"11:31:30 AM", ~"%r"));
-        fail_unless!(test(~"11:31:30 PM", ~"%r"));
-        fail_unless!(test(~"03", ~"%S"));
-        fail_unless!(test(~"13", ~"%S"));
-        fail_unless!(test(~"15:31:30", ~"%T"));
-        fail_unless!(test(~"\t", ~"%t"));
-        fail_unless!(test(~"1", ~"%u"));
-        fail_unless!(test(~"7", ~"%u"));
-        fail_unless!(test(~"13-Feb-2009", ~"%v"));
-        fail_unless!(test(~"0", ~"%w"));
-        fail_unless!(test(~"6", ~"%w"));
-        fail_unless!(test(~"2009", ~"%Y"));
-        fail_unless!(test(~"09", ~"%y"));
-        fail_unless!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone ==
+        assert!(test(~"19", ~"%C"));
+        assert!(test(~"Fri Feb 13 23:31:30 2009", ~"%c"));
+        assert!(test(~"02/13/09", ~"%D"));
+        assert!(test(~"03", ~"%d"));
+        assert!(test(~"13", ~"%d"));
+        assert!(test(~" 3", ~"%e"));
+        assert!(test(~"13", ~"%e"));
+        assert!(test(~"2009-02-13", ~"%F"));
+        assert!(test(~"03", ~"%H"));
+        assert!(test(~"13", ~"%H"));
+        assert!(test(~"03", ~"%I")); // FIXME (#2350): flesh out
+        assert!(test(~"11", ~"%I")); // FIXME (#2350): flesh out
+        assert!(test(~"044", ~"%j"));
+        assert!(test(~" 3", ~"%k"));
+        assert!(test(~"13", ~"%k"));
+        assert!(test(~" 1", ~"%l"));
+        assert!(test(~"11", ~"%l"));
+        assert!(test(~"03", ~"%M"));
+        assert!(test(~"13", ~"%M"));
+        assert!(test(~"\n", ~"%n"));
+        assert!(test(~"am", ~"%P"));
+        assert!(test(~"pm", ~"%P"));
+        assert!(test(~"AM", ~"%p"));
+        assert!(test(~"PM", ~"%p"));
+        assert!(test(~"23:31", ~"%R"));
+        assert!(test(~"11:31:30 AM", ~"%r"));
+        assert!(test(~"11:31:30 PM", ~"%r"));
+        assert!(test(~"03", ~"%S"));
+        assert!(test(~"13", ~"%S"));
+        assert!(test(~"15:31:30", ~"%T"));
+        assert!(test(~"\t", ~"%t"));
+        assert!(test(~"1", ~"%u"));
+        assert!(test(~"7", ~"%u"));
+        assert!(test(~"13-Feb-2009", ~"%v"));
+        assert!(test(~"0", ~"%w"));
+        assert!(test(~"6", ~"%w"));
+        assert!(test(~"2009", ~"%Y"));
+        assert!(test(~"09", ~"%y"));
+        assert!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone ==
             ~"UTC");
-        fail_unless!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone ==
+        assert!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone ==
             ~"");
-        fail_unless!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff ==
+        assert!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff ==
             0);
-        fail_unless!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff ==
+        assert!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff ==
             0);
-        fail_unless!(test(~"%", ~"%%"));
+        assert!(test(~"%", ~"%%"));
     }
 
     pub fn test_ctime() {
@@ -1158,8 +1158,8 @@ mod tests {
 
         error!("test_ctime: %? %?", utc.ctime(), local.ctime());
 
-        fail_unless!(utc.ctime()   == ~"Fri Feb 13 23:31:30 2009");
-        fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
+        assert!(utc.ctime()   == ~"Fri Feb 13 23:31:30 2009");
+        assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
     }
 
     pub fn test_strftime() {
@@ -1170,69 +1170,69 @@ mod tests {
         let utc = at_utc(time);
         let local = at(time);
 
-        fail_unless!(local.strftime(~"") == ~"");
-        fail_unless!(local.strftime(~"%A") == ~"Friday");
-        fail_unless!(local.strftime(~"%a") == ~"Fri");
-        fail_unless!(local.strftime(~"%B") == ~"February");
-        fail_unless!(local.strftime(~"%b") == ~"Feb");
-        fail_unless!(local.strftime(~"%C") == ~"20");
-        fail_unless!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009");
-        fail_unless!(local.strftime(~"%D") == ~"02/13/09");
-        fail_unless!(local.strftime(~"%d") == ~"13");
-        fail_unless!(local.strftime(~"%e") == ~"13");
-        fail_unless!(local.strftime(~"%F") == ~"2009-02-13");
-        // fail_unless!(local.strftime("%G") == "2009");
-        // fail_unless!(local.strftime("%g") == "09");
-        fail_unless!(local.strftime(~"%H") == ~"15");
-        fail_unless!(local.strftime(~"%I") == ~"03");
-        fail_unless!(local.strftime(~"%j") == ~"044");
-        fail_unless!(local.strftime(~"%k") == ~"15");
-        fail_unless!(local.strftime(~"%l") == ~" 3");
-        fail_unless!(local.strftime(~"%M") == ~"31");
-        fail_unless!(local.strftime(~"%m") == ~"02");
-        fail_unless!(local.strftime(~"%n") == ~"\n");
-        fail_unless!(local.strftime(~"%P") == ~"pm");
-        fail_unless!(local.strftime(~"%p") == ~"PM");
-        fail_unless!(local.strftime(~"%R") == ~"15:31");
-        fail_unless!(local.strftime(~"%r") == ~"03:31:30 PM");
-        fail_unless!(local.strftime(~"%S") == ~"30");
-        fail_unless!(local.strftime(~"%s") == ~"1234567890");
-        fail_unless!(local.strftime(~"%T") == ~"15:31:30");
-        fail_unless!(local.strftime(~"%t") == ~"\t");
-        // fail_unless!(local.strftime("%U") == "06");
-        fail_unless!(local.strftime(~"%u") == ~"5");
-        // fail_unless!(local.strftime("%V") == "07");
-        fail_unless!(local.strftime(~"%v") == ~"13-Feb-2009");
-        // fail_unless!(local.strftime("%W") == "06");
-        fail_unless!(local.strftime(~"%w") == ~"5");
+        assert!(local.strftime(~"") == ~"");
+        assert!(local.strftime(~"%A") == ~"Friday");
+        assert!(local.strftime(~"%a") == ~"Fri");
+        assert!(local.strftime(~"%B") == ~"February");
+        assert!(local.strftime(~"%b") == ~"Feb");
+        assert!(local.strftime(~"%C") == ~"20");
+        assert!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009");
+        assert!(local.strftime(~"%D") == ~"02/13/09");
+        assert!(local.strftime(~"%d") == ~"13");
+        assert!(local.strftime(~"%e") == ~"13");
+        assert!(local.strftime(~"%F") == ~"2009-02-13");
+        // assert!(local.strftime("%G") == "2009");
+        // assert!(local.strftime("%g") == "09");
+        assert!(local.strftime(~"%H") == ~"15");
+        assert!(local.strftime(~"%I") == ~"03");
+        assert!(local.strftime(~"%j") == ~"044");
+        assert!(local.strftime(~"%k") == ~"15");
+        assert!(local.strftime(~"%l") == ~" 3");
+        assert!(local.strftime(~"%M") == ~"31");
+        assert!(local.strftime(~"%m") == ~"02");
+        assert!(local.strftime(~"%n") == ~"\n");
+        assert!(local.strftime(~"%P") == ~"pm");
+        assert!(local.strftime(~"%p") == ~"PM");
+        assert!(local.strftime(~"%R") == ~"15:31");
+        assert!(local.strftime(~"%r") == ~"03:31:30 PM");
+        assert!(local.strftime(~"%S") == ~"30");
+        assert!(local.strftime(~"%s") == ~"1234567890");
+        assert!(local.strftime(~"%T") == ~"15:31:30");
+        assert!(local.strftime(~"%t") == ~"\t");
+        // assert!(local.strftime("%U") == "06");
+        assert!(local.strftime(~"%u") == ~"5");
+        // assert!(local.strftime("%V") == "07");
+        assert!(local.strftime(~"%v") == ~"13-Feb-2009");
+        // assert!(local.strftime("%W") == "06");
+        assert!(local.strftime(~"%w") == ~"5");
         // handle "%X"
         // handle "%x"
-        fail_unless!(local.strftime(~"%Y") == ~"2009");
-        fail_unless!(local.strftime(~"%y") == ~"09");
+        assert!(local.strftime(~"%Y") == ~"2009");
+        assert!(local.strftime(~"%y") == ~"09");
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.
         let zone = local.strftime(~"%Z");
-        fail_unless!(zone == ~"PST" || zone == ~"Pacific Standard Time");
+        assert!(zone == ~"PST" || zone == ~"Pacific Standard Time");
 
-        fail_unless!(local.strftime(~"%z") == ~"-0800");
-        fail_unless!(local.strftime(~"%%") == ~"%");
+        assert!(local.strftime(~"%z") == ~"-0800");
+        assert!(local.strftime(~"%%") == ~"%");
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.
         let rfc822 = local.rfc822();
         let prefix = ~"Fri, 13 Feb 2009 15:31:30 ";
-        fail_unless!(rfc822 == prefix + ~"PST" ||
+        assert!(rfc822 == prefix + ~"PST" ||
                      rfc822 == prefix + ~"Pacific Standard Time");
 
-        fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
-        fail_unless!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800");
-        fail_unless!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00");
+        assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
+        assert!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800");
+        assert!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00");
 
-        fail_unless!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009");
-        fail_unless!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT");
-        fail_unless!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000");
-        fail_unless!(utc.rfc3339() == ~"2009-02-13T23:31:30Z");
+        assert!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009");
+        assert!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT");
+        assert!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000");
+        assert!(utc.rfc3339() == ~"2009-02-13T23:31:30Z");
     }
 
     pub fn test_timespec_eq_ord() {
@@ -1244,28 +1244,28 @@ mod tests {
         let d = &Timespec::new(2, 1);
         let e = &Timespec::new(2, 1);
 
-        fail_unless!(eq(d, e));
-        fail_unless!(ne(c, e));
+        assert!(eq(d, e));
+        assert!(ne(c, e));
 
-        fail_unless!(lt(a, b));
-        fail_unless!(lt(b, c));
-        fail_unless!(lt(c, d));
+        assert!(lt(a, b));
+        assert!(lt(b, c));
+        assert!(lt(c, d));
 
-        fail_unless!(le(a, b));
-        fail_unless!(le(b, c));
-        fail_unless!(le(c, d));
-        fail_unless!(le(d, e));
-        fail_unless!(le(e, d));
+        assert!(le(a, b));
+        assert!(le(b, c));
+        assert!(le(c, d));
+        assert!(le(d, e));
+        assert!(le(e, d));
 
-        fail_unless!(ge(b, a));
-        fail_unless!(ge(c, b));
-        fail_unless!(ge(d, c));
-        fail_unless!(ge(e, d));
-        fail_unless!(ge(d, e));
+        assert!(ge(b, a));
+        assert!(ge(c, b));
+        assert!(ge(d, c));
+        assert!(ge(e, d));
+        assert!(ge(d, e));
 
-        fail_unless!(gt(b, a));
-        fail_unless!(gt(c, b));
-        fail_unless!(gt(d, c));
+        assert!(gt(b, a));
+        assert!(gt(c, b));
+        assert!(gt(d, c));
     }
 
     #[test]
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index d72bfe73dd6..229d1a07caa 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -261,14 +261,14 @@ mod test {
 
             match recv_timeout(hl_loop, 10u, &test_po) {
               Some(val) => {
-                fail_unless!(val == expected);
+                assert!(val == expected);
                 successes += 1;
               }
               _ => failures += 1
             };
         }
 
-        fail_unless!(successes > times / 2);
+        assert!(successes > times / 2);
     }
 
     #[test]
@@ -292,6 +292,6 @@ mod test {
             };
         }
 
-        fail_unless!(successes > times / 2);
+        assert!(successes > times / 2);
     }
 }
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index 9a184ca8682..d0868da4408 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -725,24 +725,24 @@ mod test_treemap {
 
     #[test]
     fn find_empty() {
-        let m = TreeMap::new::<int, int>(); fail_unless!(m.find(&5) == None);
+        let m = TreeMap::new::<int, int>(); assert!(m.find(&5) == None);
     }
 
     #[test]
     fn find_not_found() {
         let mut m = TreeMap::new();
-        fail_unless!(m.insert(1, 2));
-        fail_unless!(m.insert(5, 3));
-        fail_unless!(m.insert(9, 3));
-        fail_unless!(m.find(&2) == None);
+        assert!(m.insert(1, 2));
+        assert!(m.insert(5, 3));
+        assert!(m.insert(9, 3));
+        assert!(m.find(&2) == None);
     }
 
     #[test]
     fn test_find_mut() {
         let mut m = TreeMap::new();
-        fail_unless!(m.insert(1, 12));
-        fail_unless!(m.insert(2, 8));
-        fail_unless!(m.insert(5, 14));
+        assert!(m.insert(1, 12));
+        assert!(m.insert(2, 8));
+        assert!(m.insert(5, 14));
         let new = 100;
         match m.find_mut(&5) {
           None => fail!(), Some(x) => *x = new
@@ -753,24 +753,24 @@ mod test_treemap {
     #[test]
     fn insert_replace() {
         let mut m = TreeMap::new();
-        fail_unless!(m.insert(5, 2));
-        fail_unless!(m.insert(2, 9));
-        fail_unless!(!m.insert(2, 11));
-        fail_unless!(m.find(&2).unwrap() == &11);
+        assert!(m.insert(5, 2));
+        assert!(m.insert(2, 9));
+        assert!(!m.insert(2, 11));
+        assert!(m.find(&2).unwrap() == &11);
     }
 
     #[test]
     fn test_clear() {
         let mut m = TreeMap::new();
         m.clear();
-        fail_unless!(m.insert(5, 11));
-        fail_unless!(m.insert(12, -3));
-        fail_unless!(m.insert(19, 2));
+        assert!(m.insert(5, 11));
+        assert!(m.insert(12, -3));
+        assert!(m.insert(19, 2));
         m.clear();
-        fail_unless!(m.find(&5).is_none());
-        fail_unless!(m.find(&12).is_none());
-        fail_unless!(m.find(&19).is_none());
-        fail_unless!(m.is_empty());
+        assert!(m.find(&5).is_none());
+        assert!(m.find(&12).is_none());
+        assert!(m.find(&19).is_none());
+        assert!(m.is_empty());
     }
 
     #[test]
@@ -785,28 +785,28 @@ mod test_treemap {
         m.insert(copy k1, copy v1);
         m.insert(copy k2, copy v2);
 
-        fail_unless!(m.find(&k2) == Some(&v2));
-        fail_unless!(m.find(&k1) == Some(&v1));
+        assert!(m.find(&k2) == Some(&v2));
+        assert!(m.find(&k1) == Some(&v1));
     }
 
     fn check_equal<K: Eq + TotalOrd, V: Eq>(ctrl: &[(K, V)],
                                             map: &TreeMap<K, V>) {
-        fail_unless!(ctrl.is_empty() == map.is_empty());
+        assert!(ctrl.is_empty() == map.is_empty());
         for ctrl.each |x| {
             let &(k, v) = x;
-            fail_unless!(map.find(&k).unwrap() == &v)
+            assert!(map.find(&k).unwrap() == &v)
         }
         for map.each |&(map_k, map_v)| {
             let mut found = false;
             for ctrl.each |x| {
                 let &(ctrl_k, ctrl_v) = x;
                 if *map_k == ctrl_k {
-                    fail_unless!(*map_v == ctrl_v);
+                    assert!(*map_v == ctrl_v);
                     found = true;
                     break;
                 }
             }
-            fail_unless!(found);
+            assert!(found);
         }
     }
 
@@ -814,12 +814,12 @@ mod test_treemap {
                                   parent: &~TreeNode<K, V>) {
         match *node {
           Some(ref r) => {
-            fail_unless!(r.key.cmp(&parent.key) == Less);
-            fail_unless!(r.level == parent.level - 1); // left is black
+            assert!(r.key.cmp(&parent.key) == Less);
+            assert!(r.level == parent.level - 1); // left is black
             check_left(&r.left, r);
             check_right(&r.right, r, false);
           }
-          None => fail_unless!(parent.level == 1) // parent is leaf
+          None => assert!(parent.level == 1) // parent is leaf
         }
     }
 
@@ -828,15 +828,15 @@ mod test_treemap {
                                    parent_red: bool) {
         match *node {
           Some(ref r) => {
-            fail_unless!(r.key.cmp(&parent.key) == Greater);
+            assert!(r.key.cmp(&parent.key) == Greater);
             let red = r.level == parent.level;
-            if parent_red { fail_unless!(!red) } // no dual horizontal links
+            if parent_red { assert!(!red) } // no dual horizontal links
             // Right red or black
-            fail_unless!(red || r.level == parent.level - 1);
+            assert!(red || r.level == parent.level - 1);
             check_left(&r.left, r);
             check_right(&r.right, r, red);
           }
-          None => fail_unless!(parent.level == 1) // parent is leaf
+          None => assert!(parent.level == 1) // parent is leaf
         }
     }
 
@@ -856,7 +856,7 @@ mod test_treemap {
         let mut ctrl = ~[];
 
         check_equal(ctrl, &map);
-        fail_unless!(map.find(&5).is_none());
+        assert!(map.find(&5).is_none());
 
         let rng = rand::seeded_rng(&[42]);
 
@@ -865,7 +865,7 @@ mod test_treemap {
                 let k = rng.gen_int();
                 let v = rng.gen_int();
                 if !ctrl.contains(&(k, v)) {
-                    fail_unless!(map.insert(k, v));
+                    assert!(map.insert(k, v));
                     ctrl.push((k, v));
                     check_structure(&map);
                     check_equal(ctrl, &map);
@@ -875,7 +875,7 @@ mod test_treemap {
             for 30.times {
                 let r = rng.gen_uint_range(0, ctrl.len());
                 let (key, _) = vec::remove(&mut ctrl, r);
-                fail_unless!(map.remove(&key));
+                assert!(map.remove(&key));
                 check_structure(&map);
                 check_equal(ctrl, &map);
             }
@@ -885,36 +885,36 @@ mod test_treemap {
     #[test]
     fn test_len() {
         let mut m = TreeMap::new();
-        fail_unless!(m.insert(3, 6));
-        fail_unless!(m.len() == 1);
-        fail_unless!(m.insert(0, 0));
-        fail_unless!(m.len() == 2);
-        fail_unless!(m.insert(4, 8));
-        fail_unless!(m.len() == 3);
-        fail_unless!(m.remove(&3));
-        fail_unless!(m.len() == 2);
-        fail_unless!(!m.remove(&5));
-        fail_unless!(m.len() == 2);
-        fail_unless!(m.insert(2, 4));
-        fail_unless!(m.len() == 3);
-        fail_unless!(m.insert(1, 2));
-        fail_unless!(m.len() == 4);
+        assert!(m.insert(3, 6));
+        assert!(m.len() == 1);
+        assert!(m.insert(0, 0));
+        assert!(m.len() == 2);
+        assert!(m.insert(4, 8));
+        assert!(m.len() == 3);
+        assert!(m.remove(&3));
+        assert!(m.len() == 2);
+        assert!(!m.remove(&5));
+        assert!(m.len() == 2);
+        assert!(m.insert(2, 4));
+        assert!(m.len() == 3);
+        assert!(m.insert(1, 2));
+        assert!(m.len() == 4);
     }
 
     #[test]
     fn test_each() {
         let mut m = TreeMap::new();
 
-        fail_unless!(m.insert(3, 6));
-        fail_unless!(m.insert(0, 0));
-        fail_unless!(m.insert(4, 8));
-        fail_unless!(m.insert(2, 4));
-        fail_unless!(m.insert(1, 2));
+        assert!(m.insert(3, 6));
+        assert!(m.insert(0, 0));
+        assert!(m.insert(4, 8));
+        assert!(m.insert(2, 4));
+        assert!(m.insert(1, 2));
 
         let mut n = 0;
         for m.each |&(k, v)| {
-            fail_unless!(*k == n);
-            fail_unless!(*v == n * 2);
+            assert!(*k == n);
+            assert!(*v == n * 2);
             n += 1;
         }
     }
@@ -923,16 +923,16 @@ mod test_treemap {
     fn test_each_reverse() {
         let mut m = TreeMap::new();
 
-        fail_unless!(m.insert(3, 6));
-        fail_unless!(m.insert(0, 0));
-        fail_unless!(m.insert(4, 8));
-        fail_unless!(m.insert(2, 4));
-        fail_unless!(m.insert(1, 2));
+        assert!(m.insert(3, 6));
+        assert!(m.insert(0, 0));
+        assert!(m.insert(4, 8));
+        assert!(m.insert(2, 4));
+        assert!(m.insert(1, 2));
 
         let mut n = 4;
         for m.each_reverse |&(k, v)| {
-            fail_unless!(*k == n);
-            fail_unless!(*v == n * 2);
+            assert!(*k == n);
+            assert!(*v == n * 2);
             n -= 1;
         }
     }
@@ -942,17 +942,17 @@ mod test_treemap {
         let mut a = TreeMap::new();
         let mut b = TreeMap::new();
 
-        fail_unless!(a == b);
-        fail_unless!(a.insert(0, 5));
-        fail_unless!(a != b);
-        fail_unless!(b.insert(0, 4));
-        fail_unless!(a != b);
-        fail_unless!(a.insert(5, 19));
-        fail_unless!(a != b);
-        fail_unless!(!b.insert(0, 5));
-        fail_unless!(a != b);
-        fail_unless!(b.insert(5, 19));
-        fail_unless!(a == b);
+        assert!(a == b);
+        assert!(a.insert(0, 5));
+        assert!(a != b);
+        assert!(b.insert(0, 4));
+        assert!(a != b);
+        assert!(a.insert(5, 19));
+        assert!(a != b);
+        assert!(!b.insert(0, 5));
+        assert!(a != b);
+        assert!(b.insert(5, 19));
+        assert!(a == b);
     }
 
     #[test]
@@ -960,17 +960,17 @@ mod test_treemap {
         let mut a = TreeMap::new();
         let mut b = TreeMap::new();
 
-        fail_unless!(!(a < b) && !(b < a));
-        fail_unless!(b.insert(0, 5));
-        fail_unless!(a < b);
-        fail_unless!(a.insert(0, 7));
-        fail_unless!(!(a < b) && !(b < a));
-        fail_unless!(b.insert(-2, 0));
-        fail_unless!(b < a);
-        fail_unless!(a.insert(-5, 2));
-        fail_unless!(a < b);
-        fail_unless!(a.insert(6, 2));
-        fail_unless!(a < b && !(b < a));
+        assert!(!(a < b) && !(b < a));
+        assert!(b.insert(0, 5));
+        assert!(a < b);
+        assert!(a.insert(0, 7));
+        assert!(!(a < b) && !(b < a));
+        assert!(b.insert(-2, 0));
+        assert!(b < a);
+        assert!(a.insert(-5, 2));
+        assert!(a < b);
+        assert!(a.insert(6, 2));
+        assert!(a < b && !(b < a));
     }
 
     #[test]
@@ -978,13 +978,13 @@ mod test_treemap {
         let mut a = TreeMap::new();
         let mut b = TreeMap::new();
 
-        fail_unless!(a <= b && a >= b);
-        fail_unless!(a.insert(1, 1));
-        fail_unless!(a > b && a >= b);
-        fail_unless!(b < a && b <= a);
-        fail_unless!(b.insert(2, 2));
-        fail_unless!(b > a && b >= a);
-        fail_unless!(a < b && a <= b);
+        assert!(a <= b && a >= b);
+        assert!(a.insert(1, 1));
+        assert!(a > b && a >= b);
+        assert!(b < a && b <= a);
+        assert!(b.insert(2, 2));
+        assert!(b > a && b >= a);
+        assert!(a < b && a <= b);
     }
 
     #[test]
@@ -996,22 +996,22 @@ mod test_treemap {
         let (x4, y4) = (29, 5);
         let (x5, y5) = (103, 3);
 
-        fail_unless!(m.insert(x1, y1));
-        fail_unless!(m.insert(x2, y2));
-        fail_unless!(m.insert(x3, y3));
-        fail_unless!(m.insert(x4, y4));
-        fail_unless!(m.insert(x5, y5));
+        assert!(m.insert(x1, y1));
+        assert!(m.insert(x2, y2));
+        assert!(m.insert(x3, y3));
+        assert!(m.insert(x4, y4));
+        assert!(m.insert(x5, y5));
 
         let m = m;
         let mut a = m.iter();
 
-        fail_unless!(map_next(&mut a).unwrap() == (&x1, &y1));
-        fail_unless!(map_next(&mut a).unwrap() == (&x2, &y2));
-        fail_unless!(map_next(&mut a).unwrap() == (&x3, &y3));
-        fail_unless!(map_next(&mut a).unwrap() == (&x4, &y4));
-        fail_unless!(map_next(&mut a).unwrap() == (&x5, &y5));
+        assert!(map_next(&mut a).unwrap() == (&x1, &y1));
+        assert!(map_next(&mut a).unwrap() == (&x2, &y2));
+        assert!(map_next(&mut a).unwrap() == (&x3, &y3));
+        assert!(map_next(&mut a).unwrap() == (&x4, &y4));
+        assert!(map_next(&mut a).unwrap() == (&x5, &y5));
 
-        fail_unless!(map_next(&mut a).is_none());
+        assert!(map_next(&mut a).is_none());
 
         let mut b = m.iter();
 
@@ -1020,7 +1020,7 @@ mod test_treemap {
         let mut i = 0;
 
         for map_advance(&mut b) |x| {
-            fail_unless!(expected[i] == x);
+            assert!(expected[i] == x);
             i += 1;
 
             if i == 2 {
@@ -1029,7 +1029,7 @@ mod test_treemap {
         }
 
         for map_advance(&mut b) |x| {
-            fail_unless!(expected[i] == x);
+            assert!(expected[i] == x);
             i += 1;
         }
     }
@@ -1043,80 +1043,80 @@ mod test_set {
     fn test_clear() {
         let mut s = TreeSet::new();
         s.clear();
-        fail_unless!(s.insert(5));
-        fail_unless!(s.insert(12));
-        fail_unless!(s.insert(19));
+        assert!(s.insert(5));
+        assert!(s.insert(12));
+        assert!(s.insert(19));
         s.clear();
-        fail_unless!(!s.contains(&5));
-        fail_unless!(!s.contains(&12));
-        fail_unless!(!s.contains(&19));
-        fail_unless!(s.is_empty());
+        assert!(!s.contains(&5));
+        assert!(!s.contains(&12));
+        assert!(!s.contains(&19));
+        assert!(s.is_empty());
     }
 
     #[test]
     fn test_disjoint() {
         let mut xs = TreeSet::new();
         let mut ys = TreeSet::new();
-        fail_unless!(xs.is_disjoint(&ys));
-        fail_unless!(ys.is_disjoint(&xs));
-        fail_unless!(xs.insert(5));
-        fail_unless!(ys.insert(11));
-        fail_unless!(xs.is_disjoint(&ys));
-        fail_unless!(ys.is_disjoint(&xs));
-        fail_unless!(xs.insert(7));
-        fail_unless!(xs.insert(19));
-        fail_unless!(xs.insert(4));
-        fail_unless!(ys.insert(2));
-        fail_unless!(ys.insert(-11));
-        fail_unless!(xs.is_disjoint(&ys));
-        fail_unless!(ys.is_disjoint(&xs));
-        fail_unless!(ys.insert(7));
-        fail_unless!(!xs.is_disjoint(&ys));
-        fail_unless!(!ys.is_disjoint(&xs));
+        assert!(xs.is_disjoint(&ys));
+        assert!(ys.is_disjoint(&xs));
+        assert!(xs.insert(5));
+        assert!(ys.insert(11));
+        assert!(xs.is_disjoint(&ys));
+        assert!(ys.is_disjoint(&xs));
+        assert!(xs.insert(7));
+        assert!(xs.insert(19));
+        assert!(xs.insert(4));
+        assert!(ys.insert(2));
+        assert!(ys.insert(-11));
+        assert!(xs.is_disjoint(&ys));
+        assert!(ys.is_disjoint(&xs));
+        assert!(ys.insert(7));
+        assert!(!xs.is_disjoint(&ys));
+        assert!(!ys.is_disjoint(&xs));
     }
 
     #[test]
     fn test_subset_and_superset() {
         let mut a = TreeSet::new();
-        fail_unless!(a.insert(0));
-        fail_unless!(a.insert(5));
-        fail_unless!(a.insert(11));
-        fail_unless!(a.insert(7));
+        assert!(a.insert(0));
+        assert!(a.insert(5));
+        assert!(a.insert(11));
+        assert!(a.insert(7));
 
         let mut b = TreeSet::new();
-        fail_unless!(b.insert(0));
-        fail_unless!(b.insert(7));
-        fail_unless!(b.insert(19));
-        fail_unless!(b.insert(250));
-        fail_unless!(b.insert(11));
-        fail_unless!(b.insert(200));
+        assert!(b.insert(0));
+        assert!(b.insert(7));
+        assert!(b.insert(19));
+        assert!(b.insert(250));
+        assert!(b.insert(11));
+        assert!(b.insert(200));
 
-        fail_unless!(!a.is_subset(&b));
-        fail_unless!(!a.is_superset(&b));
-        fail_unless!(!b.is_subset(&a));
-        fail_unless!(!b.is_superset(&a));
+        assert!(!a.is_subset(&b));
+        assert!(!a.is_superset(&b));
+        assert!(!b.is_subset(&a));
+        assert!(!b.is_superset(&a));
 
-        fail_unless!(b.insert(5));
+        assert!(b.insert(5));
 
-        fail_unless!(a.is_subset(&b));
-        fail_unless!(!a.is_superset(&b));
-        fail_unless!(!b.is_subset(&a));
-        fail_unless!(b.is_superset(&a));
+        assert!(a.is_subset(&b));
+        assert!(!a.is_superset(&b));
+        assert!(!b.is_subset(&a));
+        assert!(b.is_superset(&a));
     }
 
     #[test]
     fn test_each() {
         let mut m = TreeSet::new();
 
-        fail_unless!(m.insert(3));
-        fail_unless!(m.insert(0));
-        fail_unless!(m.insert(4));
-        fail_unless!(m.insert(2));
-        fail_unless!(m.insert(1));
+        assert!(m.insert(3));
+        assert!(m.insert(0));
+        assert!(m.insert(4));
+        assert!(m.insert(2));
+        assert!(m.insert(1));
 
         let mut n = 0;
         for m.each |x| {
-            fail_unless!(*x == n);
+            assert!(*x == n);
             n += 1
         }
     }
@@ -1125,15 +1125,15 @@ mod test_set {
     fn test_each_reverse() {
         let mut m = TreeSet::new();
 
-        fail_unless!(m.insert(3));
-        fail_unless!(m.insert(0));
-        fail_unless!(m.insert(4));
-        fail_unless!(m.insert(2));
-        fail_unless!(m.insert(1));
+        assert!(m.insert(3));
+        assert!(m.insert(0));
+        assert!(m.insert(4));
+        assert!(m.insert(2));
+        assert!(m.insert(1));
 
         let mut n = 4;
         for m.each_reverse |x| {
-            fail_unless!(*x == n);
+            assert!(*x == n);
             n -= 1
         }
     }
@@ -1143,15 +1143,15 @@ mod test_set {
         let mut set_a = TreeSet::new();
         let mut set_b = TreeSet::new();
 
-        for a.each |x| { fail_unless!(set_a.insert(*x)) }
-        for b.each |y| { fail_unless!(set_b.insert(*y)) }
+        for a.each |x| { assert!(set_a.insert(*x)) }
+        for b.each |y| { assert!(set_b.insert(*y)) }
 
         let mut i = 0;
         for f(&set_a, &set_b) |x| {
-            fail_unless!(*x == expected[i]);
+            assert!(*x == expected[i]);
             i += 1;
         }
-        fail_unless!(i == expected.len());
+        assert!(i == expected.len());
     }
 
     #[test]
diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs
index 4fdd4e286da..77996de6d83 100644
--- a/src/libstd/unicode.rs
+++ b/src/libstd/unicode.rs
@@ -224,25 +224,25 @@ mod tests {
 
     #[test]
     fn test_is_digit() {
-        fail_unless!((unicode::icu::is_digit('0')));
-        fail_unless!((!unicode::icu::is_digit('m')));
+        assert!((unicode::icu::is_digit('0')));
+        assert!((!unicode::icu::is_digit('m')));
     }
 
     #[test]
     fn test_is_lower() {
-        fail_unless!((unicode::icu::is_lower('m')));
-        fail_unless!((!unicode::icu::is_lower('M')));
+        assert!((unicode::icu::is_lower('m')));
+        assert!((!unicode::icu::is_lower('M')));
     }
 
     #[test]
     fn test_is_space() {
-        fail_unless!((unicode::icu::is_space(' ')));
-        fail_unless!((!unicode::icu::is_space('m')));
+        assert!((unicode::icu::is_space(' ')));
+        assert!((!unicode::icu::is_space('m')));
     }
 
     #[test]
     fn test_is_upper() {
-        fail_unless!((unicode::icu::is_upper('M')));
-        fail_unless!((!unicode::icu::is_upper('m')));
+        assert!((unicode::icu::is_upper('M')));
+        assert!((!unicode::icu::is_upper('m')));
     }
 }
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 1c7a7c22a9d..fe40fc6a78b 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -188,7 +188,7 @@ extern fn tear_down_walk_cb(handle: *libc::c_void, arg: *libc::c_void) {
     // pretty much, if we still have an active handle and it is *not*
     // the async handle that facilities global loop communication, we
     // want to barf out and fail
-    fail_unless!(handle == arg);
+    assert!(handle == arg);
 }
 
 extern fn tear_down_close_cb(handle: *ll::uv_async_t) {
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index f6cc35e0c9e..7582a7cff51 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1339,7 +1339,7 @@ pub mod test {
                     stream as *libc::c_void);
                 let err_msg = get_last_err_info(test_loop);
                 debug!(err_msg);
-                fail_unless!(false);
+                assert!(false);
             }
             debug!(~"finishing on_connect_cb");
         }
@@ -1411,12 +1411,12 @@ pub mod test {
                 }
                 else {
                    debug!(~"tcp_connect() failure");
-                   fail_unless!(false);
+                   assert!(false);
                 }
             }
             else {
                 debug!(~"tcp_init() failure");
-                fail_unless!(false);
+                assert!(false);
             }
             loop_delete(test_loop);
         }
@@ -1492,7 +1492,7 @@ pub mod test {
                         debug!(get_last_err_info(
                             get_loop_for_uv_handle(client_stream_ptr
                                 as *libc::c_void)));
-                        fail_unless!(false);
+                        assert!(false);
                     }
                 }
                 else {
@@ -1552,19 +1552,19 @@ pub mod test {
                     else {
                         debug!("server_connection_cb: bad read:%d",
                                         read_result as int);
-                        fail_unless!(false);
+                        assert!(false);
                     }
                 }
                 else {
                     debug!("server_connection_cb: bad accept: %d",
                                 accept_result as int);
-                    fail_unless!(false);
+                    assert!(false);
                 }
             }
             else {
                 debug!("server_connection_cb: bad client init: %d",
                             client_init_result as int);
-                fail_unless!(false);
+                assert!(false);
             }
         }
     }
@@ -1683,25 +1683,25 @@ pub mod test {
                         else {
                             debug!("uv_async_init failure: %d",
                                     async_result as int);
-                            fail_unless!(false);
+                            assert!(false);
                         }
                     }
                     else {
                         debug!("non-zero result on uv_listen: %d",
                                     listen_result as int);
-                        fail_unless!(false);
+                        assert!(false);
                     }
                 }
                 else {
                     debug!("non-zero result on uv_tcp_bind: %d",
                                 bind_result as int);
-                    fail_unless!(false);
+                    assert!(false);
                 }
             }
             else {
                 debug!("non-zero result on uv_tcp_init: %d",
                             tcp_init_result as int);
-                fail_unless!(false);
+                assert!(false);
             }
             loop_delete(test_loop);
         }
@@ -1749,8 +1749,8 @@ pub mod test {
             let msg_from_client = server_port.recv();
             let msg_from_server = client_port.recv();
 
-            fail_unless!(str::contains(msg_from_client, kill_server_msg));
-            fail_unless!(str::contains(msg_from_server, server_resp_msg));
+            assert!(str::contains(msg_from_client, kill_server_msg));
+            assert!(str::contains(msg_from_server, server_resp_msg));
         }
     }
 
@@ -1794,7 +1794,7 @@ pub mod test {
                     t_name, rust_size, foreign_size as uint);
                 debug!(output);
             }
-            fail_unless!(sizes_match);
+            assert!(sizes_match);
         }
     }
 
@@ -1859,7 +1859,7 @@ pub mod test {
             // .. can't get the uv::ll::sockaddr_in6 to == 28 :/
             // .. so the type always appears to be 32 in size.. which is
             // good, i guess.. better too big than too little
-            fail_unless!((4u+foreign_handle_size as uint) ==
+            assert!((4u+foreign_handle_size as uint) ==
                 rust_handle_size);
         }
     }
@@ -1874,7 +1874,7 @@ pub mod test {
                               foreign_handle_size as uint, rust_handle_size);
             debug!(output);
             // FIXME #1645 .. see note above about struct padding
-            fail_unless!((4u+foreign_handle_size as uint) ==
+            assert!((4u+foreign_handle_size as uint) ==
                 rust_handle_size);
         }
     }
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index b086670956e..7a8aff121a8 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -246,7 +246,7 @@ pub impl FileMap {
     fn next_line(&self, +pos: BytePos) {
         // the new charpos must be > the last one (or it's the first one).
         let lines = &mut *self.lines;
-        fail_unless!((lines.len() == 0) || (lines[lines.len() - 1] < pos));
+        assert!((lines.len() == 0) || (lines[lines.len() - 1] < pos));
         self.lines.push(pos);
     }
 
@@ -264,7 +264,7 @@ pub impl FileMap {
     }
 
     pub fn record_multibyte_char(&self, pos: BytePos, bytes: uint) {
-        fail_unless!(bytes >=2 && bytes <= 4);
+        assert!(bytes >=2 && bytes <= 4);
         let mbc = MultiByteChar {
             pos: pos,
             bytes: bytes,
@@ -387,7 +387,7 @@ pub impl CodeMap {
     pub fn span_to_snippet(&self, sp: span) -> ~str {
         let begin = self.lookup_byte_offset(sp.lo);
         let end = self.lookup_byte_offset(sp.hi);
-        fail_unless!(begin.fm.start_pos == end.fm.start_pos);
+        assert!(begin.fm.start_pos == end.fm.start_pos);
         return str::slice(*begin.fm.src,
                           begin.pos.to_uint(), end.pos.to_uint()).to_owned();
     }
@@ -449,7 +449,7 @@ priv impl CodeMap {
         debug!("codemap: char pos %? is on the line at char pos %?",
                chpos, linechpos);
         debug!("codemap: byte is on line: %?", line);
-        fail_unless!(chpos >= linechpos);
+        assert!(chpos >= linechpos);
         return Loc {
             file: f,
             line: line,
@@ -488,7 +488,7 @@ priv impl CodeMap {
                 total_extra_bytes += mbc.bytes;
                 // We should never see a byte position in the middle of a
                 // character
-                fail_unless!(bpos == mbc.pos
+                assert!(bpos == mbc.pos
                     || bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes);
             } else {
                 break;
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 6f49fe02239..09498f09a29 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -449,19 +449,6 @@ pub fn core_macros() -> ~str {
         )
     )
 
-    macro_rules! fail_unless(
-        ($cond:expr) => {
-            if !$cond {
-                ::core::sys::fail_assert(stringify!($cond), file!(), line!())
-            }
-        };
-        ($cond:expr, $msg:expr) => {
-            if !$cond {
-                ::core::sys::fail_assert($msg, file!(), line!())
-            }
-        }
-    )
-
     macro_rules! assert(
         ($cond:expr) => {
             if !$cond {
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 99033b3b3cc..ca8a17dad67 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -54,7 +54,7 @@ impl gen_send for message {
           message(ref _id, span, ref tys, this, Some(ref next_state)) => {
             debug!("pipec: next state exists");
             let next = this.proto.get_state(next_state.state);
-            fail_unless!(next_state.tys.len() ==
+            assert!(next_state.tys.len() ==
                 next.generics.ty_params.len());
             let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str()));
             let args_ast = vec::map2(arg_names, *tys, |n, t| cx.arg(*n, *t));
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index e6619d6dcfa..f74fbbc3c03 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -407,7 +407,7 @@ pub fn parse(
             }
         }
 
-        fail_unless!(cur_eis.len() > 0u);
+        assert!(cur_eis.len() > 0u);
     }
 }
 
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 0804951327a..f90ff21cdf0 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -48,7 +48,7 @@ pub fn is_doc_comment(s: &str) -> bool {
 }
 
 pub fn doc_comment_style(comment: &str) -> ast::attr_style {
-    fail_unless!(is_doc_comment(comment));
+    assert!(is_doc_comment(comment));
     if comment.starts_with(~"//!") || comment.starts_with(~"/*!") {
         ast::attr_inner
     } else {
@@ -134,7 +134,7 @@ fn read_to_eol(rdr: @mut StringReader) -> ~str {
 
 fn read_one_line_comment(rdr: @mut StringReader) -> ~str {
     let val = read_to_eol(rdr);
-    fail_unless!((val[0] == '/' as u8 && val[1] == '/' as u8) ||
+    assert!((val[0] == '/' as u8 && val[1] == '/' as u8) ||
                  (val[0] == '#' as u8 && val[1] == '!' as u8));
     return val;
 }
@@ -247,7 +247,7 @@ fn read_block_comment(rdr: @mut StringReader,
             bump(rdr);
         }
         if !is_block_non_doc_comment(curr_line) { return; }
-        fail_unless!(!curr_line.contains_char('\n'));
+        assert!(!curr_line.contains_char('\n'));
         lines.push(curr_line);
     } else {
         let mut level: int = 1;
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index ffd2a1d801c..17d6ba3ac93 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -187,7 +187,7 @@ pub fn bump(rdr: @mut StringReader) {
     rdr.last_pos = rdr.pos;
     let current_byte_offset = byte_offset(rdr).to_uint();;
     if current_byte_offset < (*rdr.src).len() {
-        fail_unless!(rdr.curr != -1 as char);
+        assert!(rdr.curr != -1 as char);
         let last_char = rdr.curr;
         let next = str::char_range_at(*rdr.src, current_byte_offset);
         let byte_offset_diff = next.next - current_byte_offset;
@@ -314,7 +314,7 @@ fn consume_any_line_comment(rdr: @mut StringReader)
 }
 
 pub fn is_block_non_doc_comment(s: &str) -> bool {
-    fail_unless!(s.len() >= 1u);
+    assert!(s.len() >= 1u);
     str::all_between(s, 1u, s.len() - 1u, |ch| ch == '*')
 }
 
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index cdb67129c35..22e659fa574 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -214,7 +214,7 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id {
     let rv = sess.next_id;
     sess.next_id += 1;
     // ID 0 is reserved for the crate and doesn't actually exist in the AST
-    fail_unless!(rv != 0);
+    assert!(rv != 0);
     return rv;
 }
 
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index d93e5995d4f..ac0e42fc65d 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2529,7 +2529,7 @@ pub impl Parser {
 
     fn parse_block(&self) -> blk {
         let (attrs, blk) = self.parse_inner_attrs_and_block(false);
-        fail_unless!(vec::is_empty(attrs));
+        assert!(vec::is_empty(attrs));
         return blk;
     }
 
@@ -3922,7 +3922,7 @@ pub impl Parser {
         foreign_items_allowed: bool,
         macros_allowed: bool
     ) -> item_or_view_item {
-        fail_unless!(items_allowed != foreign_items_allowed);
+        assert!(items_allowed != foreign_items_allowed);
 
         maybe_whole!(iovi self, nt_item);
         let lo = self.span.lo;
@@ -4333,13 +4333,13 @@ pub impl Parser {
                         view_items.push(view_item);
                     }
                     iovi_item(item) => {
-                        fail_unless!(items_allowed);
+                        assert!(items_allowed);
                         items.push(item);
                         attrs = self.parse_outer_attributes();
                         break;
                     }
                     iovi_foreign_item(foreign_item) => {
-                        fail_unless!(foreign_items_allowed);
+                        assert!(foreign_items_allowed);
                         foreign_items.push(foreign_item);
                         attrs = self.parse_outer_attributes();
                         break;
@@ -4364,11 +4364,11 @@ pub impl Parser {
                         view_items.push(view_item);
                     }
                     iovi_item(item) => {
-                        fail_unless!(items_allowed);
+                        assert!(items_allowed);
                         items.push(item)
                     }
                     iovi_foreign_item(foreign_item) => {
-                        fail_unless!(foreign_items_allowed);
+                        assert!(foreign_items_allowed);
                         foreign_items.push(foreign_item);
                     }
                 }
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index af9cb7b841e..e742bdc056a 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -117,7 +117,7 @@ pub fn tok_str(++t: token) -> ~str {
 pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint,
                lim: uint) -> ~str {
     let n = vec::len(toks);
-    fail_unless!(n == vec::len(szs));
+    assert!(n == vec::len(szs));
     let mut i = left;
     let mut L = lim;
     let mut s = ~"[";
@@ -369,12 +369,12 @@ pub impl Printer {
         } else {
             self.top += 1u;
             self.top %= self.buf_len;
-            fail_unless!((self.top != self.bottom));
+            assert!((self.top != self.bottom));
         }
         self.scan_stack[self.top] = x;
     }
     fn scan_pop(&mut self) -> uint {
-        fail_unless!((!self.scan_stack_empty));
+        assert!((!self.scan_stack_empty));
         let x = self.scan_stack[self.top];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
@@ -382,11 +382,11 @@ pub impl Printer {
         return x;
     }
     fn scan_top(&mut self) -> uint {
-        fail_unless!((!self.scan_stack_empty));
+        assert!((!self.scan_stack_empty));
         return self.scan_stack[self.top];
     }
     fn scan_pop_bottom(&mut self) -> uint {
-        fail_unless!((!self.scan_stack_empty));
+        assert!((!self.scan_stack_empty));
         let x = self.scan_stack[self.bottom];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
@@ -396,7 +396,7 @@ pub impl Printer {
     fn advance_right(&mut self) {
         self.right += 1u;
         self.right %= self.buf_len;
-        fail_unless!((self.right != self.left));
+        assert!((self.right != self.left));
     }
     fn advance_left(&mut self, ++x: token, L: int) {
         debug!("advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right,
@@ -406,7 +406,7 @@ pub impl Printer {
             match x {
               BREAK(b) => self.left_total += b.blank_space,
               STRING(_, len) => {
-                fail_unless!((len == L)); self.left_total += len;
+                assert!((len == L)); self.left_total += len;
               }
               _ => ()
             }
@@ -498,7 +498,7 @@ pub impl Printer {
           END => {
             debug!("print END -> pop END");
             let print_stack = &*self.print_stack;
-            fail_unless!((print_stack.len() != 0u));
+            assert!((print_stack.len() != 0u));
             self.print_stack.pop();
           }
           BREAK(b) => {
@@ -532,8 +532,8 @@ pub impl Printer {
           }
           STRING(s, len) => {
             debug!("print STRING(%s)", *s);
-            fail_unless!((L == len));
-            // fail_unless!(L <= space);
+            assert!((L == len));
+            // assert!(L <= space);
             self.space -= len;
             self.print_str(*s);
           }
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 66907471c98..7ca5fba4c81 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1294,8 +1294,8 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
         print_fn_block_args(s, decl);
         space(s.s);
         // }
-        fail_unless!(body.node.stmts.is_empty());
-        fail_unless!(body.node.expr.is_some());
+        assert!(body.node.stmts.is_empty());
+        assert!(body.node.expr.is_some());
         // we extract the block, so as not to create another set of boxes
         match body.node.expr.get().node {
             ast::expr_block(ref blk) => {
@@ -1445,7 +1445,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) {
 
         // if any are mut, all are mut
         if locs.any(|l| l.node.is_mutbl) {
-            fail_unless!(locs.all(|l| l.node.is_mutbl));
+            assert!(locs.all(|l| l.node.is_mutbl));
             word_nbsp(s, ~"mut");
         }
 
@@ -2080,7 +2080,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) {
 pub fn print_comment(s: @ps, cmnt: comments::cmnt) {
     match cmnt.style {
       comments::mixed => {
-        fail_unless!((vec::len(cmnt.lines) == 1u));
+        assert!((vec::len(cmnt.lines) == 1u));
         zerobreak(s.s);
         word(s.s, cmnt.lines[0]);
         zerobreak(s.s);
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)));
 }