1 files changed, 39 insertions, 39 deletions

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;
         }
     }