auto merge of #6601 : cmr/rust/assert_eq, r=Aatch

src/libcore/at_vec.rs

@@ -294,30 +294,30 @@ mod test {
         }
 
         assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 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]);
+        assert_eq!(from_fn(5, |x| x+1), @[1, 2, 3, 4, 5]);
+        assert_eq!(from_elem(5, 3.14), @[3.14, 3.14, 3.14, 3.14, 3.14]);
     }
 
     #[test]
     fn append_test() {
-        assert!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]);
+        assert_eq!(@[1,2,3] + @[4,5,6], @[1,2,3,4,5,6]);
     }
 
     #[test]
     fn test_to_managed_consume() {
-        assert!(to_managed_consume::<int>(~[]) == @[]);
-        assert!(to_managed_consume(~[true]) == @[true]);
-        assert!(to_managed_consume(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(to_managed_consume(~[~"abc", ~"123"]) == @[~"abc", ~"123"]);
-        assert!(to_managed_consume(~[~[42]]) == @[~[42]]);
+        assert_eq!(to_managed_consume::<int>(~[]), @[]);
+        assert_eq!(to_managed_consume(~[true]), @[true]);
+        assert_eq!(to_managed_consume(~[1, 2, 3, 4, 5]), @[1, 2, 3, 4, 5]);
+        assert_eq!(to_managed_consume(~[~"abc", ~"123"]), @[~"abc", ~"123"]);
+        assert_eq!(to_managed_consume(~[~[42]]), @[~[42]]);
     }
 
     #[test]
     fn test_to_managed() {
-        assert!(to_managed::<int>([]) == @[]);
-        assert!(to_managed([true]) == @[true]);
-        assert!(to_managed([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]);
-        assert!(to_managed([@"abc", @"123"]) == @[@"abc", @"123"]);
-        assert!(to_managed([@[42]]) == @[@[42]]);
+        assert_eq!(to_managed::<int>([]), @[]);
+        assert_eq!(to_managed([true]), @[true]);
+        assert_eq!(to_managed([1, 2, 3, 4, 5]), @[1, 2, 3, 4, 5]);
+        assert_eq!(to_managed([@"abc", @"123"]), @[@"abc", @"123"]);
+        assert_eq!(to_managed([@[42]]), @[@[42]]);
     }
 }

src/libcore/bool.rs

@@ -113,14 +113,14 @@ mod tests {
 
     #[test]
     fn test_bool_to_str() {
-        assert!(to_str(false) == ~"false");
-        assert!(to_str(true) == ~"true");
+        assert_eq!(to_str(false), ~"false");
+        assert_eq!(to_str(true), ~"true");
     }
 
     #[test]
     fn test_bool_to_bit() {
         do all_values |v| {
-            assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 });
+            assert_eq!(to_bit(v), if is_true(v) { 1u8 } else { 0u8 });
         }
     }
 

src/libcore/cast.rs

@@ -145,7 +145,7 @@ mod tests {
 
     #[test]
     fn test_transmute_copy() {
-        assert!(1u == unsafe { ::cast::transmute_copy(&1) });
+        assert_eq!(1u, unsafe { ::cast::transmute_copy(&1) });
     }
 
     #[test]
@@ -177,7 +177,7 @@ mod tests {
     #[test]
     fn test_transmute2() {
         unsafe {
-            assert!(~[76u8, 0u8] == transmute(~"L"));
+            assert_eq!(~[76u8, 0u8], transmute(~"L"));
         }
     }
 }

src/libcore/cell.rs

@@ -122,7 +122,7 @@ fn test_with_ref() {
     let good = 6;
     let c = Cell(~[1, 2, 3, 4, 5, 6]);
     let l = do c.with_ref() |v| { v.len() };
-    assert!(l == good);
+    assert_eq!(l, good);
 }
 
 #[test]
@@ -132,5 +132,5 @@ fn test_with_mut_ref() {
     let c = Cell(v);
     do c.with_mut_ref() |v| { v.push(3); }
     let v = c.take();
-    assert!(v == good);
+    assert_eq!(v, good);
 }

src/libcore/clone.rs

@@ -146,14 +146,14 @@ deep_clone_impl!(char)
 fn test_owned_clone() {
     let a = ~5i;
     let b: ~int = a.clone();
-    assert!(a == b);
+    assert_eq!(a, b);
 }
 
 #[test]
 fn test_managed_clone() {
     let a = @5i;
     let b: @int = a.clone();
-    assert!(a == b);
+    assert_eq!(a, b);
 }
 
 #[test]
@@ -168,9 +168,9 @@ fn test_managed_mut_deep_clone() {
 fn test_managed_mut_clone() {
     let a = @mut 5i;
     let b: @mut int = a.clone();
-    assert!(a == b);
+    assert_eq!(a, b);
     *b = 10;
-    assert!(a == b);
+    assert_eq!(a, b);
 }
 
 #[test]

src/libcore/hash.rs

@@ -490,7 +490,7 @@ mod tests {
             let vec = u8to64_le!(vecs[t], 0);
             let out = buf.hash_keyed(k0, k1);
             debug!("got %?, expected %?", out, vec);
-            assert!(vec == out);
+            assert_eq!(vec, out);
 
             stream_full.reset();
             stream_full.input(buf);
@@ -512,19 +512,19 @@ mod tests {
     fn test_hash_uint() {
         let val = 0xdeadbeef_deadbeef_u64;
         assert!((val as u64).hash() != (val as uint).hash());
-        assert!((val as u32).hash() == (val as uint).hash());
+        assert_eq!((val as u32).hash(), (val as uint).hash());
     }
     #[test] #[cfg(target_arch = "x86_64")]
     fn test_hash_uint() {
         let val = 0xdeadbeef_deadbeef_u64;
-        assert!((val as u64).hash() == (val as uint).hash());
+        assert_eq!((val as u64).hash(), (val as uint).hash());
         assert!((val as u32).hash() != (val as uint).hash());
     }
     #[test] #[cfg(target_arch = "x86")]
     fn test_hash_uint() {
         let val = 0xdeadbeef_deadbeef_u64;
         assert!((val as u64).hash() != (val as uint).hash());
-        assert!((val as u32).hash() == (val as uint).hash());
+        assert_eq!((val as u32).hash(), (val as uint).hash());
     }
 
     #[test]

src/libcore/hashmap.rs

@@ -842,8 +842,8 @@ mod test_map {
         let mut m = HashMap::new();
         assert!(m.insert(1, 2));
         assert!(m.insert(2, 4));
-        assert!(*m.get(&1) == 2);
-        assert!(*m.get(&2) == 4);
+        assert_eq!(*m.get(&1), 2);
+        assert_eq!(*m.get(&2), 4);
     }
 
     #[test]
@@ -863,9 +863,9 @@ mod test_map {
     fn test_insert_overwrite() {
         let mut m = HashMap::new();
         assert!(m.insert(1, 2));
-        assert!(*m.get(&1) == 2);
+        assert_eq!(*m.get(&1), 2);
         assert!(!m.insert(1, 3));
-        assert!(*m.get(&1) == 3);
+        assert_eq!(*m.get(&1), 3);
     }
 
     #[test]
@@ -874,9 +874,9 @@ mod test_map {
         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);
+        assert_eq!(*m.get(&9), 4);
+        assert_eq!(*m.get(&5), 3);
+        assert_eq!(*m.get(&1), 2);
     }
 
     #[test]
@@ -886,8 +886,8 @@ mod test_map {
         assert!(m.insert(5, 3));
         assert!(m.insert(9, 4));
         assert!(m.remove(&1));
-        assert!(*m.get(&9) == 4);
-        assert!(*m.get(&5) == 3);
+        assert_eq!(*m.get(&9), 4);
+        assert_eq!(*m.get(&5), 3);
     }
 
     #[test]
@@ -903,30 +903,30 @@ mod test_map {
     fn test_pop() {
         let mut m = HashMap::new();
         m.insert(1, 2);
-        assert!(m.pop(&1) == Some(2));
-        assert!(m.pop(&1) == None);
+        assert_eq!(m.pop(&1), Some(2));
+        assert_eq!(m.pop(&1), None);
     }
 
     #[test]
     fn test_swap() {
         let mut m = HashMap::new();
-        assert!(m.swap(1, 2) == None);
-        assert!(m.swap(1, 3) == Some(2));
-        assert!(m.swap(1, 4) == Some(3));
+        assert_eq!(m.swap(1, 2), None);
+        assert_eq!(m.swap(1, 3), Some(2));
+        assert_eq!(m.swap(1, 4), Some(3));
     }
 
     #[test]
     fn test_find_or_insert() {
         let mut m = HashMap::new::<int, int>();
-        assert!(m.find_or_insert(1, 2) == &2);
-        assert!(m.find_or_insert(1, 3) == &2);
+        assert_eq!(m.find_or_insert(1, 2), &2);
+        assert_eq!(m.find_or_insert(1, 3), &2);
     }
 
     #[test]
     fn test_find_or_insert_with() {
         let mut m = HashMap::new::<int, int>();
-        assert!(m.find_or_insert_with(1, |_| 2) == &2);
-        assert!(m.find_or_insert_with(1, |_| 3) == &2);
+        assert_eq!(m.find_or_insert_with(1, |_| 2), &2);
+        assert_eq!(m.find_or_insert_with(1, |_| 3), &2);
     }
 
     #[test]
@@ -938,10 +938,10 @@ mod test_map {
         do m.consume |k, v| {
             m2.insert(k, v);
         }
-        assert!(m.len() == 0);
-        assert!(m2.len() == 2);
-        assert!(m2.get(&1) == &2);
-        assert!(m2.get(&2) == &3);
+        assert_eq!(m.len(), 0);
+        assert_eq!(m2.len(), 2);
+        assert_eq!(m2.get(&1), &2);
+        assert_eq!(m2.get(&2), &3);
     }
 
     #[test]
@@ -952,10 +952,10 @@ mod test_map {
         }
         let mut observed = 0;
         for m.each |k, v| {
-            assert!(*v == *k * 2);
+            assert_eq!(*v, *k * 2);
             observed |= (1 << *k);
         }
-        assert!(observed == 0xFFFF_FFFF);
+        assert_eq!(observed, 0xFFFF_FFFF);
     }
 
     #[test]
@@ -984,14 +984,14 @@ mod test_map {
 
         m2.insert(3, 4);
 
-        assert!(m1 == m2);
+        assert_eq!(m1, m2);
     }
 
     #[test]
     fn test_expand() {
         let mut m = HashMap::new();
 
-        assert!(m.len() == 0);
+        assert_eq!(m.len(), 0);
         assert!(m.is_empty());
 
         let mut i = 0u;
@@ -1001,7 +1001,7 @@ mod test_map {
             i += 1;
         }
 
-        assert!(m.len() == i);
+        assert_eq!(m.len(), i);
         assert!(!m.is_empty());
     }
 }
@@ -1090,7 +1090,7 @@ mod test_set {
             assert!(vec::contains(expected, x));
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1113,7 +1113,7 @@ mod test_set {
             assert!(vec::contains(expected, x));
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1139,7 +1139,7 @@ mod test_set {
             assert!(vec::contains(expected, x));
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1169,6 +1169,6 @@ mod test_set {
             assert!(vec::contains(expected, x));
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 }

src/libcore/io.rs

@@ -635,7 +635,7 @@ impl<T:Reader> ReaderUtil for T {
                     let next = bytes[i] as int;
                     i += 1;
                     assert!((next > -1));
-                    assert!((next & 192 == 128));
+                    assert_eq!(next & 192, 128);
                     val <<= 6;
                     val += (next & 63) as uint;
                 }
@@ -676,7 +676,7 @@ impl<T:Reader> ReaderUtil for T {
         if c.len() == 0 {
             return -1 as char; // FIXME will this stay valid? // #2004
         }
-        assert!(c.len() == 1);
+        assert_eq!(c.len(), 1);
         return c[0];
     }
 
@@ -1795,14 +1795,14 @@ mod tests {
         let inp: @io::Reader = result::get(&io::file_reader(tmpfile));
         let frood2: ~str = inp.read_c_str();
         debug!(copy frood2);
-        assert!(frood == frood2);
+        assert_eq!(frood, frood2);
     }
 
     #[test]
     fn test_readchars_empty() {
         do io::with_str_reader(~"") |inp| {
             let res : ~[char] = inp.read_chars(128);
-            assert!(res.len() == 0);
+            assert_eq!(res.len(), 0);
         }
     }
 
@@ -1810,18 +1810,18 @@ mod tests {
     fn test_read_line_utf8() {
         do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
             let line = inp.read_line();
-            assert!(line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
+            assert_eq!(line, ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
         }
     }
 
     #[test]
     fn test_read_lines() {
         do io::with_str_reader(~"a\nb\nc\n") |inp| {
-            assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
+            assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
         }
 
         do io::with_str_reader(~"a\nb\nc") |inp| {
-            assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]);
+            assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
         }
 
         do io::with_str_reader(~"") |inp| {
@@ -1842,7 +1842,7 @@ mod tests {
             do io::with_str_reader(s) |inp| {
                 let res : ~[char] = inp.read_chars(len);
                 if len <= ivals.len() {
-                    assert!(res.len() == len);
+                    assert_eq!(res.len(), len);
                 }
                 assert!(vec::slice(ivals, 0u, res.len()) ==
                              vec::map(res, |x| *x as int));
@@ -1861,7 +1861,7 @@ mod tests {
     fn test_readchar() {
         do io::with_str_reader(~"生") |inp| {
             let res : char = inp.read_char();
-            assert!((res as int == 29983));
+            assert_eq!(res as int, 29983);
         }
     }
 
@@ -1869,7 +1869,7 @@ mod tests {
     fn test_readchar_empty() {
         do io::with_str_reader(~"") |inp| {
             let res : char = inp.read_char();
-            assert!((res as int == -1));
+            assert_eq!(res as int, -1);
         }
     }
 
@@ -1877,7 +1877,7 @@ mod tests {
     fn file_reader_not_exist() {
         match io::file_reader(&Path("not a file")) {
           result::Err(copy e) => {
-            assert!(e == ~"error opening not a file");
+            assert_eq!(e, ~"error opening not a file");
           }
           result::Ok(_) => fail!()
         }
@@ -1966,7 +1966,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             for uints.each |i| {
-                assert!(file.read_le_u64() == *i);
+                assert_eq!(file.read_le_u64(), *i);
             }
         }
     }
@@ -1988,7 +1988,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             for uints.each |i| {
-                assert!(file.read_be_u64() == *i);
+                assert_eq!(file.read_be_u64(), *i);
             }
         }
     }
@@ -2012,7 +2012,7 @@ mod tests {
             for ints.each |i| {
                 // this tests that the sign extension is working
                 // (comparing the values as i32 would not test this)
-                assert!(file.read_be_int_n(4) == *i as i64);
+                assert_eq!(file.read_be_int_n(4), *i as i64);
             }
         }
     }
@@ -2031,7 +2031,7 @@ mod tests {
         {
             let file = io::file_reader(&path).get();
             let f = file.read_be_f32();
-            assert!(f == 8.1250);
+            assert_eq!(f, 8.1250);
         }
     }
 
@@ -2048,8 +2048,8 @@ mod tests {
 
         {
             let file = io::file_reader(&path).get();
-            assert!(file.read_be_f32() == 8.1250);
-            assert!(file.read_le_f32() == 8.1250);
+            assert_eq!(file.read_be_f32(), 8.1250);
+            assert_eq!(file.read_le_f32(), 8.1250);
         }
     }
 }

src/libcore/num/int-template/int.rs

@@ -85,20 +85,20 @@ mod inst {
 
     #[test]
     fn test_pow() {
-        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));
+        assert_eq!(pow(0, 0u), 1);
+        assert_eq!(pow(0, 1u), 0);
+        assert_eq!(pow(0, 2u), 0);
+        assert_eq!(pow(-1, 0u), 1);
+        assert_eq!(pow(1, 0u), 1);
+        assert_eq!(pow(-3, 2u), 9);
+        assert_eq!(pow(-3, 3u), -27);
+        assert_eq!(pow(4, 9u), 262144);
     }
 
     #[test]
     fn test_overflows() {
         assert!((::int::max_value > 0));
         assert!((::int::min_value <= 0));
-        assert!((::int::min_value + ::int::max_value + 1 == 0));
+        assert_eq!(::int::min_value + ::int::max_value + 1, 0);
     }
 }

src/libcore/num/uint-template/uint.rs

@@ -211,46 +211,46 @@ pub mod inst {
 
     #[test]
     fn test_next_power_of_two() {
-        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));
+        assert_eq!(next_power_of_two(0u), 0u);
+        assert_eq!(next_power_of_two(1u), 1u);
+        assert_eq!(next_power_of_two(2u), 2u);
+        assert_eq!(next_power_of_two(3u), 4u);
+        assert_eq!(next_power_of_two(4u), 4u);
+        assert_eq!(next_power_of_two(5u), 8u);
+        assert_eq!(next_power_of_two(6u), 8u);
+        assert_eq!(next_power_of_two(7u), 8u);
+        assert_eq!(next_power_of_two(8u), 8u);
+        assert_eq!(next_power_of_two(9u), 16u);
+        assert_eq!(next_power_of_two(10u), 16u);
+        assert_eq!(next_power_of_two(11u), 16u);
+        assert_eq!(next_power_of_two(12u), 16u);
+        assert_eq!(next_power_of_two(13u), 16u);
+        assert_eq!(next_power_of_two(14u), 16u);
+        assert_eq!(next_power_of_two(15u), 16u);
+        assert_eq!(next_power_of_two(16u), 16u);
+        assert_eq!(next_power_of_two(17u), 32u);
+        assert_eq!(next_power_of_two(18u), 32u);
+        assert_eq!(next_power_of_two(19u), 32u);
+        assert_eq!(next_power_of_two(20u), 32u);
+        assert_eq!(next_power_of_two(21u), 32u);
+        assert_eq!(next_power_of_two(22u), 32u);
+        assert_eq!(next_power_of_two(23u), 32u);
+        assert_eq!(next_power_of_two(24u), 32u);
+        assert_eq!(next_power_of_two(25u), 32u);
+        assert_eq!(next_power_of_two(26u), 32u);
+        assert_eq!(next_power_of_two(27u), 32u);
+        assert_eq!(next_power_of_two(28u), 32u);
+        assert_eq!(next_power_of_two(29u), 32u);
+        assert_eq!(next_power_of_two(30u), 32u);
+        assert_eq!(next_power_of_two(31u), 32u);
+        assert_eq!(next_power_of_two(32u), 32u);
+        assert_eq!(next_power_of_two(33u), 64u);
+        assert_eq!(next_power_of_two(34u), 64u);
+        assert_eq!(next_power_of_two(35u), 64u);
+        assert_eq!(next_power_of_two(36u), 64u);
+        assert_eq!(next_power_of_two(37u), 64u);
+        assert_eq!(next_power_of_two(38u), 64u);
+        assert_eq!(next_power_of_two(39u), 64u);
     }
 
     #[test]
@@ -258,14 +258,14 @@ pub mod inst {
         use uint;
         assert!((uint::max_value > 0u));
         assert!((uint::min_value <= 0u));
-        assert!((uint::min_value + uint::max_value + 1u == 0u));
+        assert_eq!(uint::min_value + uint::max_value + 1u, 0u);
     }
 
     #[test]
     fn test_div() {
-        assert!((div_floor(3u, 4u) == 0u));
-        assert!((div_ceil(3u, 4u)  == 1u));
-        assert!((div_round(3u, 4u) == 1u));
+        assert_eq!(div_floor(3u, 4u), 0u);
+        assert_eq!(div_ceil(3u, 4u), 1u);
+        assert_eq!(div_round(3u, 4u), 1u);
     }
 
     #[test]
@@ -274,6 +274,6 @@ pub mod inst {
         let ten = 10 as uint;
         let mut accum = 0;
         for ten.times { accum += 1; }
-        assert!((accum == 10));
+        assert_eq!(accum, 10);
     }
 }

src/libcore/option.rs

@@ -405,7 +405,7 @@ fn test_unwrap_ptr() {
         let opt = Some(x);
         let y = opt.unwrap();
         let addr_y: *int = ::cast::transmute(&*y);
-        assert!(addr_x == addr_y);
+        assert_eq!(addr_x, addr_y);
     }
 }
 
@@ -416,7 +416,7 @@ fn test_unwrap_str() {
     let opt = Some(x);
     let y = opt.unwrap();
     let addr_y = str::as_buf(y, |buf, _len| buf);
-    assert!(addr_x == addr_y);
+    assert_eq!(addr_x, addr_y);
 }
 
 #[test]
@@ -442,7 +442,7 @@ fn test_unwrap_resource() {
         let opt = Some(x);
         let _y = opt.unwrap();
     }
-    assert!(*i == 1);
+    assert_eq!(*i, 1);
 }
 
 #[test]
@@ -453,7 +453,7 @@ fn test_option_dance() {
     for x.each |_x| {
         y2 = y.swap_unwrap();
     }
-    assert!(y2 == 5);
+    assert_eq!(y2, 5);
     assert!(y.is_none());
 }
 #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -474,13 +474,13 @@ fn test_option_while_some() {
             None
         }
     }
-    assert!(i == 11);
+    assert_eq!(i, 11);
 }
 
 #[test]
 fn test_get_or_zero() {
     let some_stuff = Some(42);
-    assert!(some_stuff.get_or_zero() == 42);
+    assert_eq!(some_stuff.get_or_zero(), 42);
     let no_stuff: Option<int> = None;
-    assert!(no_stuff.get_or_zero() == 0);
+    assert_eq!(no_stuff.get_or_zero(), 0);
 }

src/libcore/os.rs

@@ -221,7 +221,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());
-                assert!(vs.len() == 2);
+                assert_eq!(vs.len(), 2);
                 pairs.push((copy vs[0], copy vs[1]));
             }
             pairs
@@ -388,7 +388,7 @@ pub fn pipe() -> Pipe {
     unsafe {
         let mut fds = Pipe {in: 0 as c_int,
                             out: 0 as c_int };
-        assert!((libc::pipe(&mut fds.in) == (0 as c_int)));
+        assert_eq!(libc::pipe(&mut fds.in), (0 as c_int));
         return Pipe {in: fds.in, out: fds.out};
     }
 }
@@ -407,7 +407,7 @@ 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);
-        assert!((res == 0 as c_int));
+        assert_eq!(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};
@@ -1474,7 +1474,7 @@ mod tests {
     fn test_setenv() {
         let n = make_rand_name();
         setenv(n, ~"VALUE");
-        assert!(getenv(n) == option::Some(~"VALUE"));
+        assert_eq!(getenv(n), option::Some(~"VALUE"));
     }
 
     #[test]
@@ -1482,7 +1482,7 @@ mod tests {
         let n = make_rand_name();
         setenv(n, ~"VALUE");
         unsetenv(n);
-        assert!(getenv(n) == option::None);
+        assert_eq!(getenv(n), option::None);
     }
 
     #[test]
@@ -1492,9 +1492,9 @@ mod tests {
         let n = make_rand_name();
         setenv(n, ~"1");
         setenv(n, ~"2");
-        assert!(getenv(n) == option::Some(~"2"));
+        assert_eq!(getenv(n), option::Some(~"2"));
         setenv(n, ~"");
-        assert!(getenv(n) == option::Some(~""));
+        assert_eq!(getenv(n), option::Some(~""));
     }
 
     // Windows GetEnvironmentVariable requires some extra work to make sure
@@ -1509,7 +1509,7 @@ mod tests {
         let n = make_rand_name();
         setenv(n, s);
         debug!(copy s);
-        assert!(getenv(n) == option::Some(s));
+        assert_eq!(getenv(n), option::Some(s));
     }
 
     #[test]
@@ -1567,7 +1567,7 @@ mod tests {
         let oldhome = getenv(~"HOME");
 
         setenv(~"HOME", ~"/home/MountainView");
-        assert!(os::homedir() == Some(Path("/home/MountainView")));
+        assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"");
         assert!(os::homedir().is_none());
@@ -1588,16 +1588,16 @@ mod tests {
         assert!(os::homedir().is_none());
 
         setenv(~"HOME", ~"/home/MountainView");
-        assert!(os::homedir() == Some(Path("/home/MountainView")));
+        assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"");
 
         setenv(~"USERPROFILE", ~"/home/MountainView");
-        assert!(os::homedir() == Some(Path("/home/MountainView")));
+        assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
 
         setenv(~"HOME", ~"/home/MountainView");
         setenv(~"USERPROFILE", ~"/home/PaloAlto");
-        assert!(os::homedir() == Some(Path("/home/MountainView")));
+        assert_eq!(os::homedir(), Some(Path("/home/MountainView")));
 
         oldhome.each(|s| {setenv(~"HOME", *s);true});
         olduserprofile.each(|s| {setenv(~"USERPROFILE", *s);true});
@@ -1668,7 +1668,7 @@ mod tests {
                                    (str::len(s) + 1u) as size_t, ostream)
                       == buf.len() as size_t))
           }
-          assert!((libc::fclose(ostream) == (0u as c_int)));
+          assert_eq!(libc::fclose(ostream), (0u as c_int));
           let in_mode = in.get_mode();
           let rs = os::copy_file(&in, &out);
           if (!os::path_exists(&in)) {
@@ -1676,8 +1676,8 @@ mod tests {
           }
           assert!((rs));
           let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]);
-          assert!((rslt == 0));
-          assert!(out.get_mode() == in_mode);
+          assert_eq!(rslt, 0);
+          assert_eq!(out.get_mode(), in_mode);
           assert!((remove_file(&in)));
           assert!((remove_file(&out)));
         }

src/libcore/path.rs

@@ -952,30 +952,30 @@ mod tests {
         let path = PosixPath("tmp/");
         let path = path.push("/hmm");
         let path = path.normalize();
-        assert!(~"tmp/hmm" == path.to_str());
+        assert_eq!(~"tmp/hmm", path.to_str());
 
         let path = WindowsPath("tmp/");
         let path = path.push("/hmm");
         let path = path.normalize();
-        assert!(~"tmp\\hmm" == path.to_str());
+        assert_eq!(~"tmp\\hmm", path.to_str());
     }
 
     #[test]
     fn test_filetype_foo_bar() {
         let wp = PosixPath("foo.bar");
-        assert!(wp.filetype() == Some(~".bar"));
+        assert_eq!(wp.filetype(), Some(~".bar"));
 
         let wp = WindowsPath("foo.bar");
-        assert!(wp.filetype() == Some(~".bar"));
+        assert_eq!(wp.filetype(), Some(~".bar"));
     }
 
     #[test]
     fn test_filetype_foo() {
         let wp = PosixPath("foo");
-        assert!(wp.filetype() == None);
+        assert_eq!(wp.filetype(), None);
 
         let wp = WindowsPath("foo");
-        assert!(wp.filetype() == None);
+        assert_eq!(wp.filetype(), None);
     }
 
     #[test]
@@ -986,7 +986,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                assert!(ss == sss);
+                assert_eq!(ss, sss);
             }
         }
 
@@ -1044,7 +1044,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                assert!(ss == sss);
+                assert_eq!(ss, sss);
             }
         }
 
@@ -1107,7 +1107,7 @@ mod tests {
             if (ss != sss) {
                 debug!("got %s", ss);
                 debug!("expected %s", sss);
-                assert!(ss == sss);
+                assert_eq!(ss, sss);
             }
         }
 
@@ -1192,9 +1192,9 @@ mod tests {
 
     #[test]
     fn test_windows_path_restrictions() {
-        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);
+        assert_eq!(WindowsPath("hi").is_restricted(), false);
+        assert_eq!(WindowsPath("C:\\NUL").is_restricted(), true);
+        assert_eq!(WindowsPath("C:\\COM1.TXT").is_restricted(), true);
+        assert_eq!(WindowsPath("c:\\prn.exe").is_restricted(), true);
     }
 }

src/libcore/pipes.rs

@@ -353,7 +353,7 @@ pub fn send<T,Tbuffer>(mut p: SendPacketBuffered<T,Tbuffer>,
     let header = p.header();
     let p_ = p.unwrap();
     let p = unsafe { &mut *p_ };
-    assert!(ptr::to_unsafe_ptr(&(p.header)) == header);
+    assert_eq!(ptr::to_unsafe_ptr(&(p.header)), header);
     assert!(p.payload.is_none());
     p.payload = Some(payload);
     let old_state = swap_state_rel(&mut p.header.state, Full);
@@ -494,7 +494,7 @@ fn try_recv_<T:Owned>(p: &mut Packet<T>) -> Option<T> {
           Terminated => {
             // This assert detects when we've accidentally unsafely
             // casted too big of a number to a state.
-            assert!(old_state == Terminated);
+            assert_eq!(old_state, Terminated);
 
             let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
             if !old_task.is_null() {
@@ -566,7 +566,7 @@ fn receiver_terminate<T:Owned>(p: *mut Packet<T>) {
         if !old_task.is_null() {
             unsafe {
                 rustrt::rust_task_deref(old_task);
-                assert!(old_task == rustrt::rust_get_task());
+                assert_eq!(old_task, rustrt::rust_get_task());
             }
         }
       }

src/libcore/ptr.rs

@@ -343,15 +343,15 @@ pub mod ptr_tests {
             let mut p = Pair {fst: 10, snd: 20};
             let pptr: *mut Pair = &mut p;
             let iptr: *mut int = cast::transmute(pptr);
-            assert!((*iptr == 10));;
+            assert_eq!(*iptr, 10);
             *iptr = 30;
-            assert!((*iptr == 30));
-            assert!((p.fst == 30));;
+            assert_eq!(*iptr, 30);
+            assert_eq!(p.fst, 30);
 
             *pptr = Pair {fst: 50, snd: 60};
-            assert!((*iptr == 50));
-            assert!((p.fst == 50));
-            assert!((p.snd == 60));
+            assert_eq!(*iptr, 50);
+            assert_eq!(p.fst, 50);
+            assert_eq!(p.snd, 60);
 
             let v0 = ~[32000u16, 32001u16, 32002u16];
             let mut v1 = ~[0u16, 0u16, 0u16];
@@ -396,8 +396,8 @@ pub mod ptr_tests {
                 do str::as_c_str(s2) |p2| {
                     let v = ~[p0, p1, p2, null()];
                     do vec::as_imm_buf(v) |vp, len| {
-                        assert!(unsafe { buf_len(vp) } == 3u);
-                        assert!(len == 4u);
+                        assert_eq!(unsafe { buf_len(vp) }, 3u);
+                        assert_eq!(len, 4u);
                     }
                 }
             }
@@ -448,11 +448,11 @@ pub mod ptr_tests {
                                          debug!(
                                              "test_ptr_array_each e: %s, a: %s",
                                              expected, actual);
-                                         assert!(actual == expected);
+                                         assert_eq!(actual, expected);
                                          ctr += 1;
                                          iteration_count += 1;
                                      });
-            assert!(iteration_count == 3u);
+            assert_eq!(iteration_count, 3u);
         }
     }
     #[test]
@@ -480,11 +480,11 @@ pub mod ptr_tests {
                 debug!(
                     "test_ptr_array_each e: %s, a: %s",
                     expected, actual);
-                assert!(actual == expected);
+                assert_eq!(actual, expected);
                 ctr += 1;
                 iteration_count += 1;
             });
-            assert!(iteration_count == 3);
+            assert_eq!(iteration_count, 3);
         }
     }
     #[test]

src/libcore/rand.rs

@@ -880,7 +880,7 @@ mod tests {
         let seed = seed();
         let mut ra = IsaacRng::new_seeded(seed);
         let mut rb = IsaacRng::new_seeded(seed);
-        assert!(ra.gen_str(100u) == rb.gen_str(100u));
+        assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
     }
 
     #[test]
@@ -889,7 +889,7 @@ mod tests {
         let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
         let mut ra = IsaacRng::new_seeded(seed);
         let mut rb = IsaacRng::new_seeded(seed);
-        assert!(ra.gen_str(100u) == rb.gen_str(100u));
+        assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
     }
 
     #[test]
@@ -908,8 +908,8 @@ mod tests {
         let mut r = rng();
         let a = r.gen_int_range(-3, 42);
         assert!(a >= -3 && a < 42);
-        assert!(r.gen_int_range(0, 1) == 0);
-        assert!(r.gen_int_range(-12, -11) == -12);
+        assert_eq!(r.gen_int_range(0, 1), 0);
+        assert_eq!(r.gen_int_range(-12, -11), -12);
     }
 
     #[test]
@@ -925,8 +925,8 @@ mod tests {
         let mut r = rng();
         let a = r.gen_uint_range(3u, 42u);
         assert!(a >= 3u && a < 42u);
-        assert!(r.gen_uint_range(0u, 1u) == 0u);
-        assert!(r.gen_uint_range(12u, 13u) == 12u);
+        assert_eq!(r.gen_uint_range(0u, 1u), 0u);
+        assert_eq!(r.gen_uint_range(12u, 13u), 12u);
     }
 
     #[test]
@@ -948,8 +948,8 @@ mod tests {
     #[test]
     fn test_gen_weighted_bool() {
         let mut r = rng();
-        assert!(r.gen_weighted_bool(0u) == true);
-        assert!(r.gen_weighted_bool(1u) == true);
+        assert_eq!(r.gen_weighted_bool(0u), true);
+        assert_eq!(r.gen_weighted_bool(1u), true);
     }
 
     #[test]
@@ -958,23 +958,23 @@ mod tests {
         debug!(r.gen_str(10u));
         debug!(r.gen_str(10u));
         debug!(r.gen_str(10u));
-        assert!(r.gen_str(0u).len() == 0u);
-        assert!(r.gen_str(10u).len() == 10u);
-        assert!(r.gen_str(16u).len() == 16u);
+        assert_eq!(r.gen_str(0u).len(), 0u);
+        assert_eq!(r.gen_str(10u).len(), 10u);
+        assert_eq!(r.gen_str(16u).len(), 16u);
     }
 
     #[test]
     fn test_gen_bytes() {
         let mut r = rng();
-        assert!(r.gen_bytes(0u).len() == 0u);
-        assert!(r.gen_bytes(10u).len() == 10u);
-        assert!(r.gen_bytes(16u).len() == 16u);
+        assert_eq!(r.gen_bytes(0u).len(), 0u);
+        assert_eq!(r.gen_bytes(10u).len(), 10u);
+        assert_eq!(r.gen_bytes(16u).len(), 16u);
     }
 
     #[test]
     fn test_choose() {
         let mut r = rng();
-        assert!(r.choose([1, 1, 1]) == 1);
+        assert_eq!(r.choose([1, 1, 1]), 1);
     }
 
     #[test]
@@ -982,7 +982,7 @@ mod tests {
         let mut r = rng();
         let x: Option<int> = r.choose_option([]);
         assert!(x.is_none());
-        assert!(r.choose_option([1, 1, 1]) == Some(1));
+        assert_eq!(r.choose_option([1, 1, 1]), Some(1));
     }
 
     #[test]
@@ -1015,7 +1015,7 @@ mod tests {
     fn test_weighted_vec() {
         let mut r = rng();
         let empty: ~[int] = ~[];
-        assert!(r.weighted_vec(~[]) == empty);
+        assert_eq!(r.weighted_vec(~[]), empty);
         assert!(r.weighted_vec(~[
             Weighted { weight: 0u, item: 3u },
             Weighted { weight: 1u, item: 2u },
@@ -1027,16 +1027,16 @@ mod tests {
     fn test_shuffle() {
         let mut r = rng();
         let empty: ~[int] = ~[];
-        assert!(r.shuffle(~[]) == empty);
-        assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
+        assert_eq!(r.shuffle(~[]), empty);
+        assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
     }
 
     #[test]
     fn test_task_rng() {
         let mut r = task_rng();
         r.gen::<int>();
-        assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]);
-        assert!(r.gen_uint_range(0u, 1u) == 0u);
+        assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
+        assert_eq!(r.gen_uint_range(0u, 1u), 0u);
     }
 
     #[test]

src/libcore/repr.rs

@@ -220,7 +220,7 @@ pub impl ReprVisitor {
         } else if mtbl == 1 {
             // skip, this is ast::m_imm
         } else {
-            assert!(mtbl == 2);
+            assert_eq!(mtbl, 2);
             self.writer.write_str("const ");
         }
     }
@@ -592,7 +592,7 @@ fn test_repr() {
             error!("expected '%s', got '%s'",
                    e, s);
         }
-        assert!(s == e);
+        assert_eq!(s, e);
     }
 
     exact_test(&10, "10");

src/libcore/result.rs

@@ -407,12 +407,12 @@ mod tests {
 
     #[test]
     pub fn chain_success() {
-        assert!(get(&chain(op1(), op2)) == 667u);
+        assert_eq!(get(&chain(op1(), op2)), 667u);
     }
 
     #[test]
     pub fn chain_failure() {
-        assert!(get_err(&chain(op3(), op2)) == ~"sadface");
+        assert_eq!(get_err(&chain(op3(), op2)), ~"sadface");
     }
 
     #[test]
@@ -438,19 +438,19 @@ mod tests {
 
     #[test]
     pub fn test_impl_map() {
-        assert!(Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b"));
-        assert!(Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map(|_x| ~"b"), Ok(~"b"));
+        assert_eq!(Err::<~str, ~str>(~"a").map(|_x| ~"b"), Err(~"a"));
     }
 
     #[test]
     pub fn test_impl_map_err() {
-        assert!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a"));
-        assert!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b"));
+        assert_eq!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b"), Ok(~"a"));
+        assert_eq!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b"), Err(~"b"));
     }
 
     #[test]
     pub fn test_get_ref_method() {
         let foo: Result<int, ()> = Ok(100);
-        assert!(*foo.get_ref() == 100);
+        assert_eq!(*foo.get_ref(), 100);
     }
 }

src/libcore/rt/io/flate.rs

@@ -114,8 +114,8 @@ mod test {
         let mut inflate_reader = InflateReader::new(mem_reader);
         let mut out_bytes = [0, .. 100];
         let bytes_read = inflate_reader.read(out_bytes).get();
-        assert!(bytes_read == in_bytes.len());
+        assert_eq!(bytes_read, in_bytes.len());
         let out_msg = str::from_bytes(out_bytes);
         assert!(in_msg == out_msg);
     }
-}
+}

src/libcore/rt/io/mem.rs

@@ -86,7 +86,7 @@ impl Reader for MemReader {
         {
             let input = self.buf.slice(self.pos, self.pos + write_len);
             let output = vec::mut_slice(buf, 0, write_len);
-            assert!(input.len() == output.len());
+            assert_eq!(input.len(), output.len());
             vec::bytes::copy_memory(output, input, write_len);
         }
         self.pos += write_len;
@@ -189,33 +189,33 @@ mod test {
     #[test]
     fn test_mem_writer() {
         let mut writer = MemWriter::new();
-        assert!(writer.tell() == 0);
+        assert_eq!(writer.tell(), 0);
         writer.write([0]);
-        assert!(writer.tell() == 1);
+        assert_eq!(writer.tell(), 1);
         writer.write([1, 2, 3]);
         writer.write([4, 5, 6, 7]);
-        assert!(writer.tell() == 8);
-        assert!(writer.inner() == ~[0, 1, 2, 3, 4, 5 , 6, 7]);
+        assert_eq!(writer.tell(), 8);
+        assert_eq!(writer.inner(), ~[0, 1, 2, 3, 4, 5 , 6, 7]);
     }
 
     #[test]
     fn test_mem_reader() {
         let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
         let mut buf = [];
-        assert!(reader.read(buf) == Some(0));
-        assert!(reader.tell() == 0);
+        assert_eq!(reader.read(buf), Some(0));
+        assert_eq!(reader.tell(), 0);
         let mut buf = [0];
-        assert!(reader.read(buf) == Some(1));
-        assert!(reader.tell() == 1);
-        assert!(buf == [0]);
+        assert_eq!(reader.read(buf), Some(1));
+        assert_eq!(reader.tell(), 1);
+        assert_eq!(buf, [0]);
         let mut buf = [0, ..4];
-        assert!(reader.read(buf) == Some(4));
-        assert!(reader.tell() == 5);
-        assert!(buf == [1, 2, 3, 4]);
-        assert!(reader.read(buf) == Some(3));
-        assert!(buf.slice(0, 3) == [5, 6, 7]);
+        assert_eq!(reader.read(buf), Some(4));
+        assert_eq!(reader.tell(), 5);
+        assert_eq!(buf, [1, 2, 3, 4]);
+        assert_eq!(reader.read(buf), Some(3));
+        assert_eq!(buf.slice(0, 3), [5, 6, 7]);
         assert!(reader.eof());
-        assert!(reader.read(buf) == None);
+        assert_eq!(reader.read(buf), None);
         assert!(reader.eof());
     }
 }

src/libcore/rt/io/net/tcp.rs

@@ -262,7 +262,7 @@ mod test {
                     let mut stream = listener.accept();
                     let mut buf = [0];
                     stream.read(buf);
-                    assert!(buf[0] == 99);
+                    assert_eq!(buf[0], 99);
                 }
             }
 

src/libcore/rt/io/option.rs

@@ -87,7 +87,7 @@ mod test {
             let mut writer: Option<MemWriter> = Some(MemWriter::new());
             writer.write([0, 1, 2]);
             writer.flush();
-            assert!(writer.unwrap().inner() == ~[0, 1, 2]);
+            assert_eq!(writer.unwrap().inner(), ~[0, 1, 2]);
         }
     }
 
@@ -98,7 +98,7 @@ mod test {
 
             let mut called = false;
             do io_error::cond.trap(|err| {
-                assert!(err.kind == PreviousIoError);
+                assert_eq!(err.kind, PreviousIoError);
                 called = true;
             }).in {
                 writer.write([0, 0, 0]);
@@ -107,7 +107,7 @@ mod test {
 
             let mut called = false;
             do io_error::cond.trap(|err| {
-                assert!(err.kind == PreviousIoError);
+                assert_eq!(err.kind, PreviousIoError);
                 called = true;
             }).in {
                 writer.flush();
@@ -122,7 +122,7 @@ mod test {
             let mut reader: Option<MemReader> = Some(MemReader::new(~[0, 1, 2, 3]));
             let mut buf = [0, 0];
             reader.read(buf);
-            assert!(buf == [0, 1]);
+            assert_eq!(buf, [0, 1]);
             assert!(!reader.eof());
         }
     }
@@ -134,7 +134,7 @@ mod test {
 
         let mut called = false;
         do read_error::cond.trap(|err| {
-            assert!(err.kind == PreviousIoError);
+            assert_eq!(err.kind, PreviousIoError);
             called = true;
         }).in {
             reader.read(buf);
@@ -143,7 +143,7 @@ mod test {
 
         let mut called = false;
         do io_error::cond.trap(|err| {
-            assert!(err.kind == PreviousIoError);
+            assert_eq!(err.kind, PreviousIoError);
             called = true;
         }).in {
             assert!(reader.eof());

src/libcore/rt/mod.rs

@@ -217,15 +217,15 @@ fn test_context() {
     use rt::uv::uvio::UvEventLoop;
     use cell::Cell;
 
-    assert!(context() == OldTaskContext);
+    assert_eq!(context(), OldTaskContext);
     do run_in_bare_thread {
-        assert!(context() == GlobalContext);
+        assert_eq!(context(), GlobalContext);
         let mut sched = ~UvEventLoop::new_scheduler();
         let task = ~do Coroutine::new(&mut sched.stack_pool) {
-            assert!(context() == TaskContext);
+            assert_eq!(context(), TaskContext);
             let sched = local_sched::take();
             do sched.deschedule_running_task_and_then() |task| {
-                assert!(context() == SchedulerContext);
+                assert_eq!(context(), SchedulerContext);
                 let task = Cell(task);
                 do local_sched::borrow |sched| {
                     sched.enqueue_task(task.take());

src/libcore/rt/sched.rs

@@ -445,7 +445,7 @@ mod test {
                 sched.enqueue_task(task);
             }
             sched.run();
-            assert!(task_count == total);
+            assert_eq!(task_count, total);
         }
     }
 
@@ -473,7 +473,7 @@ mod test {
             };
             sched.enqueue_task(task1);
             sched.run();
-            assert!(count == 3);
+            assert_eq!(count, 3);
         }
     }
 
@@ -492,7 +492,7 @@ mod test {
             sched.enqueue_task(start_task);
             sched.run();
 
-            assert!(count == MAX);
+            assert_eq!(count, MAX);
 
             fn run_task(count_ptr: *mut int) {
                 do local_sched::borrow |sched| {

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) {
-    assert!(0 == pthread_key_create(key, null()));
+    assert_eq!(0, pthread_key_create(key, null()));
 }
 
 #[cfg(unix)]
 pub unsafe fn set(key: Key, value: *mut c_void) {
-    assert!(0 == pthread_setspecific(key, value));
+    assert_eq!(0, pthread_setspecific(key, value));
 }
 
 #[cfg(unix)]
@@ -91,10 +91,10 @@ fn tls_smoke_test() {
         create(&mut key);
         set(key, transmute(value));
         let value: ~int = transmute(get(key));
-        assert!(value == ~20);
+        assert_eq!(value, ~20);
         let value = ~30;
         set(key, transmute(value));
         let value: ~int = transmute(get(key));
-        assert!(value == ~30);
+        assert_eq!(value, ~30);
     }
 }

src/libcore/rt/uv/mod.rs

@@ -231,7 +231,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);
-    assert!(err.to_str() == ~"EOF: end of file");
+    assert_eq!(err.to_str(), ~"EOF: end of file");
 }
 
 pub fn last_uv_error<H, W: Watcher + NativeHandle<*H>>(watcher: &W) -> UvError {
@@ -397,7 +397,7 @@ fn idle_smoke_test() {
         }
         loop_.run();
         loop_.close();
-        assert!(count == 10);
+        assert_eq!(count, 10);
     }
 }
 

src/libcore/rt/uv/net.rs

@@ -114,7 +114,7 @@ pub impl StreamWatcher {
         let self_handle = self.native_handle() as *c_void;
         let stream_handle = stream.native_handle() as *c_void;
         unsafe {
-            assert!(0 == uvll::accept(self_handle, stream_handle));
+            assert_eq!(0, uvll::accept(self_handle, stream_handle));
         }
     }
 
@@ -158,7 +158,7 @@ pub impl TcpWatcher {
         unsafe {
             let handle = malloc_handle(UV_TCP);
             assert!(handle.is_not_null());
-            assert!(0 == uvll::tcp_init(loop_.native_handle(), handle));
+            assert_eq!(0, uvll::tcp_init(loop_.native_handle(), handle));
             let mut watcher: TcpWatcher = NativeHandle::from_native_handle(handle);
             watcher.install_watcher_data();
             return watcher;
@@ -350,7 +350,7 @@ mod test {
             do tcp_watcher.connect(addr) |stream_watcher, status| {
                 rtdebug!("tcp_watcher.connect!");
                 assert!(status.is_some());
-                assert!(status.get().name() == ~"ECONNREFUSED");
+                assert_eq!(status.get().name(), ~"ECONNREFUSED");
                 stream_watcher.close(||());
             }
             loop_.run();
@@ -397,7 +397,7 @@ mod test {
                             count += 1;
                         }
                     } else {
-                        assert!(count == MAX);
+                        assert_eq!(count, MAX);
                         do stream_watcher.close {
                             server_stream_watcher.close(||());
                         }

src/libcore/rt/uv/uvio.rs

@@ -97,7 +97,7 @@ fn test_callback_run_once() {
             unsafe { *count_ptr += 1 }
         }
         event_loop.run();
-        assert!(count == 1);
+        assert_eq!(count, 1);
     }
 }
 
@@ -379,10 +379,10 @@ fn test_simple_tcp_server_and_client() {
                 let mut stream = listener.accept().unwrap();
                 let mut buf = [0, .. 2048];
                 let nread = stream.read(buf).unwrap();
-                assert!(nread == 8);
+                assert_eq!(nread, 8);
                 for uint::range(0, nread) |i| {
                     rtdebug!("%u", buf[i] as uint);
-                    assert!(buf[i] == i as u8);
+                    assert_eq!(buf[i], i as u8);
                 }
             }
         }
@@ -416,7 +416,7 @@ fn test_read_and_block() {
                 let nread = stream.read(buf).unwrap();
                 for uint::range(0, nread) |i| {
                     let val = buf[i] as uint;
-                    assert!(val == current % 8);
+                    assert_eq!(val, current % 8);
                     current += 1;
                 }
                 reads += 1;
@@ -482,7 +482,7 @@ fn test_read_read_read() {
                     rtdebug!("read %u bytes", nread as uint);
                     total_bytes_read += nread;
                     for uint::range(0, nread) |i| {
-                        assert!(buf[i] == 1);
+                        assert_eq!(buf[i], 1);
                     }
                 }
                 rtdebug!("read %u bytes total", total_bytes_read as uint);

src/libcore/rt/uv/uvll.rs

@@ -132,14 +132,14 @@ pub unsafe fn free_req(v: *c_void) {
 #[test]
 fn handle_sanity_check() {
     unsafe {
-        assert!(UV_HANDLE_TYPE_MAX as uint == rust_uv_handle_type_max());
+        assert_eq!(UV_HANDLE_TYPE_MAX as uint, rust_uv_handle_type_max());
     }
 }
 
 #[test]
 fn request_sanity_check() {
     unsafe {
-        assert!(UV_REQ_TYPE_MAX as uint == rust_uv_req_type_max());
+        assert_eq!(UV_REQ_TYPE_MAX as uint, rust_uv_req_type_max());
     }
 }
 

src/libcore/run.rs

@@ -835,7 +835,7 @@ mod tests {
 
         debug!(copy expected);
         debug!(copy actual);
-        assert!((expected == actual));
+        assert_eq!(expected, actual);
     }
 
     #[test]
@@ -844,7 +844,7 @@ mod tests {
                                      &None, &None,
                                      0i32, 0i32, 0i32);
         let status = run::waitpid(pid);
-        assert!(status == 1);
+        assert_eq!(status, 1);
     }
 
     #[test]

src/libcore/str.rs

@@ -67,7 +67,7 @@ pub fn from_bytes(vv: &const [u8]) -> ~str {
  * Fails if not null terminated
  */
 pub fn from_bytes_with_null<'a>(vv: &'a [u8]) -> &'a str {
-    assert!(vv[vv.len() - 1] == 0);
+    assert_eq!(vv[vv.len() - 1], 0);
     assert!(is_utf8(vv));
     return unsafe { raw::from_bytes_with_null(vv) };
 }
@@ -2247,7 +2247,7 @@ pub fn char_range_at(s: &str, i: uint) -> CharRange {
     let mut i = i + 1u;
     while i < end {
         let byte = s[i];
-        assert!((byte & 192u8 == tag_cont_u8));
+        assert_eq!(byte & 192u8, tag_cont_u8);
         val <<= 6u;
         val += (byte & 63u8) as uint;
         i += 1u;
@@ -2733,7 +2733,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);
-            assert!((c == ~"AAA"));
+            assert_eq!(c, ~"AAA");
         }
     }
 
@@ -3160,47 +3160,47 @@ mod tests {
 
     #[test]
     fn test_len() {
-        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));
+        assert_eq!(len(~""), 0u);
+        assert_eq!(len(~"hello world"), 11u);
+        assert_eq!(len(~"\x63"), 1u);
+        assert_eq!(len(~"\xa2"), 2u);
+        assert_eq!(len(~"\u03c0"), 2u);
+        assert_eq!(len(~"\u2620"), 3u);
+        assert_eq!(len(~"\U0001d11e"), 4u);
 
-        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));
+        assert_eq!(char_len(~""), 0u);
+        assert_eq!(char_len(~"hello world"), 11u);
+        assert_eq!(char_len(~"\x63"), 1u);
+        assert_eq!(char_len(~"\xa2"), 1u);
+        assert_eq!(char_len(~"\u03c0"), 1u);
+        assert_eq!(char_len(~"\u2620"), 1u);
+        assert_eq!(char_len(~"\U0001d11e"), 1u);
+        assert_eq!(char_len(~"ประเทศไทย中华Việt Nam"), 19u);
     }
 
     #[test]
     fn test_rfind_char() {
-        assert!(rfind_char(~"hello", 'l') == Some(3u));
-        assert!(rfind_char(~"hello", 'o') == Some(4u));
-        assert!(rfind_char(~"hello", 'h') == Some(0u));
+        assert_eq!(rfind_char(~"hello", 'l'), Some(3u));
+        assert_eq!(rfind_char(~"hello", 'o'), Some(4u));
+        assert_eq!(rfind_char(~"hello", 'h'), Some(0u));
         assert!(rfind_char(~"hello", 'z').is_none());
-        assert!(rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u));
+        assert_eq!(rfind_char(~"ประเทศไทย中华Việt Nam", '华'), Some(30u));
     }
 
     #[test]
     fn test_pop_char() {
         let mut data = ~"ประเทศไทย中华";
         let cc = pop_char(&mut data);
-        assert!(~"ประเทศไทย中" == data);
-        assert!('华' == cc);
+        assert_eq!(~"ประเทศไทย中", data);
+        assert_eq!('华', cc);
     }
 
     #[test]
     fn test_pop_char_2() {
         let mut data2 = ~"华";
         let cc2 = pop_char(&mut data2);
-        assert!(~"" == data2);
-        assert!('华' == cc2);
+        assert_eq!(~"", data2);
+        assert_eq!('华', cc2);
     }
 
     #[test]
@@ -3448,58 +3448,58 @@ mod tests {
     fn test_find_str() {
         // byte positions
         assert!(find_str(~"banana", ~"apple pie").is_none());
-        assert!(find_str(~"", ~"") == Some(0u));
+        assert_eq!(find_str(~"", ~""), Some(0u));
 
         let data = ~"ประเทศไทย中华Việt Nam";
-        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_eq!(find_str(data, ~""), Some(0u));
+        assert_eq!(find_str(data, ~"ประเ"), Some( 0u));
+        assert_eq!(find_str(data, ~"ะเ"), Some( 6u));
+        assert_eq!(find_str(data, ~"中华"), Some(27u));
         assert!(find_str(data, ~"ไท华").is_none());
     }
 
     #[test]
     fn test_find_str_between() {
         // byte positions
-        assert!(find_str_between(~"", ~"", 0u, 0u) == Some(0u));
+        assert_eq!(find_str_between(~"", ~"", 0u, 0u), Some(0u));
 
         let data = ~"abcabc";
-        assert!(find_str_between(data, ~"ab", 0u, 6u) == Some(0u));
-        assert!(find_str_between(data, ~"ab", 2u, 6u) == Some(3u));
+        assert_eq!(find_str_between(data, ~"ab", 0u, 6u), Some(0u));
+        assert_eq!(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;
-        assert!(find_str_between(data, ~"", 0u, 43u) == Some(0u));
-        assert!(find_str_between(data, ~"", 6u, 43u) == Some(6u));
+        assert_eq!(find_str_between(data, ~"", 0u, 43u), Some(0u));
+        assert_eq!(find_str_between(data, ~"", 6u, 43u), Some(6u));
 
-        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));
+        assert_eq!(find_str_between(data, ~"ประ", 0u, 43u), Some( 0u));
+        assert_eq!(find_str_between(data, ~"ทศไ", 0u, 43u), Some(12u));
+        assert_eq!(find_str_between(data, ~"ย中", 0u, 43u), Some(24u));
+        assert_eq!(find_str_between(data, ~"iệt", 0u, 43u), Some(34u));
+        assert_eq!(find_str_between(data, ~"Nam", 0u, 43u), Some(40u));
 
-        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));
+        assert_eq!(find_str_between(data, ~"ประ", 43u, 86u), Some(43u));
+        assert_eq!(find_str_between(data, ~"ทศไ", 43u, 86u), Some(55u));
+        assert_eq!(find_str_between(data, ~"ย中", 43u, 86u), Some(67u));
+        assert_eq!(find_str_between(data, ~"iệt", 43u, 86u), Some(77u));
+        assert_eq!(find_str_between(data, ~"Nam", 43u, 86u), Some(83u));
     }
 
     #[test]
     fn test_substr() {
         fn t(a: &str, b: &str, start: int) {
-            assert!(substr(a, start as uint, len(b)) == b);
+            assert_eq!(substr(a, start as uint, len(b)), b);
         }
         t("hello", "llo", 2);
         t("hello", "el", 1);
-        assert!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u));
+        assert_eq!("ะเทศไท", substr("ประเทศไทย中华Việt Nam", 6u, 6u));
     }
 
     #[test]
     fn test_concat() {
         fn t(v: &[~str], s: &str) {
-            assert!(concat(v) == s.to_str());
+            assert_eq!(concat(v), s.to_str());
         }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood");
         let v: ~[~str] = ~[];
@@ -3510,7 +3510,7 @@ mod tests {
     #[test]
     fn test_connect() {
         fn t(v: &[~str], sep: &str, s: &str) {
-            assert!(connect(v, sep) == s.to_str());
+            assert_eq!(connect(v, sep), s.to_str());
         }
         t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"],
           ~" ", ~"you know I'm no good");
@@ -3522,7 +3522,7 @@ mod tests {
     #[test]
     fn test_connect_slices() {
         fn t(v: &[&str], sep: &str, s: &str) {
-            assert!(connect_slices(v, sep) == s.to_str());
+            assert_eq!(connect_slices(v, sep), s.to_str());
         }
         t(["you", "know", "I'm", "no", "good"],
           " ", "you know I'm no good");
@@ -3532,18 +3532,18 @@ mod tests {
 
     #[test]
     fn test_repeat() {
-        assert!(repeat(~"x", 4) == ~"xxxx");
-        assert!(repeat(~"hi", 4) == ~"hihihihi");
-        assert!(repeat(~"ไท华", 3) == ~"ไท华ไท华ไท华");
-        assert!(repeat(~"", 4) == ~"");
-        assert!(repeat(~"hi", 0) == ~"");
+        assert_eq!(repeat(~"x", 4), ~"xxxx");
+        assert_eq!(repeat(~"hi", 4), ~"hihihihi");
+        assert_eq!(repeat(~"ไท华", 3), ~"ไท华ไท华ไท华");
+        assert_eq!(repeat(~"", 4), ~"");
+        assert_eq!(repeat(~"hi", 0), ~"");
     }
 
     #[test]
     fn test_unsafe_slice() {
-        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)});
+        assert_eq!("ab", unsafe {raw::slice_bytes("abc", 0, 2)});
+        assert_eq!("bc", unsafe {raw::slice_bytes("abc", 1, 3)});
+        assert_eq!("", unsafe {raw::slice_bytes("abc", 1, 1)});
         fn a_million_letter_a() -> ~str {
             let mut i = 0;
             let mut rs = ~"";
@@ -3588,13 +3588,13 @@ mod tests {
     #[test]
     fn test_replace() {
         let a = ~"a";
-        assert!(replace(~"", a, ~"b") == ~"");
-        assert!(replace(~"a", a, ~"b") == ~"b");
-        assert!(replace(~"ab", a, ~"b") == ~"bb");
+        assert_eq!(replace(~"", a, ~"b"), ~"");
+        assert_eq!(replace(~"a", a, ~"b"), ~"b");
+        assert_eq!(replace(~"ab", a, ~"b"), ~"bb");
         let test = ~"test";
         assert!(replace(~" test test ", test, ~"toast") ==
             ~" toast toast ");
-        assert!(replace(~" test test ", test, ~"") == ~"   ");
+        assert_eq!(replace(~" test test ", test, ~""), ~"   ");
     }
 
     #[test]
@@ -3604,7 +3604,7 @@ mod tests {
 
         let a = ~"ประเ";
         let A = ~"دولة الكويتทศไทย中华";
-        assert!((replace(data, a, repl) ==  A));
+        assert_eq!(replace(data, a, repl), A);
     }
 
     #[test]
@@ -3614,7 +3614,7 @@ mod tests {
 
         let b = ~"ะเ";
         let B = ~"ปรدولة الكويتทศไทย中华";
-        assert!((replace(data, b,   repl) ==  B));
+        assert_eq!(replace(data, b,   repl), B);
     }
 
     #[test]
@@ -3624,7 +3624,7 @@ mod tests {
 
         let c = ~"中华";
         let C = ~"ประเทศไทยدولة الكويت";
-        assert!((replace(data, c, repl) ==  C));
+        assert_eq!(replace(data, c, repl), C);
     }
 
     #[test]
@@ -3633,21 +3633,21 @@ mod tests {
         let repl = ~"دولة الكويت";
 
         let d = ~"ไท华";
-        assert!((replace(data, d, repl) == data));
+        assert_eq!(replace(data, d, repl), data);
     }
 
     #[test]
     fn test_slice() {
-        assert!("ab" == slice("abc", 0, 2));
-        assert!("bc" == slice("abc", 1, 3));
-        assert!("" == slice("abc", 1, 1));
-        assert!("\u65e5" == slice("\u65e5\u672c", 0, 3));
+        assert_eq!("ab", slice("abc", 0, 2));
+        assert_eq!("bc", slice("abc", 1, 3));
+        assert_eq!("", slice("abc", 1, 1));
+        assert_eq!("\u65e5", slice("\u65e5\u672c", 0, 3));
 
         let data = "ประเทศไทย中华";
-        assert!("ป" == slice(data, 0, 3));
-        assert!("ร" == slice(data, 3, 6));
-        assert!("" == slice(data, 3, 3));
-        assert!("华" == slice(data, 30, 33));
+        assert_eq!("ป", slice(data, 0, 3));
+        assert_eq!("ร", slice(data, 3, 6));
+        assert_eq!("", slice(data, 3, 3));
+        assert_eq!("华", slice(data, 30, 33));
 
         fn a_million_letter_X() -> ~str {
             let mut i = 0;
@@ -3673,16 +3673,16 @@ mod tests {
     fn test_slice_2() {
         let ss = "中华Việt Nam";
 
-        assert!("华" == slice(ss, 3u, 6u));
-        assert!("Việt Nam" == slice(ss, 6u, 16u));
+        assert_eq!("华", slice(ss, 3u, 6u));
+        assert_eq!("Việt Nam", slice(ss, 6u, 16u));
 
-        assert!("ab" == slice("abc", 0u, 2u));
-        assert!("bc" == slice("abc", 1u, 3u));
-        assert!("" == slice("abc", 1u, 1u));
+        assert_eq!("ab", slice("abc", 0u, 2u));
+        assert_eq!("bc", slice("abc", 1u, 3u));
+        assert_eq!("", slice("abc", 1u, 1u));
 
-        assert!("中" == slice(ss, 0u, 3u));
-        assert!("华V" == slice(ss, 3u, 7u));
-        assert!("" == slice(ss, 3u, 3u));
+        assert_eq!("中", slice(ss, 0u, 3u));
+        assert_eq!("华V", slice(ss, 3u, 7u));
+        assert_eq!("", slice(ss, 3u, 3u));
         /*0: 中
           3: 华
           6: V
@@ -3708,7 +3708,7 @@ mod tests {
                      " *** foo *** ");
         assert!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
                      "foo *** ");
-        assert!(trim_left_chars(" ***  *** ", ~['*', ' ']) == "");
+        assert_eq!(trim_left_chars(" ***  *** ", ~['*', ' ']), "");
         assert!(trim_left_chars("foo *** ", ~['*', ' ']) ==
                      "foo *** ");
     }
@@ -3719,47 +3719,47 @@ mod tests {
                      " *** foo *** ");
         assert!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
                      " *** foo");
-        assert!(trim_right_chars(" ***  *** ", ~['*', ' ']) == "");
+        assert_eq!(trim_right_chars(" ***  *** ", ~['*', ' ']), "");
         assert!(trim_right_chars(" *** foo", ~['*', ' ']) ==
                      " *** foo");
     }
 
     #[test]
     fn test_trim_chars() {
-        assert!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** ");
-        assert!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo");
-        assert!(trim_chars(" ***  *** ", ~['*', ' ']) == "");
-        assert!(trim_chars("foo", ~['*', ' ']) == "foo");
+        assert_eq!(trim_chars(" *** foo *** ", ~[]), " *** foo *** ");
+        assert_eq!(trim_chars(" *** foo *** ", ~['*', ' ']), "foo");
+        assert_eq!(trim_chars(" ***  *** ", ~['*', ' ']), "");
+        assert_eq!(trim_chars("foo", ~['*', ' ']), "foo");
     }
 
     #[test]
     fn test_trim_left() {
-        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 "));
+        assert_eq!(trim_left(""), "");
+        assert_eq!(trim_left("a"), "a");
+        assert_eq!(trim_left("    "), "");
+        assert_eq!(trim_left("     blah"), "blah");
+        assert_eq!(trim_left("   \u3000  wut"), "wut");
+        assert_eq!(trim_left("hey "), "hey ");
     }
 
     #[test]
     fn test_trim_right() {
-        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"));
+        assert_eq!(trim_right(""), "");
+        assert_eq!(trim_right("a"), "a");
+        assert_eq!(trim_right("    "), "");
+        assert_eq!(trim_right("blah     "), "blah");
+        assert_eq!(trim_right("wut   \u3000  "), "wut");
+        assert_eq!(trim_right(" hey"), " hey");
     }
 
     #[test]
     fn test_trim() {
-        assert!((trim("") == ""));
-        assert!((trim("a") == "a"));
-        assert!((trim("    ") == ""));
-        assert!((trim("    blah     ") == "blah"));
-        assert!((trim("\nwut   \u3000  ") == "wut"));
-        assert!((trim(" hey dude ") == "hey dude"));
+        assert_eq!(trim(""), "");
+        assert_eq!(trim("a"), "a");
+        assert_eq!(trim("    "), "");
+        assert_eq!(trim("    blah     "), "blah");
+        assert_eq!(trim("\nwut   \u3000  "), "wut");
+        assert_eq!(trim(" hey dude "), "hey dude");
     }
 
     #[test]
@@ -3775,23 +3775,23 @@ mod tests {
     fn test_shift_byte() {
         let mut s = ~"ABC";
         let b = unsafe{raw::shift_byte(&mut s)};
-        assert!((s == ~"BC"));
-        assert!((b == 65u8));
+        assert_eq!(s, ~"BC");
+        assert_eq!(b, 65u8);
     }
 
     #[test]
     fn test_pop_byte() {
         let mut s = ~"ABC";
         let b = unsafe{raw::pop_byte(&mut s)};
-        assert!((s == ~"AB"));
-        assert!((b == 67u8));
+        assert_eq!(s, ~"AB");
+        assert_eq!(b, 67u8);
     }
 
     #[test]
     fn test_unsafe_from_bytes() {
         let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
         let b = unsafe { raw::from_bytes(a) };
-        assert!((b == ~"AAAAAAA"));
+        assert_eq!(b, ~"AAAAAAA");
     }
 
     #[test]
@@ -3808,7 +3808,7 @@ mod tests {
                   0x20_u8, 0x4e_u8, 0x61_u8,
                   0x6d_u8];
 
-        assert!(ss == from_bytes(bb));
+        assert_eq!(ss, from_bytes(bb));
     }
 
     #[test]
@@ -3895,7 +3895,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);
-            assert!((c == ~"AAAAAAA"));
+            assert_eq!(c, ~"AAAAAAA");
         }
     }
 
@@ -3911,20 +3911,20 @@ mod tests {
     fn test_as_buf() {
         let a = ~"Abcdefg";
         let b = as_buf(a, |buf, _l| {
-            assert!(unsafe { *buf } == 65u8);
+            assert_eq!(unsafe { *buf }, 65u8);
             100
         });
-        assert!((b == 100));
+        assert_eq!(b, 100);
     }
 
     #[test]
     fn test_as_buf_small() {
         let a = ~"A";
         let b = as_buf(a, |buf, _l| {
-            assert!(unsafe { *buf } == 65u8);
+            assert_eq!(unsafe { *buf }, 65u8);
             100
         });
-        assert!((b == 100));
+        assert_eq!(b, 100);
     }
 
     #[test]
@@ -3933,7 +3933,7 @@ mod tests {
             let s = ~"hello";
             let sb = as_buf(s, |b, _l| b);
             let s_cstr = raw::from_buf(sb);
-            assert!(s_cstr == s);
+            assert_eq!(s_cstr, s);
         }
     }
 
@@ -3942,11 +3942,11 @@ mod tests {
         let a = ~"hello";
         do as_buf(a) |buf, len| {
             unsafe {
-                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);
+                assert_eq!(a[0], 'h' as u8);
+                assert_eq!(*buf, 'h' as u8);
+                assert_eq!(len, 6u);
+                assert_eq!(*ptr::offset(buf,4u), 'o' as u8);
+                assert_eq!(*ptr::offset(buf,5u), 0u8);
             }
         }
     }
@@ -3956,15 +3956,15 @@ mod tests {
         let a = "kernelsprite";
         let b = slice(a, 7, len(a));
         let c = slice(a, 0, len(a) - 6);
-        assert!(subslice_offset(a, b) == 7);
-        assert!(subslice_offset(a, c) == 0);
+        assert_eq!(subslice_offset(a, b), 7);
+        assert_eq!(subslice_offset(a, c), 0);
 
         let string = "a\nb\nc";
         let mut lines = ~[];
         for each_line(string) |line| { lines.push(line) }
-        assert!(subslice_offset(string, lines[0]) == 0);
-        assert!(subslice_offset(string, lines[1]) == 2);
-        assert!(subslice_offset(string, lines[2]) == 4);
+        assert_eq!(subslice_offset(string, lines[0]), 0);
+        assert_eq!(subslice_offset(string, lines[1]), 2);
+        assert_eq!(subslice_offset(string, lines[2]), 4);
     }
 
     #[test]
@@ -3984,13 +3984,13 @@ mod tests {
         let mut i: uint = 0u;
         let n1: uint = len(s1);
         let n2: uint = vec::len::<u8>(v);
-        assert!((n1 == n2));
+        assert_eq!(n1, n2);
         while i < n1 {
             let a: u8 = s1[i];
             let b: u8 = s2[i];
             debug!(a);
             debug!(b);
-            assert!((a == b));
+            assert_eq!(a, b);
             i += 1u;
         }
     }
@@ -4094,26 +4094,26 @@ mod tests {
 
     #[test]
     fn test_map() {
-        assert!(~"" == map(~"", |c| unsafe {libc::toupper(c as c_char)} as char));
-        assert!(~"YMCA" == map(~"ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
+        assert_eq!(~"", map(~"", |c| unsafe {libc::toupper(c as c_char)} as char));
+        assert_eq!(~"YMCA", map(~"ymca", |c| unsafe {libc::toupper(c as c_char)} as char));
     }
 
     #[test]
     fn test_all() {
-        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));
+        assert_eq!(true, all(~"", char::is_uppercase));
+        assert_eq!(false, all(~"ymca", char::is_uppercase));
+        assert_eq!(true, all(~"YMCA", char::is_uppercase));
+        assert_eq!(false, all(~"yMCA", char::is_uppercase));
+        assert_eq!(false, all(~"YMCy", char::is_uppercase));
     }
 
     #[test]
     fn test_any() {
-        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));
+        assert_eq!(false, any(~"", char::is_uppercase));
+        assert_eq!(false, any(~"ymca", char::is_uppercase));
+        assert_eq!(true, any(~"YMCA", char::is_uppercase));
+        assert_eq!(true, any(~"yMCA", char::is_uppercase));
+        assert_eq!(true, any(~"Ymcy", char::is_uppercase));
     }
 
     #[test]
@@ -4205,7 +4205,7 @@ mod tests {
         let mut pos = 0;
 
         for s.each |b| {
-            assert!(b == v[pos]);
+            assert_eq!(b, v[pos]);
             pos += 1;
         }
     }
@@ -4213,7 +4213,7 @@ mod tests {
     #[test]
     fn test_each_empty() {
         for "".each |b| {
-            assert!(b == 0u8);
+            assert_eq!(b, 0u8);
         }
     }
 
@@ -4228,8 +4228,8 @@ mod tests {
         let mut pos = 0;
 
         for s.eachi |i, b| {
-            assert!(pos == i);
-            assert!(b == v[pos]);
+            assert_eq!(pos, i);
+            assert_eq!(b, v[pos]);
             pos += 1;
         }
     }
@@ -4237,8 +4237,8 @@ mod tests {
     #[test]
     fn test_eachi_empty() {
         for "".eachi |i, b| {
-            assert!(i == 0);
-            assert!(b == 0);
+            assert_eq!(i, 0);
+            assert_eq!(b, 0);
         }
     }
 
@@ -4254,14 +4254,14 @@ mod tests {
 
         for s.each_reverse |b| {
             pos -= 1;
-            assert!(b == v[pos]);
+            assert_eq!(b, v[pos]);
         }
     }
 
     #[test]
     fn test_each_empty_reverse() {
         for "".each_reverse |b| {
-            assert!(b == 0u8);
+            assert_eq!(b, 0u8);
         }
     }
 
@@ -4277,16 +4277,16 @@ mod tests {
 
         for s.eachi_reverse |i, b| {
             pos -= 1;
-            assert!(pos == i);
-            assert!(b == v[pos]);
+            assert_eq!(pos, i);
+            assert_eq!(b, v[pos]);
         }
     }
 
     #[test]
     fn test_eachi_reverse_empty() {
         for "".eachi_reverse |i, b| {
-            assert!(i == 0);
-            assert!(b == 0);
+            assert_eq!(i, 0);
+            assert_eq!(b, 0);
         }
     }
 
@@ -4296,7 +4296,7 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
         for s.each_char |ch| {
-            assert!(ch == v[pos]);
+            assert_eq!(ch, v[pos]);
             pos += 1;
         }
     }
@@ -4307,8 +4307,8 @@ mod tests {
         let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
         let mut pos = 0;
         for s.each_chari |i, ch| {
-            assert!(pos == i);
-            assert!(ch == v[pos]);
+            assert_eq!(pos, i);
+            assert_eq!(ch, v[pos]);
             pos += 1;
         }
     }
@@ -4320,7 +4320,7 @@ mod tests {
         let mut pos = v.len();
         for s.each_char_reverse |ch| {
             pos -= 1;
-            assert!(ch == v[pos]);
+            assert_eq!(ch, v[pos]);
         }
     }
 
@@ -4331,43 +4331,43 @@ mod tests {
         let mut pos = v.len();
         for s.each_chari_reverse |i, ch| {
             pos -= 1;
-            assert!(pos == i);
-            assert!(ch == v[pos]);
+            assert_eq!(pos, i);
+            assert_eq!(ch, v[pos]);
         }
     }
 
     #[test]
     fn test_escape_unicode() {
-        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_eq!(escape_unicode(~"abc"), ~"\\x61\\x62\\x63");
+        assert_eq!(escape_unicode(~"a c"), ~"\\x61\\x20\\x63");
+        assert_eq!(escape_unicode(~"\r\n\t"), ~"\\x0d\\x0a\\x09");
+        assert_eq!(escape_unicode(~"'\"\\"), ~"\\x27\\x22\\x5c");
         assert!(escape_unicode(~"\x00\x01\xfe\xff") ==
                      ~"\\x00\\x01\\xfe\\xff");
-        assert!(escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff");
+        assert_eq!(escape_unicode(~"\u0100\uffff"), ~"\\u0100\\uffff");
         assert!(escape_unicode(~"\U00010000\U0010ffff") ==
             ~"\\U00010000\\U0010ffff");
-        assert!(escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00");
-        assert!(escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d");
+        assert_eq!(escape_unicode(~"ab\ufb00"), ~"\\x61\\x62\\ufb00");
+        assert_eq!(escape_unicode(~"\U0001d4ea\r"), ~"\\U0001d4ea\\x0d");
     }
 
     #[test]
     fn test_escape_default() {
-        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_eq!(escape_default(~"abc"), ~"abc");
+        assert_eq!(escape_default(~"a c"), ~"a c");
+        assert_eq!(escape_default(~"\r\n\t"), ~"\\r\\n\\t");
+        assert_eq!(escape_default(~"'\"\\"), ~"\\'\\\"\\\\");
+        assert_eq!(escape_default(~"\u0100\uffff"), ~"\\u0100\\uffff");
         assert!(escape_default(~"\U00010000\U0010ffff") ==
             ~"\\U00010000\\U0010ffff");
-        assert!(escape_default(~"ab\ufb00") == ~"ab\\ufb00");
-        assert!(escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r");
+        assert_eq!(escape_default(~"ab\ufb00"), ~"ab\\ufb00");
+        assert_eq!(escape_default(~"\U0001d4ea\r"), ~"\\U0001d4ea\\r");
     }
 
     #[test]
     fn test_to_managed() {
-        assert!((~"abc").to_managed() == @"abc");
-        assert!(slice("abcdef", 1, 5).to_managed() == @"bcde");
+        assert_eq!((~"abc").to_managed(), @"abc");
+        assert_eq!(slice("abcdef", 1, 5).to_managed(), @"bcde");
     }
 
     #[test]
@@ -4381,7 +4381,7 @@ mod tests {
 
     #[test]
     fn test_char_range_at_reverse_underflow() {
-        assert!(char_range_at_reverse("abc", 0).next == 0);
+        assert_eq!(char_range_at_reverse("abc", 0).next, 0);
     }
 
     #[test]

src/libcore/sys.rs

@@ -251,10 +251,10 @@ mod tests {
 
     #[test]
     fn size_of_basic() {
-        assert!(size_of::<u8>() == 1u);
-        assert!(size_of::<u16>() == 2u);
-        assert!(size_of::<u32>() == 4u);
-        assert!(size_of::<u64>() == 8u);
+        assert_eq!(size_of::<u8>(), 1u);
+        assert_eq!(size_of::<u16>(), 2u);
+        assert_eq!(size_of::<u32>(), 4u);
+        assert_eq!(size_of::<u64>(), 8u);
     }
 
     #[test]
@@ -262,15 +262,15 @@ mod tests {
     #[cfg(target_arch = "arm")]
     #[cfg(target_arch = "mips")]
     fn size_of_32() {
-        assert!(size_of::<uint>() == 4u);
-        assert!(size_of::<*uint>() == 4u);
+        assert_eq!(size_of::<uint>(), 4u);
+        assert_eq!(size_of::<*uint>(), 4u);
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
     fn size_of_64() {
-        assert!(size_of::<uint>() == 8u);
-        assert!(size_of::<*uint>() == 8u);
+        assert_eq!(size_of::<uint>(), 8u);
+        assert_eq!(size_of::<*uint>(), 8u);
     }
 
     #[test]
@@ -284,9 +284,9 @@ mod tests {
     #[test]
     fn nonzero_size_of_basic() {
         type Z = [i8, ..0];
-        assert!(size_of::<Z>() == 0u);
-        assert!(nonzero_size_of::<Z>() == 1u);
-        assert!(nonzero_size_of::<uint>() == size_of::<uint>());
+        assert_eq!(size_of::<Z>(), 0u);
+        assert_eq!(nonzero_size_of::<Z>(), 1u);
+        assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>());
     }
 
     #[test]
@@ -299,9 +299,9 @@ mod tests {
 
     #[test]
     fn align_of_basic() {
-        assert!(pref_align_of::<u8>() == 1u);
-        assert!(pref_align_of::<u16>() == 2u);
-        assert!(pref_align_of::<u32>() == 4u);
+        assert_eq!(pref_align_of::<u8>(), 1u);
+        assert_eq!(pref_align_of::<u16>(), 2u);
+        assert_eq!(pref_align_of::<u32>(), 4u);
     }
 
     #[test]
@@ -309,15 +309,15 @@ mod tests {
     #[cfg(target_arch = "arm")]
     #[cfg(target_arch = "mips")]
     fn align_of_32() {
-        assert!(pref_align_of::<uint>() == 4u);
-        assert!(pref_align_of::<*uint>() == 4u);
+        assert_eq!(pref_align_of::<uint>(), 4u);
+        assert_eq!(pref_align_of::<*uint>(), 4u);
     }
 
     #[test]
     #[cfg(target_arch = "x86_64")]
     fn align_of_64() {
-        assert!(pref_align_of::<uint>() == 8u);
-        assert!(pref_align_of::<*uint>() == 8u);
+        assert_eq!(pref_align_of::<uint>(), 8u);
+        assert_eq!(pref_align_of::<*uint>(), 8u);
     }
 
     #[test]
@@ -333,7 +333,7 @@ mod tests {
             let x = 10;
             let f: &fn(int) -> int = |y| x + y;
 
-            assert!(f(20) == 30);
+            assert_eq!(f(20), 30);
 
             let original_closure: Closure = cast::transmute(f);
 
@@ -346,7 +346,7 @@ mod tests {
             };
 
             let new_f: &fn(int) -> int = cast::transmute(new_closure);
-            assert!(new_f(20) == 30);
+            assert_eq!(new_f(20), 30);
         }
     }
 

src/libcore/task/mod.rs

@@ -805,7 +805,7 @@ fn test_future_result() {
     let mut builder = task();
     builder.future_result(|r| result = Some(r));
     do builder.spawn {}
-    assert!(result.unwrap().recv() == Success);
+    assert_eq!(result.unwrap().recv(), Success);
 
     result = None;
     let mut builder = task();
@@ -814,7 +814,7 @@ fn test_future_result() {
     do builder.spawn {
         fail!();
     }
-    assert!(result.unwrap().recv() == Failure);
+    assert_eq!(result.unwrap().recv(), Failure);
 }
 
 #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -891,7 +891,7 @@ fn test_spawn_sched_childs_on_default_sched() {
             let ch = ch.take();
             let child_sched_id = unsafe { rt::rust_get_sched_id() };
             assert!(parent_sched_id != child_sched_id);
-            assert!(child_sched_id == default_id);
+            assert_eq!(child_sched_id, default_id);
             ch.send(());
         };
     };
@@ -985,7 +985,7 @@ fn avoid_copying_the_body(spawnfn: &fn(v: ~fn())) {
     }
 
     let x_in_child = p.recv();
-    assert!(x_in_parent == x_in_child);
+    assert_eq!(x_in_parent, x_in_child);
 }
 
 #[test]
@@ -1143,7 +1143,7 @@ fn test_sched_thread_per_core() {
         unsafe {
             let cores = rt::rust_num_threads();
             let reported_threads = rt::rust_sched_threads();
-            assert!((cores as uint == reported_threads as uint));
+            assert_eq!(cores as uint, reported_threads as uint);
             chan.send(());
         }
     }
@@ -1158,9 +1158,9 @@ fn test_spawn_thread_on_demand() {
     do spawn_sched(ManualThreads(2)) || {
         unsafe {
             let max_threads = rt::rust_sched_threads();
-            assert!((max_threads as int == 2));
+            assert_eq!(max_threads as int, 2);
             let running_threads = rt::rust_sched_current_nonlazy_threads();
-            assert!((running_threads as int == 1));
+            assert_eq!(running_threads as int, 1);
 
             let (port2, chan2) = comm::stream();
 
@@ -1169,7 +1169,7 @@ fn test_spawn_thread_on_demand() {
             }
 
             let running_threads2 = rt::rust_sched_current_nonlazy_threads();
-            assert!((running_threads2 as int == 2));
+            assert_eq!(running_threads2 as int, 2);
 
             port2.recv();
             chan.send(());

src/libcore/task/spawn.rs

@@ -774,7 +774,7 @@ fn test_spawn_raw_notify_success() {
     };
     do spawn_raw(opts) {
     }
-    assert!(notify_po.recv() == Success);
+    assert_eq!(notify_po.recv(), Success);
 }
 
 #[test]
@@ -791,5 +791,5 @@ fn test_spawn_raw_notify_failure() {
     do spawn_raw(opts) {
         fail!();
     }
-    assert!(notify_po.recv() == Failure);
+    assert_eq!(notify_po.recv(), Failure);
 }

src/libcore/to_str.rs

@@ -182,30 +182,30 @@ mod tests {
     use container::Set;
     #[test]
     fn test_simple_types() {
-        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");
+        assert_eq!(1i.to_str(), ~"1");
+        assert_eq!((-1i).to_str(), ~"-1");
+        assert_eq!(200u.to_str(), ~"200");
+        assert_eq!(2u8.to_str(), ~"2");
+        assert_eq!(true.to_str(), ~"true");
+        assert_eq!(false.to_str(), ~"false");
+        assert_eq!(().to_str(), ~"()");
+        assert_eq!((~"hi").to_str(), ~"hi");
+        assert_eq!((@"hi").to_str(), ~"hi");
     }
 
     #[test]
     fn test_tuple_types() {
-        assert!((1, 2).to_str() == ~"(1, 2)");
-        assert!((~"a", ~"b", false).to_str() == ~"(a, b, false)");
-        assert!(((), ((), 100)).to_str() == ~"((), ((), 100))");
+        assert_eq!((1, 2).to_str(), ~"(1, 2)");
+        assert_eq!((~"a", ~"b", false).to_str(), ~"(a, b, false)");
+        assert_eq!(((), ((), 100)).to_str(), ~"((), ((), 100))");
     }
 
     #[test]
     fn test_vectors() {
         let x: ~[int] = ~[];
-        assert!(x.to_str() == ~"[]");
-        assert!((~[1]).to_str() == ~"[1]");
-        assert!((~[1, 2, 3]).to_str() == ~"[1, 2, 3]");
+        assert_eq!(x.to_str(), ~"[]");
+        assert_eq!((~[1]).to_str(), ~"[1]");
+        assert_eq!((~[1, 2, 3]).to_str(), ~"[1, 2, 3]");
         assert!((~[~[], ~[1], ~[1, 1]]).to_str() ==
                ~"[[], [1], [1, 1]]");
     }
@@ -221,7 +221,7 @@ mod tests {
         let table_str = table.to_str();
 
         assert!(table_str == ~"{1: 2, 3: 4}" || table_str == ~"{3: 4, 1: 2}");
-        assert!(empty.to_str() == ~"{}");
+        assert_eq!(empty.to_str(), ~"{}");
     }
 
     #[test]
@@ -235,6 +235,6 @@ mod tests {
         let set_str = set.to_str();
 
         assert!(set_str == ~"{1, 2}" || set_str == ~"{2, 1}");
-        assert!(empty_set.to_str() == ~"{}");
+        assert_eq!(empty_set.to_str(), ~"{}");
     }
 }

src/libcore/trie.rs

@@ -451,7 +451,7 @@ pub fn check_integrity<T>(trie: &TrieNode<T>) {
         }
     }
 
-    assert!(sum == trie.count);
+    assert_eq!(sum, trie.count);
 }
 
 #[cfg(test)]
@@ -521,8 +521,8 @@ mod tests {
 
         let mut n = 0;
         for m.each |k, v| {
-            assert!(*k == n);
-            assert!(*v == n * 2);
+            assert_eq!(*k, n);
+            assert_eq!(*v, n * 2);
             n += 1;
         }
     }
@@ -540,8 +540,8 @@ mod tests {
             if n == uint::max_value - 5000 { break }
             assert!(n < uint::max_value - 5000);
 
-            assert!(*k == n);
-            assert!(*v == n / 2);
+            assert_eq!(*k, n);
+            assert_eq!(*v, n / 2);
             n += 1;
         }
     }
@@ -558,8 +558,8 @@ mod tests {
 
         let mut n = 4;
         for m.each_reverse |k, v| {
-            assert!(*k == n);
-            assert!(*v == n * 2);
+            assert_eq!(*k, n);
+            assert_eq!(*v, n * 2);
             n -= 1;
         }
     }
@@ -577,8 +577,8 @@ mod tests {
             if n == uint::max_value - 5000 { break }
             assert!(n > uint::max_value - 5000);
 
-            assert!(*k == n);
-            assert!(*v == n / 2);
+            assert_eq!(*k, n);
+            assert_eq!(*v, n / 2);
             n -= 1;
         }
     }
@@ -593,14 +593,14 @@ mod tests {
         assert!(trie.insert(x));
         assert!(trie.insert(y));
 
-        assert!(trie.len() == 2);
+        assert_eq!(trie.len(), 2);
 
         let expected = [x, y];
 
         let mut i = 0;
 
         for trie.each |x| {
-            assert!(expected[i] == *x);
+            assert_eq!(expected[i], *x);
             i += 1;
         }
     }
@@ -608,16 +608,16 @@ mod tests {
     #[test]
     fn test_swap() {
         let mut m = TrieMap::new();
-        assert!(m.swap(1, 2) == None);
-        assert!(m.swap(1, 3) == Some(2));
-        assert!(m.swap(1, 4) == Some(3));
+        assert_eq!(m.swap(1, 2), None);
+        assert_eq!(m.swap(1, 3), Some(2));
+        assert_eq!(m.swap(1, 4), Some(3));
     }
 
     #[test]
     fn test_pop() {
         let mut m = TrieMap::new();
         m.insert(1, 2);
-        assert!(m.pop(&1) == Some(2));
-        assert!(m.pop(&1) == None);
+        assert_eq!(m.pop(&1), Some(2));
+        assert_eq!(m.pop(&1), None);
     }
 }

src/libcore/unstable/at_exit.rs

@@ -83,7 +83,7 @@ fn test_at_exit() {
     let i = 10;
     do at_exit {
         debug!("at_exit1");
-        assert!(i == 10);
+        assert_eq!(i, 10);
     }
 }
 
@@ -93,7 +93,7 @@ fn test_at_exit_many() {
     for uint::range(20, 100) |j| {
         do at_exit {
             debug!("at_exit2");
-            assert!(i == 10);
+            assert_eq!(i, 10);
             assert!(j > i);
         }
     }

src/libcore/unstable/extfmt.rs

@@ -355,8 +355,8 @@ pub mod ct {
 
         fn test(s: &str, flags: &[Flag], next: uint) {
             let f = parse_flags(s, 0, s.len());
-            assert!(pack(f.val) == pack(flags));
-            assert!(f.next == next);
+            assert_eq!(pack(f.val), pack(flags));
+            assert_eq!(f.next, next);
         }
 
         test("", [], 0);
@@ -459,10 +459,10 @@ pub mod ct {
         assert!(peek_num(s2, 0, s2.len()).is_none());
 
         let s3 = "123";
-        assert!(peek_num(s3, 0, s3.len()) == Some(Parsed::new(123, 3)));
+        assert_eq!(peek_num(s3, 0, s3.len()), Some(Parsed::new(123, 3)));
 
         let s4 = "123foo";
-        assert!(peek_num(s4, 0, s4.len()) == Some(Parsed::new(123, 3)));
+        assert_eq!(peek_num(s4, 0, s4.len()), Some(Parsed::new(123, 3)));
     }
 }
 

src/libcore/unstable/finally.rs

@@ -79,10 +79,10 @@ fn test_success() {
         i = 10;
     }).finally {
         assert!(!failing());
-        assert!(i == 10);
+        assert_eq!(i, 10);
         i = 20;
     }
-    assert!(i == 20);
+    assert_eq!(i, 20);
 }
 
 #[test]
@@ -95,7 +95,7 @@ fn test_fail() {
         fail!();
     }).finally {
         assert!(failing());
-        assert!(i == 10);
+        assert_eq!(i, 10);
     }
 }
 
@@ -103,7 +103,7 @@ fn test_fail() {
 fn test_retval() {
     let closure: &fn() -> int = || 10;
     let i = do closure.finally { };
-    assert!(i == 10);
+    assert_eq!(i, 10);
 }
 
 #[test]
@@ -134,6 +134,6 @@ fn test_managed() {
         *i += 10;
         r
     };
-    assert!(do managed.finally {} == 10);
-    assert!(*i == 20);
+    assert_eq!(do managed.finally {}, 10);
+    assert_eq!(*i, 20);
 }

src/libcore/unstable/global.rs

@@ -200,7 +200,7 @@ fn get_global_state() -> Exclusive<GlobalState> {
                 let prev_i = unsafe {
                     atomic_cxchg(&mut *global_ptr, state_i, POISON)
                 };
-                assert!(prev_i == state_i);
+                assert_eq!(prev_i, state_i);
 
                 // Capture the global state object in the at_exit closure
                 // so that it is destroyed at the right time

src/libcore/unstable/mod.rs

@@ -55,7 +55,7 @@ pub fn run_in_bare_thread(f: ~fn()) {
 fn test_run_in_bare_thread() {
     let i = 100;
     do run_in_bare_thread {
-        assert!(i == 100);
+        assert_eq!(i, 100);
     }
 }
 

src/libcore/unstable/sync.rs

@@ -275,11 +275,11 @@ mod tests {
         let x2 = x.clone();
         do task::try || {
             do x2.with |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do x.with |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
 }

src/libcore/util.rs

@@ -193,8 +193,8 @@ mod tests {
         let mut x = 31337;
         let mut y = 42;
         swap(&mut x, &mut y);
-        assert!(x == 42);
-        assert!(y == 31337);
+        assert_eq!(x, 42);
+        assert_eq!(y, 31337);
     }
     #[test]
     pub fn test_replace() {

src/librustc/back/rpath.rs

@@ -209,7 +209,7 @@ mod test {
     fn test_rpaths_to_flags() {
         let flags = rpaths_to_flags(~[Path("path1"),
                                       Path("path2")]);
-        assert!(flags == ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]);
+        assert_eq!(flags, ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]);
     }
 
     #[test]
@@ -234,7 +234,7 @@ mod test {
         let res = minimize_rpaths([Path("rpath1"),
                                    Path("rpath2"),
                                    Path("rpath1")]);
-        assert!(res == ~[Path("rpath1"), Path("rpath2")]);
+        assert_eq!(res, ~[Path("rpath1"), Path("rpath2")]);
     }
 
     #[test]
@@ -243,7 +243,7 @@ mod test {
                                     Path("1a"), Path("4a"),Path("1a"),
                                     Path("2"), Path("3"), Path("4a"),
                                     Path("3")]);
-        assert!(res == ~[Path("1a"), Path("2"), Path("4a"), Path("3")]);
+        assert_eq!(res, ~[Path("1a"), Path("2"), Path("4a"), Path("3")]);
     }
 
     #[test]
@@ -251,7 +251,7 @@ mod test {
         let p1 = Path("/usr/bin/rustc");
         let p2 = Path("/usr/lib/mylib");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("../lib"));
+        assert_eq!(res, Path("../lib"));
     }
 
     #[test]
@@ -259,7 +259,7 @@ mod test {
         let p1 = Path("/usr/bin/rustc");
         let p2 = Path("/usr/bin/../lib/mylib");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("../lib"));
+        assert_eq!(res, Path("../lib"));
     }
 
     #[test]
@@ -267,7 +267,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/rustc");
         let p2 = Path("/usr/lib/whatever/mylib");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("../../lib/whatever"));
+        assert_eq!(res, Path("../../lib/whatever"));
     }
 
     #[test]
@@ -275,7 +275,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/../rustc");
         let p2 = Path("/usr/lib/whatever/mylib");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("../lib/whatever"));
+        assert_eq!(res, Path("../lib/whatever"));
     }
 
     #[test]
@@ -283,7 +283,7 @@ mod test {
         let p1 = Path("/usr/bin/whatever/../rustc");
         let p2 = Path("/usr/lib/whatever/../mylib");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("../lib"));
+        assert_eq!(res, Path("../lib"));
     }
 
     #[test]
@@ -291,7 +291,7 @@ mod test {
         let p1 = Path("/1");
         let p2 = Path("/2/3");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path("2"));
+        assert_eq!(res, Path("2"));
     }
 
     #[test]
@@ -299,7 +299,7 @@ mod test {
         let p1 = Path("/1/2");
         let p2 = Path("/3");
         let res = get_relative_to(&p1, &p2);
-        assert!(res == Path(".."));
+        assert_eq!(res, Path(".."));
     }
 
     #[test]
@@ -312,7 +312,7 @@ mod test {
         debug!("test_relative_tu8: %s vs. %s",
                res.to_str(),
                Path(".").to_str());
-        assert!(res == Path("."));
+        assert_eq!(res, Path("."));
     }
 
     #[test]
@@ -322,7 +322,7 @@ mod test {
       let o = session::os_linux;
       let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
-      assert!(res.to_str() == ~"$ORIGIN/../lib");
+      assert_eq!(res.to_str(), ~"$ORIGIN/../lib");
     }
 
     #[test]
@@ -331,7 +331,7 @@ mod test {
         let o = session::os_freebsd;
         let res = get_rpath_relative_to_output(o,
             &Path("bin/rustc"), &Path("lib/libstd.so"));
-        assert!(res.to_str() == ~"$ORIGIN/../lib");
+        assert_eq!(res.to_str(), ~"$ORIGIN/../lib");
     }
 
     #[test]
@@ -342,7 +342,7 @@ mod test {
         let res = get_rpath_relative_to_output(o,
                                                &Path("bin/rustc"),
                                                &Path("lib/libstd.so"));
-        assert!(res.to_str() == ~"@executable_path/../lib");
+        assert_eq!(res.to_str(), ~"@executable_path/../lib");
     }
 
     #[test]
@@ -352,6 +352,6 @@ mod test {
                res.to_str(),
                os::make_absolute(&Path("lib")).to_str());
 
-        assert!(res == os::make_absolute(&Path("lib")));
+        assert_eq!(res, os::make_absolute(&Path("lib")));
     }
 }

src/librustc/driver/driver.rs

@@ -938,6 +938,6 @@ 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");
-        assert!(test_items.len() == 1u);
+        assert_eq!(test_items.len(), 1u);
     }
 }

src/librustc/metadata/decoder.rs

@@ -1064,7 +1064,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
-            assert!(meta_items.len() == 1u);
+            assert_eq!(meta_items.len(), 1u);
             let meta_item = meta_items[0];
             attrs.push(
                 codemap::spanned {

src/librustc/metadata/encoder.rs

@@ -946,7 +946,7 @@ fn encode_info_for_item(ecx: @EncodeContext,
 
         // Now output the method info for each method.
         for ty::trait_method_def_ids(tcx, local_def(item.id)).eachi |i, &method_def_id| {
-            assert!(method_def_id.crate == ast::local_crate);
+            assert_eq!(method_def_id.crate, ast::local_crate);
 
             let method_ty = ty::method(tcx, method_def_id);
 
@@ -1278,7 +1278,7 @@ fn encode_crate_deps(ecx: @EncodeContext,
         // Sanity-check the crate numbers
         let mut expected_cnum = 1;
         for deps.each |n| {
-            assert!((n.cnum == expected_cnum));
+            assert_eq!(n.cnum, expected_cnum);
             expected_cnum += 1;
         }
 

src/librustc/metadata/tydecode.rs

@@ -156,12 +156,12 @@ fn parse_sigil(st: @mut PState) -> ast::Sigil {
 }
 
 fn parse_vstore(st: @mut PState) -> ty::vstore {
-    assert!(next(st) == '/');
+    assert_eq!(next(st), '/');
 
     let c = peek(st);
     if '0' <= c && c <= '9' {
         let n = parse_uint(st);
-        assert!(next(st) == '|');
+        assert_eq!(next(st), '|');
         return ty::vstore_fixed(n);
     }
 
@@ -187,7 +187,7 @@ fn parse_substs(st: @mut PState, conv: conv_did) -> ty::substs {
 
     let self_ty = parse_opt(st, || parse_ty(st, conv) );
 
-    assert!(next(st) == '[');
+    assert_eq!(next(st), '[');
     let mut params: ~[ty::t] = ~[];
     while peek(st) != ']' { params.push(parse_ty(st, conv)); }
     st.pos = st.pos + 1u;
@@ -204,13 +204,13 @@ fn parse_bound_region(st: @mut PState) -> ty::bound_region {
       's' => ty::br_self,
       'a' => {
         let id = parse_uint(st);
-        assert!(next(st) == '|');
+        assert_eq!(next(st), '|');
         ty::br_anon(id)
       }
       '[' => ty::br_named(st.tcx.sess.ident_of(parse_str(st, ']'))),
       'c' => {
         let id = parse_uint(st) as int;
-        assert!(next(st) == '|');
+        assert_eq!(next(st), '|');
         ty::br_cap_avoid(id, @parse_bound_region(st))
       },
       _ => fail!("parse_bound_region: bad input")
@@ -223,17 +223,17 @@ fn parse_region(st: @mut PState) -> ty::Region {
         ty::re_bound(parse_bound_region(st))
       }
       'f' => {
-        assert!(next(st) == '[');
+        assert_eq!(next(st), '[');
         let id = parse_uint(st) as int;
-        assert!(next(st) == '|');
+        assert_eq!(next(st), '|');
         let br = parse_bound_region(st);
-        assert!(next(st) == ']');
+        assert_eq!(next(st), ']');
         ty::re_free(ty::FreeRegion {scope_id: id,
                                     bound_region: br})
       }
       's' => {
         let id = parse_uint(st) as int;
-        assert!(next(st) == '|');
+        assert_eq!(next(st), '|');
         ty::re_scope(id)
       }
       't' => {
@@ -294,19 +294,19 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       'c' => return ty::mk_char(),
       't' => {
-        assert!((next(st) == '['));
+        assert_eq!(next(st), '[');
         let def = parse_def(st, NominalType, conv);
         let substs = parse_substs(st, conv);
-        assert!(next(st) == ']');
+        assert_eq!(next(st), ']');
         return ty::mk_enum(st.tcx, def, substs);
       }
       'x' => {
-        assert!(next(st) == '[');
+        assert_eq!(next(st), '[');
         let def = parse_def(st, NominalType, conv);
         let substs = parse_substs(st, conv);
         let store = parse_trait_store(st);
         let mt = parse_mutability(st);
-        assert!(next(st) == ']');
+        assert_eq!(next(st), ']');
         return ty::mk_trait(st.tcx, def, substs, store, mt);
       }
       'p' => {
@@ -337,7 +337,7 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
         return ty::mk_estr(st.tcx, v);
       }
       'T' => {
-        assert!((next(st) == '['));
+        assert_eq!(next(st), '[');
         let mut params = ~[];
         while peek(st) != ']' { params.push(parse_ty(st, conv)); }
         st.pos = st.pos + 1u;
@@ -356,9 +356,9 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       '#' => {
         let pos = parse_hex(st);
-        assert!((next(st) == ':'));
+        assert_eq!(next(st), ':');
         let len = parse_hex(st);
-        assert!((next(st) == '#'));
+        assert_eq!(next(st), '#');
         let key = ty::creader_cache_key {cnum: st.crate,
                                          pos: pos,
                                          len: len };
@@ -379,10 +379,10 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t {
       }
       'B' => ty::mk_opaque_box(st.tcx),
       'a' => {
-          assert!((next(st) == '['));
+          assert_eq!(next(st), '[');
           let did = parse_def(st, NominalType, conv);
           let substs = parse_substs(st, conv);
-          assert!((next(st) == ']'));
+          assert_eq!(next(st), ']');
           return ty::mk_struct(st.tcx, did, substs);
       }
       c => { error!("unexpected char in type string: %c", c); fail!();}
@@ -445,7 +445,7 @@ fn parse_purity(c: char) -> purity {
 }
 
 fn parse_abi_set(st: @mut PState) -> AbiSet {
-    assert!(next(st) == '[');
+    assert_eq!(next(st), '[');
     let mut abis = AbiSet::empty();
     while peek(st) != ']' {
         // FIXME(#5422) str API should not force this copy
@@ -453,7 +453,7 @@ fn parse_abi_set(st: @mut PState) -> AbiSet {
         let abi = abi::lookup(abi_str).expect(abi_str);
         abis.add(abi);
     }
-    assert!(next(st) == ']');
+    assert_eq!(next(st), ']');
     return abis;
 }
 
@@ -494,7 +494,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 {
-    assert!((next(st) == '['));
+    assert_eq!(next(st), '[');
     let mut inputs = ~[];
     while peek(st) != ']' {
         inputs.push(parse_ty(st, conv));

src/librustc/middle/astencode.rs

@@ -206,7 +206,7 @@ pub impl ExtendedDecodeContext {
          * refer to the current crate and to the new, inlined node-id.
          */
 
-        assert!(did.crate == ast::local_crate);
+        assert_eq!(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 {

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -218,7 +218,7 @@ pub impl GatherLoanCtxt {
 
     fn pop_repeating_id(&mut self, id: ast::node_id) {
         let popped = self.repeating_ids.pop();
-        assert!(id == popped);
+        assert_eq!(id, popped);
     }
 
     fn guarantee_adjustments(&mut self,

src/librustc/middle/entry.rs

@@ -144,7 +144,7 @@ fn configure_main(ctxt: @mut EntryContext) {
         } else {
             // If we *are* building a library, then we're on android where we still might
             // optionally want to translate main $4404
-            assert!(this.session.targ_cfg.os == session::os_android);
+            assert_eq!(this.session.targ_cfg.os, session::os_android);
         }
     }
 }

src/librustc/middle/region.rs

@@ -365,7 +365,7 @@ pub fn resolve_arm(arm: &ast::arm, cx: Context, visitor: visit::vt<Context>) {
 }
 
 pub fn resolve_pat(pat: @ast::pat, cx: Context, visitor: visit::vt<Context>) {
-    assert!(cx.var_parent == cx.parent);
+    assert_eq!(cx.var_parent, cx.parent);
     parent_to_expr(cx, pat.id);
     visit::visit_pat(pat, cx, visitor);
 }
@@ -427,7 +427,7 @@ pub fn resolve_expr(expr: @ast::expr, cx: Context, visitor: visit::vt<Context>)
 pub fn resolve_local(local: @ast::local,
                      cx: Context,
                      visitor: visit::vt<Context>) {
-    assert!(cx.var_parent == cx.parent);
+    assert_eq!(cx.var_parent, cx.parent);
     parent_to_expr(cx, local.node.id);
     visit::visit_local(local, cx, visitor);
 }

src/librustc/middle/resolve.rs

@@ -2321,7 +2321,7 @@ pub impl Resolver {
             return Indeterminate;
         }
 
-        assert!(containing_module.glob_count == 0);
+        assert_eq!(containing_module.glob_count, 0);
 
         // Add all resolved imports from the containing module.
         for containing_module.import_resolutions.each
@@ -2903,7 +2903,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 {
-            assert!(module_.glob_count == 0);
+            assert_eq!(module_.glob_count, 0);
         }
 
         // Check the list of resolved imports.

src/librustc/middle/resolve_stage0.rs

@@ -2368,7 +2368,7 @@ pub impl Resolver {
             return Indeterminate;
         }
 
-        assert!(containing_module.glob_count == 0);
+        assert_eq!(containing_module.glob_count, 0);
 
         // Add all resolved imports from the containing module.
         for containing_module.import_resolutions.each
@@ -2932,7 +2932,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 {
-            assert!(module_.glob_count == 0);
+            assert_eq!(module_.glob_count, 0);
         }
 
         // Check the list of resolved imports.

src/librustc/middle/trans/adt.rs

@@ -169,7 +169,7 @@ fn represent_type_uncached(cx: @CrateContext, t: ty::t) -> Repr {
 
             if cases.len() == 1 {
                 // Equivalent to a struct/tuple/newtype.
-                assert!(cases[0].discr == 0);
+                assert_eq!(cases[0].discr, 0);
                 return Univariant(mk_struct(cx, cases[0].tys, false), false)
             }
 
@@ -377,12 +377,12 @@ pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) {
             Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0]))
         }
         Univariant(ref st, true) => {
-            assert!(discr == 0);
+            assert_eq!(discr, 0);
             Store(bcx, C_bool(true),
                   GEPi(bcx, val, [0, st.fields.len() - 1]))
         }
         Univariant(*) => {
-            assert!(discr == 0);
+            assert_eq!(discr, 0);
         }
         General(*) => {
             Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0]))
@@ -405,7 +405,7 @@ pub fn num_args(r: &Repr, discr: int) -> uint {
     match *r {
         CEnum(*) => 0,
         Univariant(ref st, dtor) => {
-            assert!(discr == 0);
+            assert_eq!(discr, 0);
             st.fields.len() - (if dtor { 1 } else { 0 })
         }
         General(ref cases) => cases[discr as uint].fields.len() - 1,
@@ -426,7 +426,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) => {
-            assert!(discr == 0);
+            assert_eq!(discr, 0);
             struct_field_ptr(bcx, st, val, ix, false)
         }
         General(ref cases) => {
@@ -439,7 +439,7 @@ pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int,
                 // The unit-like case might have a nonzero number of unit-like fields.
                 // (e.g., Result or Either with () as one side.)
                 let llty = type_of::type_of(bcx.ccx(), nullfields[ix]);
-                assert!(machine::llsize_of_alloc(bcx.ccx(), llty) == 0);
+                assert_eq!(machine::llsize_of_alloc(bcx.ccx(), llty), 0);
                 // The contents of memory at this pointer can't matter, but use
                 // the value that's "reasonable" in case of pointer comparison.
                 PointerCast(bcx, val, T_ptr(llty))
@@ -498,12 +498,12 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
                    vals: &[ValueRef]) -> ValueRef {
     match *r {
         CEnum(min, max) => {
-            assert!(vals.len() == 0);
+            assert_eq!(vals.len(), 0);
             assert!(min <= discr && discr <= max);
             C_int(ccx, discr)
         }
         Univariant(ref st, _dro) => {
-            assert!(discr == 0);
+            assert_eq!(discr, 0);
             C_struct(build_const_struct(ccx, st, vals))
         }
         General(ref cases) => {
@@ -517,7 +517,7 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
             if discr == nndiscr {
                 C_struct(build_const_struct(ccx, nonnull, vals))
             } else {
-                assert!(vals.len() == 0);
+                assert_eq!(vals.len(), 0);
                 let vals = do nonnull.fields.mapi |i, &ty| {
                     let llty = type_of::sizing_type_of(ccx, ty);
                     if i == ptrfield { C_null(llty) } else { C_undef(llty) }
@@ -540,7 +540,7 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
  */
 fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef])
     -> ~[ValueRef] {
-    assert!(vals.len() == st.fields.len());
+    assert_eq!(vals.len(), st.fields.len());
 
     let mut offset = 0;
     let mut cfields = ~[];

src/librustc/middle/trans/base.rs

@@ -496,7 +496,7 @@ pub fn get_res_dtor(ccx: @CrateContext,
         } else {
             did
         };
-        assert!(did.crate == ast::local_crate);
+        assert_eq!(did.crate, ast::local_crate);
         let (val, _) = monomorphize::monomorphic_fn(ccx,
                                                     did,
                                                     substs,

src/librustc/middle/trans/build.rs

@@ -837,7 +837,7 @@ pub fn Phi(cx: block, Ty: TypeRef, vals: &[ValueRef], bbs: &[BasicBlockRef])
     -> ValueRef {
     unsafe {
         if cx.unreachable { return llvm::LLVMGetUndef(Ty); }
-        assert!(vals.len() == bbs.len());
+        assert_eq!(vals.len(), bbs.len());
         let phi = EmptyPhi(cx, Ty);
         count_insn(cx, "addincoming");
         llvm::LLVMAddIncoming(phi, vec::raw::to_ptr(vals),

src/librustc/middle/trans/callee.rs

@@ -272,7 +272,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.
-        assert!(def_id.crate == ast::local_crate);
+        assert_eq!(def_id.crate, ast::local_crate);
 
         let mut (val, must_cast) =
             monomorphize::monomorphic_fn(ccx, def_id, type_params,

src/librustc/middle/trans/closure.rs

@@ -263,7 +263,7 @@ pub fn build_closure(bcx0: block,
         let datum = expr::trans_local_var(bcx, cap_var.def);
         match cap_var.mode {
             moves::CapRef => {
-                assert!(sigil == ast::BorrowedSigil);
+                assert_eq!(sigil, ast::BorrowedSigil);
                 env_vals.push(EnvValue {action: EnvRef,
                                         datum: datum});
             }

src/librustc/middle/trans/consts.rs

@@ -113,7 +113,7 @@ fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef {
         None => v
     };
     unsafe {
-        assert!(llvm::LLVMIsGlobalConstant(v) == True);
+        assert_eq!(llvm::LLVMIsGlobalConstant(v), True);
         llvm::LLVMGetInitializer(v)
     }
 }
@@ -209,8 +209,8 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef {
                             assert!(m != ast::m_mutbl);
                             let size = machine::llsize_of(cx,
                                                           val_ty(llconst));
-                            assert!(abi::slice_elt_base == 0);
-                            assert!(abi::slice_elt_len == 1);
+                            assert_eq!(abi::slice_elt_base, 0);
+                            assert_eq!(abi::slice_elt_len, 1);
                             llconst = C_struct(~[llptr, size]);
                         }
                         _ => {
@@ -486,7 +486,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef {
             }
           }
           ast::expr_path(pth) => {
-            assert!(pth.types.len() == 0);
+            assert_eq!(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) {

src/librustc/middle/trans/datum.rs

@@ -375,7 +375,7 @@ pub impl Datum {
          * Schedules this datum for cleanup in `bcx`.  The datum
          * must be an rvalue. */
 
-        assert!(self.source == RevokeClean);
+        assert_eq!(self.source, RevokeClean);
         match self.mode {
             ByValue => {
                 add_clean_temp_immediate(bcx, self.val, self.ty);

src/librustc/middle/trans/expr.rs

@@ -287,7 +287,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
         debug!("add_env(closure_ty=%s)", closure_ty.repr(tcx));
         let scratch = scratch_datum(bcx, closure_ty, false);
         let llfn = GEPi(bcx, scratch.val, [0u, abi::fn_field_code]);
-        assert!(datum.appropriate_mode() == ByValue);
+        assert_eq!(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);

src/librustc/middle/trans/glue.rs

@@ -483,7 +483,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)
-        assert!((params.len() == 2));
+        assert_eq!(params.len(), 2);
 
         // Take a reference to the class (because it's using the Drop trait),
         // do so now.

src/librustc/middle/ty.rs

@@ -2194,7 +2194,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.
-                assert!(p.def_id.crate == ast::local_crate);
+                assert_eq!(p.def_id.crate, ast::local_crate);
 
                 type_param_def_to_contents(
                     cx, cx.ty_param_defs.get(&p.def_id.node))

src/librustc/middle/typeck/coherence.rs

@@ -863,7 +863,7 @@ pub impl CoherenceChecker {
     }
 
     fn span_of_impl(&self, implementation: @Impl) -> span {
-        assert!(implementation.did.crate == local_crate);
+        assert_eq!(implementation.did.crate, local_crate);
         match self.crate_context.tcx.items.find(&implementation.did.node) {
             Some(&node_item(item, _)) => {
                 return item.span;

src/librustc/middle/typeck/infer/region_inference.rs

@@ -680,7 +680,7 @@ pub impl RegionVarBindings {
             match undo_item {
               Snapshot => {}
               AddVar(vid) => {
-                assert!(self.var_spans.len() == vid.to_uint() + 1);
+                assert_eq!(self.var_spans.len(), vid.to_uint() + 1);
                 self.var_spans.pop();
               }
               AddConstraint(ref constraint) => {
@@ -1440,7 +1440,7 @@ pub impl RegionVarBindings {
 
         return match a_node.value {
             NoValue => {
-                assert!(a_node.classification == Contracting);
+                assert_eq!(a_node.classification, Contracting);
                 a_node.value = Value(b_region);
                 true // changed
             }

src/librustc/middle/typeck/infer/unify.rs

@@ -129,7 +129,7 @@ pub impl InferCtxt {
         } else {
             // If equal, redirect one to the other and increment the
             // other's rank.
-            assert!(node_a.rank == node_b.rank);
+            assert_eq!(node_a.rank, node_b.rank);
             self.set(node_b.root, Redirect(node_a.root));
             (node_a.root, node_a.rank + 1)
         }

src/librustdoc/astsrv.rs

@@ -162,6 +162,6 @@ fn srv_should_return_request_result() {
     let source = ~"fn a() { }";
     do from_str(source) |srv| {
         let result = exec(srv, |_ctxt| 1000 );
-        assert!(result == 1000);
+        assert_eq!(result, 1000);
     }
 }

src/librustdoc/desc_to_brief_pass.rs

@@ -197,7 +197,7 @@ mod test {
     #[test]
     fn should_promote_desc() {
         let doc = mk_doc(~"#[doc = \"desc\"] mod m { }");
-        assert!(doc.cratemod().mods()[0].brief() == Some(~"desc"));
+        assert_eq!(doc.cratemod().mods()[0].brief(), Some(~"desc"));
     }
 
     #[test]
@@ -217,20 +217,20 @@ mod test {
     #[test]
     fn test_paragraphs_1() {
         let paras = paragraphs(~"1\n\n2");
-        assert!(paras == ~[~"1", ~"2"]);
+        assert_eq!(paras, ~[~"1", ~"2"]);
     }
 
     #[test]
     fn test_paragraphs_2() {
         let paras = paragraphs(~"\n\n1\n1\n\n2\n\n");
-        assert!(paras == ~[~"1\n1", ~"2"]);
+        assert_eq!(paras, ~[~"1\n1", ~"2"]);
     }
 
     #[test]
     fn should_promote_short_descs() {
         let desc = Some(~"desc");
         let brief = extract(copy desc);
-        assert!(brief == desc);
+        assert_eq!(brief, desc);
     }
 
     #[test]
@@ -244,7 +244,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);
-        assert!(brief == None);
+        assert_eq!(brief, None);
     }
 
     #[test]

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);
-    assert!(r == ~"\\\\n");
+    assert_eq!(r, ~"\\\\n");
 }

src/librustdoc/fold.rs

@@ -369,7 +369,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);
-    assert!(doc == folded);
+    assert_eq!(doc, folded);
 }
 
 #[test]
@@ -379,7 +379,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);
-    assert!(doc == folded);
+    assert_eq!(doc, folded);
 }
 
 #[test]
@@ -389,7 +389,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);
-    assert!(doc == folded);
+    assert_eq!(doc, folded);
 }
 
 #[test]
@@ -399,5 +399,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);
-    assert!(doc == folded);
+    assert_eq!(doc, folded);
 }

src/librustdoc/markdown_index_pass.rs

@@ -209,7 +209,7 @@ mod test {
 
     #[test]
     fn should_trim_whitespace_after_removing_punctuation() {
-        assert!(pandoc_header_id("impl foo for ()") == ~"impl-foo-for");
+        assert_eq!(pandoc_header_id("impl foo for ()"), ~"impl-foo-for");
     }
 
     #[test]

src/librustdoc/markdown_writer.rs

@@ -285,7 +285,7 @@ mod test {
         let doc = mk_doc(~"test", ~"");
         let page = doc::CratePage(doc.CrateDoc());
         let filename = make_local_filename(config, page);
-        assert!(filename.to_str() == ~"output/dir/test.md");
+        assert_eq!(filename.to_str(), ~"output/dir/test.md");
     }
 
     #[test]
@@ -299,7 +299,7 @@ mod test {
         let doc = mk_doc(~"", ~"");
         let page = doc::CratePage(doc.CrateDoc());
         let filename = make_local_filename(config, page);
-        assert!(filename.to_str() == ~"output/dir/index.html");
+        assert_eq!(filename.to_str(), ~"output/dir/index.html");
     }
 
     #[test]
@@ -314,6 +314,6 @@ mod test {
         let modb = copy doc.cratemod().mods()[0].mods()[0];
         let page = doc::ItemPage(doc::ModTag(modb));
         let filename = make_local_filename(config, page);
-        assert!(filename == Path("output/dir/a_b.html"));
+        assert_eq!(filename, Path("output/dir/a_b.html"));
     }
 }

src/librustdoc/page_pass.rs

@@ -176,13 +176,13 @@ mod test {
             config::DocPerCrate,
             ~"mod a { } mod b { mod c { } }"
         );
-        assert!(doc.pages.len() == 1u);
+        assert_eq!(doc.pages.len(), 1u);
     }
 
     #[test]
     fn should_make_a_page_for_every_mod() {
         let doc = mk_doc(~"mod a { }");
-        assert!(doc.pages.mods()[0].name() == ~"a");
+        assert_eq!(doc.pages.mods()[0].name(), ~"a");
     }
 
     #[test]

src/librustdoc/pass.rs

@@ -89,6 +89,6 @@ fn test_run_passes() {
         ];
         let doc = extract::from_srv(srv.clone(), ~"one");
         let doc = run_passes(srv, doc, passes);
-        assert!(doc.cratemod().name() == ~"onetwothree");
+        assert_eq!(doc.cratemod().name(), ~"onetwothree");
     }
 }

src/librustdoc/path_pass.rs

@@ -109,6 +109,6 @@ fn should_record_fn_paths() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = run(srv.clone(), doc);
-        assert!(doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]);
+        assert_eq!(doc.cratemod().mods()[0].fns()[0].path(), ~[~"a"]);
     }
 }

src/librustdoc/prune_private_pass.rs

@@ -194,7 +194,7 @@ mod test {
               pub fn bar() { }\
               fn baz() { }\
               }");
-        assert!(doc.cratemod().impls()[0].methods.len() == 1);
+        assert_eq!(doc.cratemod().impls()[0].methods.len(), 1);
     }
 
     #[test]
@@ -204,7 +204,7 @@ mod test {
               pub fn bar() { }\
               priv fn baz() { }\
               }");
-        assert!(doc.cratemod().impls()[0].methods.len() == 1);
+        assert_eq!(doc.cratemod().impls()[0].methods.len(), 1);
     }
 
     #[test]
@@ -214,7 +214,7 @@ mod test {
               fn bar() { }\
               priv fn baz() { }\
               }");
-        assert!(doc.cratemod().impls()[0].methods.len() == 1);
+        assert_eq!(doc.cratemod().impls()[0].methods.len(), 1);
     }
 
     #[test]
@@ -224,7 +224,7 @@ mod test {
               pub fn bar() { }\
               fn baz() { }\
               }");
-        assert!(doc.cratemod().impls()[0].methods.len() == 1);
+        assert_eq!(doc.cratemod().impls()[0].methods.len(), 1);
     }
 
     #[test]
@@ -234,7 +234,7 @@ mod test {
               pub fn bar() { }\
               priv fn baz() { }\
               }");
-        assert!(doc.cratemod().impls()[0].methods.len() == 1);
+        assert_eq!(doc.cratemod().impls()[0].methods.len(), 1);
     }
 
     #[test]

src/librustdoc/sectionalize_pass.rs

@@ -236,7 +236,7 @@ mod test {
               Body\"]\
               mod a {
 }");
-        assert!(doc.cratemod().mods()[0].desc() == None);
+        assert_eq!(doc.cratemod().mods()[0].desc(), None);
     }
 
     #[test]
@@ -247,7 +247,7 @@ mod test {
               # Header\n\
               Body\"]\
               fn a(); }");
-        assert!(doc.cratemod().traits()[0].methods[0].sections.len() == 1u);
+        assert_eq!(doc.cratemod().traits()[0].methods[0].sections.len(), 1u);
     }
 
     #[test]
@@ -258,6 +258,6 @@ mod test {
               # Header\n\
               Body\"]\
               fn a() { } }");
-        assert!(doc.cratemod().impls()[0].methods[0].sections.len() == 1u);
+        assert_eq!(doc.cratemod().impls()[0].methods[0].sections.len(), 1u);
     }
 }

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);
-        assert!(doc.cratemod().items[0].name() == ~"y");
-        assert!(doc.cratemod().items[1].name() == ~"z");
+        assert_eq!(doc.cratemod().items[0].name(), ~"y");
+        assert_eq!(doc.cratemod().items[1].name(), ~"z");
     }
 }

src/librustdoc/sort_item_type_pass.rs

@@ -53,13 +53,13 @@ fn test() {
     do astsrv::from_str(source) |srv| {
         let doc = extract::from_srv(srv.clone(), ~"");
         let doc = (mk_pass().f)(srv.clone(), doc);
-        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_eq!(doc.cratemod().items[0].name(), ~"iconst");
+        assert_eq!(doc.cratemod().items[1].name(), ~"itype");
+        assert_eq!(doc.cratemod().items[2].name(), ~"ienum");
+        assert_eq!(doc.cratemod().items[3].name(), ~"istruct");
+        assert_eq!(doc.cratemod().items[4].name(), ~"itrait");
+        assert_eq!(doc.cratemod().items[5].name(), ~"__extensions__");
+        assert_eq!(doc.cratemod().items[6].name(), ~"ifn");
+        assert_eq!(doc.cratemod().items[7].name(), ~"imod");
     }
 }

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);
-        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");
+        assert_eq!(doc.cratemod().mods()[0].name(), ~"w");
+        assert_eq!(doc.cratemod().mods()[1].items[0].name(), ~"x");
+        assert_eq!(doc.cratemod().mods()[1].items[1].name(), ~"y");
+        assert_eq!(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);
-        assert!(doc.cratemod().mods()[0].items[0].name() == ~"b");
-        assert!(doc.cratemod().mods()[1].items[0].name() == ~"d");
+        assert_eq!(doc.cratemod().mods()[0].items[0].name(), ~"b");
+        assert_eq!(doc.cratemod().mods()[1].items[0].name(), ~"d");
         let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc);
-        assert!(doc.cratemod().mods()[0].items[0].name() == ~"b");
-        assert!(doc.cratemod().mods()[1].items[0].name() == ~"d");
+        assert_eq!(doc.cratemod().mods()[0].items[0].name(), ~"b");
+        assert_eq!(doc.cratemod().mods()[1].items[0].name(), ~"d");
     }
 }

src/librustdoc/text_pass.rs

@@ -158,13 +158,13 @@ mod test {
     #[test]
     fn should_execute_op_on_enum_brief() {
         let doc = mk_doc(~"#[doc = \" a \"] enum a { b }");
-        assert!(doc.cratemod().enums()[0].brief() == Some(~"a"));
+        assert_eq!(doc.cratemod().enums()[0].brief(), Some(~"a"));
     }
 
     #[test]
     fn should_execute_op_on_enum_desc() {
         let doc = mk_doc(~"#[doc = \" a \"] enum a { b }");
-        assert!(doc.cratemod().enums()[0].desc() == Some(~"a"));
+        assert_eq!(doc.cratemod().enums()[0].desc(), Some(~"a"));
     }
 
     #[test]
@@ -177,14 +177,14 @@ mod test {
     fn should_execute_op_on_trait_brief() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] trait i { fn a(); }");
-        assert!(doc.cratemod().traits()[0].brief() == Some(~"a"));
+        assert_eq!(doc.cratemod().traits()[0].brief(), Some(~"a"));
     }
 
     #[test]
     fn should_execute_op_on_trait_desc() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] trait i { fn a(); }");
-        assert!(doc.cratemod().traits()[0].desc() == Some(~"a"));
+        assert_eq!(doc.cratemod().traits()[0].desc(), Some(~"a"));
     }
 
     #[test]
@@ -205,14 +205,14 @@ mod test {
     fn should_execute_op_on_impl_brief() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] impl int { fn a() { } }");
-        assert!(doc.cratemod().impls()[0].brief() == Some(~"a"));
+        assert_eq!(doc.cratemod().impls()[0].brief(), Some(~"a"));
     }
 
     #[test]
     fn should_execute_op_on_impl_desc() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] impl int { fn a() { } }");
-        assert!(doc.cratemod().impls()[0].desc() == Some(~"a"));
+        assert_eq!(doc.cratemod().impls()[0].desc(), Some(~"a"));
     }
 
     #[test]
@@ -233,14 +233,14 @@ mod test {
     fn should_execute_op_on_type_brief() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] type t = int;");
-        assert!(doc.cratemod().types()[0].brief() == Some(~"a"));
+        assert_eq!(doc.cratemod().types()[0].brief(), Some(~"a"));
     }
 
     #[test]
     fn should_execute_op_on_type_desc() {
         let doc = mk_doc(
             ~"#[doc = \" a \"] type t = int;");
-        assert!(doc.cratemod().types()[0].desc() == Some(~"a"));
+        assert_eq!(doc.cratemod().types()[0].desc(), Some(~"a"));
     }
 
     #[test]

src/librustdoc/trim_pass.rs

@@ -45,6 +45,6 @@ mod test {
         let doc = mk_doc(~"#[doc = \" desc \"] \
                                  mod m {
 }");
-        assert!(doc.cratemod().mods()[0].desc() == Some(~"desc"));
+        assert_eq!(doc.cratemod().mods()[0].desc(), Some(~"desc"));
     }
 }

src/librustdoc/unindent_pass.rs

@@ -92,14 +92,14 @@ fn unindent(s: &str) -> ~str {
 fn should_unindent() {
     let s = ~"    line1\n    line2";
     let r = unindent(s);
-    assert!(r == ~"line1\nline2");
+    assert_eq!(r, ~"line1\nline2");
 }
 
 #[test]
 fn should_unindent_multiple_paragraphs() {
     let s = ~"    line1\n\n    line2";
     let r = unindent(s);
-    assert!(r == ~"line1\n\nline2");
+    assert_eq!(r, ~"line1\n\nline2");
 }
 
 #[test]
@@ -108,7 +108,7 @@ fn should_leave_multiple_indent_levels() {
     // base indentation and should be preserved
     let s = ~"    line1\n\n        line2";
     let r = unindent(s);
-    assert!(r == ~"line1\n\n    line2");
+    assert_eq!(r, ~"line1\n\n    line2");
 }
 
 #[test]
@@ -120,12 +120,12 @@ fn should_ignore_first_line_indent() {
     //          and continue here"]
     let s = ~"line1\n    line2";
     let r = unindent(s);
-    assert!(r == ~"line1\nline2");
+    assert_eq!(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);
-    assert!(r == ~"line1\n\n    line2");
+    assert_eq!(r, ~"line1\n\n    line2");
 }

src/librustpkg/tests.rs

@@ -212,7 +212,7 @@ fn test_package_ids_must_be_relative_path_like() {
 
     let whatever = PkgId::new("foo");
 
-    assert!(addversion("foo") == whatever.to_str());
+    assert_eq!(addversion("foo"), whatever.to_str());
     assert!(addversion("github.com/mozilla/rust") ==
             PkgId::new("github.com/mozilla/rust").to_str());
 
@@ -222,16 +222,16 @@ fn test_package_ids_must_be_relative_path_like() {
         copy whatever
     }).in {
         let x = PkgId::new("");
-        assert!(addversion("foo") == x.to_str());
+        assert_eq!(addversion("foo"), x.to_str());
     }
 
     do cond.trap(|(p, e)| {
-        assert!(p.to_str() == os::make_absolute(&Path("foo/bar/quux")).to_str());
+        assert_eq!(p.to_str(), os::make_absolute(&Path("foo/bar/quux")).to_str());
         assert!("absolute pkgid" == e);
         copy whatever
     }).in {
         let z = PkgId::new(os::make_absolute(&Path("foo/bar/quux")).to_str());
-        assert!(addversion("foo") == z.to_str());
+        assert_eq!(addversion("foo"), z.to_str());
     }
 
 }

src/librustpkg/testsuite/pass/src/install-paths/test.rs

@@ -10,5 +10,5 @@
 
 #[test]
 fn test_two_plus_two() {
-    assert!(2 + 2 == 4);
+    assert_eq!(2 + 2, 4);
 }

src/librustpkg/util.rs

@@ -417,7 +417,7 @@ pub fn compile_crate_from_input(input: &driver::input,
     match crate_opt {
         Some(c) => {
             debug!("Calling compile_rest, outputs = %?", outputs);
-            assert!(what == driver::cu_everything);
+            assert_eq!(what, driver::cu_everything);
             driver::compile_rest(sess, cfg, driver::cu_everything, Some(outputs), Some(c));
             c
         }

src/libstd/arc.rs

@@ -501,13 +501,13 @@ mod tests {
             let arc_v = p.recv();
 
             let v = copy *arc::get::<~[int]>(&arc_v);
-            assert!(v[3] == 4);
+            assert_eq!(v[3], 4);
         };
 
         let c = p.recv();
         c.send(arc::clone(&arc_v));
 
-        assert!((*arc::get(&arc_v))[2] == 3);
+        assert_eq!((*arc::get(&arc_v))[2], 3);
 
         info!(arc_v);
     }
@@ -545,7 +545,7 @@ mod tests {
             do arc2.access_cond |one, cond| {
                 cond.signal();
                 // Parent should fail when it wakes up.
-                assert!(*one == 0);
+                assert_eq!(*one, 0);
             }
         }
 
@@ -562,11 +562,11 @@ mod tests {
         let arc2 = ~arc.clone();
         do task::try || {
             do arc2.access |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do arc.access |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -575,11 +575,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.write |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do arc.read |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -588,11 +588,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.write |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do arc.write |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[should_fail] #[ignore(cfg(windows))]
@@ -602,12 +602,12 @@ mod tests {
         do task::try || {
             do arc2.write_downgrade |mut write_mode| {
                 do write_mode.write |one| {
-                    assert!(*one == 2);
+                    assert_eq!(*one, 2);
                 }
             }
         };
         do arc.write |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -616,11 +616,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.read |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do arc.read |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -629,11 +629,11 @@ mod tests {
         let arc2 = (*arc).clone();
         do task::try || {
             do arc2.read |one| {
-                assert!(*one == 2);
+                assert_eq!(*one, 2);
             }
         };
         do arc.write |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test] #[ignore(cfg(windows))]
@@ -644,12 +644,12 @@ mod tests {
             do arc2.write_downgrade |write_mode| {
                 let read_mode = arc2.downgrade(write_mode);
                 do (&read_mode).read |one| {
-                    assert!(*one == 2);
+                    assert_eq!(*one, 2);
                 }
             }
         };
         do arc.write |one| {
-            assert!(*one == 1);
+            assert_eq!(*one, 1);
         }
     }
     #[test]
@@ -691,7 +691,7 @@ mod tests {
         // Wait for writer to finish
         p.recv();
         do arc.read |num| {
-            assert!(*num == 10);
+            assert_eq!(*num, 10);
         }
     }
     #[test]
@@ -713,7 +713,7 @@ mod tests {
             do task::spawn || {
                 rp1.recv(); // wait for downgrader to give go-ahead
                 do arcn.read |state| {
-                    assert!(*state == 31337);
+                    assert_eq!(*state, 31337);
                     rc2.send(());
                 }
             }
@@ -725,7 +725,7 @@ mod tests {
         do task::spawn || {
             wp1.recv();
             do arc2.write_cond |state, cond| {
-                assert!(*state == 0);
+                assert_eq!(*state, 0);
                 *state = 42;
                 cond.signal();
             }
@@ -733,7 +733,7 @@ mod tests {
             do arc2.write |state| {
                 // This shouldn't happen until after the downgrade read
                 // section, and all other readers, finish.
-                assert!(*state == 31337);
+                assert_eq!(*state, 31337);
                 *state = 42;
             }
             wc2.send(());
@@ -746,7 +746,7 @@ mod tests {
                 while *state == 0 {
                     cond.wait();
                 }
-                assert!(*state == 42);
+                assert_eq!(*state, 42);
                 *state = 31337;
                 // send to other readers
                 for reader_convos.each |x| {
@@ -764,7 +764,7 @@ mod tests {
                     }
                 }
                 wc1.send(()); // tell writer to try again
-                assert!(*state == 31337);
+                assert_eq!(*state, 31337);
             }
         }
 

src/libstd/base64.rs

@@ -229,23 +229,23 @@ mod tests {
 
     #[test]
     fn test_to_base64() {
-        assert!((~"").to_base64()       == ~"");
+        assert_eq!((~"").to_base64(), ~"");
         assert!((~"f").to_base64()      == ~"Zg==");
-        assert!((~"fo").to_base64()     == ~"Zm8=");
-        assert!((~"foo").to_base64()    == ~"Zm9v");
+        assert_eq!((~"fo").to_base64(), ~"Zm8=");
+        assert_eq!((~"foo").to_base64(), ~"Zm9v");
         assert!((~"foob").to_base64()   == ~"Zm9vYg==");
-        assert!((~"fooba").to_base64()  == ~"Zm9vYmE=");
-        assert!((~"foobar").to_base64() == ~"Zm9vYmFy");
+        assert_eq!((~"fooba").to_base64(), ~"Zm9vYmE=");
+        assert_eq!((~"foobar").to_base64(), ~"Zm9vYmFy");
     }
 
     #[test]
     fn test_from_base64() {
-        assert!((~"").from_base64() == str::to_bytes(~""));
+        assert_eq!((~"").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_eq!((~"Zm8=").from_base64(), str::to_bytes(~"fo"));
+        assert_eq!((~"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"));
+        assert_eq!((~"Zm9vYmE=").from_base64(), str::to_bytes(~"fooba"))
+        assert_eq!((~"Zm9vYmFy").from_base64(), str::to_bytes(~"foobar"));
     }
 }

src/libstd/bitv.rs

@@ -127,7 +127,7 @@ pub impl BigBitv {
     fn process(&mut self, b: &BigBitv, nbits: uint,
                op: &fn(uint, uint) -> uint) -> bool {
         let len = b.storage.len();
-        assert!((self.storage.len() == len));
+        assert_eq!(self.storage.len(), len);
         let mut changed = false;
         for uint::range(0, len) |i| {
             let mask = big_mask(nbits, i);
@@ -508,7 +508,7 @@ pub impl Bitv {
      * the bitvector and vector must have the same length
      */
     fn eq_vec(&self, v: ~[uint]) -> bool {
-        assert!(self.nbits == v.len());
+        assert_eq!(self.nbits, v.len());
         let mut i = 0;
         while i < self.nbits {
             let w0 = self.get(i);
@@ -909,10 +909,10 @@ mod tests {
     #[test]
     fn test_to_str() {
         let zerolen = Bitv::new(0u, false);
-        assert!(zerolen.to_str() == ~"");
+        assert_eq!(zerolen.to_str(), ~"");
 
         let eightbits = Bitv::new(8u, false);
-        assert!(eightbits.to_str() == ~"00000000");
+        assert_eq!(eightbits.to_str(), ~"00000000");
     }
 
     #[test]
@@ -938,7 +938,7 @@ mod tests {
         let mut b = bitv::Bitv::new(2, false);
         b.set(0, true);
         b.set(1, false);
-        assert!(b.to_str() == ~"10");
+        assert_eq!(b.to_str(), ~"10");
     }
 
     #[test]
@@ -1248,19 +1248,19 @@ mod tests {
     fn test_from_bytes() {
         let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + ~"00000000" + ~"11111111";
-        assert!(bitv.to_str() == str);
+        assert_eq!(bitv.to_str(), str);
     }
 
     #[test]
     fn test_to_bytes() {
         let mut bv = Bitv::new(3, true);
         bv.set(1, false);
-        assert!(bv.to_bytes() == ~[0b10100000]);
+        assert_eq!(bv.to_bytes(), ~[0b10100000]);
 
         let mut bv = Bitv::new(9, false);
         bv.set(2, true);
         bv.set(8, true);
-        assert!(bv.to_bytes() == ~[0b00100000, 0b10000000]);
+        assert_eq!(bv.to_bytes(), ~[0b00100000, 0b10000000]);
     }
 
     #[test]
@@ -1272,7 +1272,7 @@ mod tests {
     #[test]
     fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        assert!(from_bytes([0b00100110]).to_bools() == bools);
+        assert_eq!(from_bytes([0b00100110]).to_bools(), bools);
     }
 
     #[test]
@@ -1330,7 +1330,7 @@ mod tests {
         assert!(b.insert(400));
         assert!(!b.insert(400));
         assert!(b.contains(&400));
-        assert!(b.len() == 2);
+        assert_eq!(b.len(), 2);
     }
 
     #[test]
@@ -1354,10 +1354,10 @@ mod tests {
         let mut i = 0;
         let expected = [3, 5, 11, 77];
         for a.intersection(&b) |x| {
-            assert!(*x == expected[i]);
+            assert_eq!(*x, expected[i]);
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1377,10 +1377,10 @@ mod tests {
         let mut i = 0;
         let expected = [1, 5, 500];
         for a.difference(&b) |x| {
-            assert!(*x == expected[i]);
+            assert_eq!(*x, expected[i]);
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1402,10 +1402,10 @@ mod tests {
         let mut i = 0;
         let expected = [1, 5, 11, 14, 220];
         for a.symmetric_difference(&b) |x| {
-            assert!(*x == expected[i]);
+            assert_eq!(*x, expected[i]);
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1430,10 +1430,10 @@ mod tests {
         let mut i = 0;
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160];
         for a.union(&b) |x| {
-            assert!(*x == expected[i]);
+            assert_eq!(*x, expected[i]);
             i += 1
         }
-        assert!(i == expected.len());
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1448,7 +1448,7 @@ mod tests {
 
         assert!(a.insert(1000));
         assert!(a.remove(&1000));
-        assert!(a.capacity() == uint::bits);
+        assert_eq!(a.capacity(), uint::bits);
     }
 
     fn rng() -> rand::IsaacRng {

src/libstd/c_vec.rs

@@ -165,9 +165,9 @@ mod tests {
 
         set(cv, 3u, 8u8);
         set(cv, 4u, 9u8);
-        assert!(get(cv, 3u) == 8u8);
-        assert!(get(cv, 4u) == 9u8);
-        assert!(len(cv) == 16u);
+        assert_eq!(get(cv, 3u), 8u8);
+        assert_eq!(get(cv, 4u), 9u8);
+        assert_eq!(len(cv), 16u);
     }
 
     #[test]
@@ -195,7 +195,7 @@ mod tests {
 
         set(cv, 0u, 32u8);
         set(cv, 1u, 33u8);
-        assert!(unsafe { *p } == 32u8);
+        assert_eq!(unsafe { *p }, 32u8);
         set(cv, 2u, 34u8); /* safety */
     }
 

src/libstd/comm.rs

@@ -104,7 +104,7 @@ mod test {
         left.send(~"abc");
         right.send(123);
 
-        assert!(left.recv() == 123);
-        assert!(right.recv() == ~"abc");
+        assert_eq!(left.recv(), 123);
+        assert_eq!(right.recv(), ~"abc");
     }
 }

src/libstd/deque.rs

@@ -140,7 +140,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>] {
-    assert!(nelts == elts.len());
+    assert_eq!(nelts, elts.len());
     let mut rv = ~[];
 
     do rv.grow_fn(nelts + 1) |i| {
@@ -163,46 +163,46 @@ mod tests {
     #[test]
     fn test_simple() {
         let mut d = Deque::new();
-        assert!(d.len() == 0u);
+        assert_eq!(d.len(), 0u);
         d.add_front(17);
         d.add_front(42);
         d.add_back(137);
-        assert!(d.len() == 3u);
+        assert_eq!(d.len(), 3u);
         d.add_back(137);
-        assert!(d.len() == 4u);
+        assert_eq!(d.len(), 4u);
         debug!(d.peek_front());
-        assert!(*d.peek_front() == 42);
+        assert_eq!(*d.peek_front(), 42);
         debug!(d.peek_back());
-        assert!(*d.peek_back() == 137);
+        assert_eq!(*d.peek_back(), 137);
         let mut i: int = d.pop_front();
         debug!(i);
-        assert!(i == 42);
+        assert_eq!(i, 42);
         i = d.pop_back();
         debug!(i);
-        assert!(i == 137);
+        assert_eq!(i, 137);
         i = d.pop_back();
         debug!(i);
-        assert!(i == 137);
+        assert_eq!(i, 137);
         i = d.pop_back();
         debug!(i);
-        assert!(i == 17);
-        assert!(d.len() == 0u);
+        assert_eq!(i, 17);
+        assert_eq!(d.len(), 0u);
         d.add_back(3);
-        assert!(d.len() == 1u);
+        assert_eq!(d.len(), 1u);
         d.add_front(2);
-        assert!(d.len() == 2u);
+        assert_eq!(d.len(), 2u);
         d.add_back(4);
-        assert!(d.len() == 3u);
+        assert_eq!(d.len(), 3u);
         d.add_front(1);
-        assert!(d.len() == 4u);
+        assert_eq!(d.len(), 4u);
         debug!(d.get(0));
         debug!(d.get(1));
         debug!(d.get(2));
         debug!(d.get(3));
-        assert!(*d.get(0) == 1);
-        assert!(*d.get(1) == 2);
-        assert!(*d.get(2) == 3);
-        assert!(*d.get(3) == 4);
+        assert_eq!(*d.get(0), 1);
+        assert_eq!(*d.get(1), 2);
+        assert_eq!(*d.get(2), 3);
+        assert_eq!(*d.get(3), 4);
     }
 
     #[test]
@@ -213,63 +213,63 @@ mod tests {
         let d: @int = @175;
 
         let mut deq = Deque::new();
-        assert!(deq.len() == 0);
+        assert_eq!(deq.len(), 0);
         deq.add_front(a);
         deq.add_front(b);
         deq.add_back(c);
-        assert!(deq.len() == 3);
+        assert_eq!(deq.len(), 3);
         deq.add_back(d);
-        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);
+        assert_eq!(deq.len(), 4);
+        assert_eq!(*deq.peek_front(), b);
+        assert_eq!(*deq.peek_back(), d);
+        assert_eq!(deq.pop_front(), b);
+        assert_eq!(deq.pop_back(), d);
+        assert_eq!(deq.pop_back(), c);
+        assert_eq!(deq.pop_back(), a);
+        assert_eq!(deq.len(), 0);
         deq.add_back(c);
-        assert!(deq.len() == 1);
+        assert_eq!(deq.len(), 1);
         deq.add_front(b);
-        assert!(deq.len() == 2);
+        assert_eq!(deq.len(), 2);
         deq.add_back(d);
-        assert!(deq.len() == 3);
+        assert_eq!(deq.len(), 3);
         deq.add_front(a);
-        assert!(deq.len() == 4);
-        assert!(*deq.get(0) == a);
-        assert!(*deq.get(1) == b);
-        assert!(*deq.get(2) == c);
-        assert!(*deq.get(3) == d);
+        assert_eq!(deq.len(), 4);
+        assert_eq!(*deq.get(0), a);
+        assert_eq!(*deq.get(1), b);
+        assert_eq!(*deq.get(2), c);
+        assert_eq!(*deq.get(3), d);
     }
 
     #[cfg(test)]
     fn test_parameterized<T:Copy + Eq>(a: T, b: T, c: T, d: T) {
         let mut deq = Deque::new();
-        assert!(deq.len() == 0);
+        assert_eq!(deq.len(), 0);
         deq.add_front(a);
         deq.add_front(b);
         deq.add_back(c);
-        assert!(deq.len() == 3);
+        assert_eq!(deq.len(), 3);
         deq.add_back(d);
-        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);
+        assert_eq!(deq.len(), 4);
+        assert_eq!(*deq.peek_front(), b);
+        assert_eq!(*deq.peek_back(), d);
+        assert_eq!(deq.pop_front(), b);
+        assert_eq!(deq.pop_back(), d);
+        assert_eq!(deq.pop_back(), c);
+        assert_eq!(deq.pop_back(), a);
+        assert_eq!(deq.len(), 0);
         deq.add_back(c);
-        assert!(deq.len() == 1);
+        assert_eq!(deq.len(), 1);
         deq.add_front(b);
-        assert!(deq.len() == 2);
+        assert_eq!(deq.len(), 2);
         deq.add_back(d);
-        assert!(deq.len() == 3);
+        assert_eq!(deq.len(), 3);
         deq.add_front(a);
-        assert!(deq.len() == 4);
-        assert!(*deq.get(0) == a);
-        assert!(*deq.get(1) == b);
-        assert!(*deq.get(2) == c);
-        assert!(*deq.get(3) == d);
+        assert_eq!(deq.len(), 4);
+        assert_eq!(*deq.get(0), a);
+        assert_eq!(*deq.get(1), b);
+        assert_eq!(*deq.get(2), c);
+        assert_eq!(*deq.get(3), d);
     }
 
     #[deriving(Eq)]

src/libstd/dlist.rs

@@ -438,7 +438,7 @@ pub impl<T> DList<T> {
             link = nobe.next_link();
             count += 1;
         }
-        assert!(count == self.len());
+        assert_eq!(count, self.len());
         // iterate backwards - some of this is probably redundant.
         link = self.peek_tail_n();
         rabbit = link;
@@ -459,7 +459,7 @@ pub impl<T> DList<T> {
             link = nobe.prev_link();
             count -= 1;
         }
-        assert!(count == 0);
+        assert_eq!(count, 0);
     }
 }
 

src/libstd/ebml.rs

@@ -273,22 +273,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 {
-        assert!(d.end == d.start + 1u);
+        assert_eq!(d.end, d.start + 1u);
         (*d.data)[d.start]
     }
 
     pub fn doc_as_u16(d: Doc) -> u16 {
-        assert!(d.end == d.start + 2u);
+        assert_eq!(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 {
-        assert!(d.end == d.start + 4u);
+        assert_eq!(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 {
-        assert!(d.end == d.start + 8u);
+        assert_eq!(d.end, d.start + 8u);
         io::u64_from_be_bytes(*d.data, d.start, 8u)
     }
 
@@ -988,7 +988,7 @@ mod tests {
             let mut deser = reader::Decoder(ebml_doc);
             let v1 = serialize::Decodable::decode(&mut deser);
             debug!("v1 == %?", v1);
-            assert!(v == v1);
+            assert_eq!(v, v1);
         }
 
         test_v(Some(22));

src/libstd/flate.rs

@@ -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)));
-        assert!((in == out));
+        assert_eq!(in, out);
     }
 }

src/libstd/flatpipes.rs

@@ -356,7 +356,7 @@ pub mod flatteners {
     impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             assert!(size_of::<T>() != 0);
-            assert!(size_of::<T>() == buf.len());
+            assert_eq!(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
@@ -652,7 +652,7 @@ mod test {
         let port = serial::reader_port(reader);
 
         let res: int = port.recv();
-        assert!(res == 10i);
+        assert_eq!(res, 10i);
     }
 
     #[test]
@@ -700,7 +700,7 @@ mod test {
         let port = pod::reader_port(reader);
 
         let res: int = port.recv();
-        assert!(res == 10);
+        assert_eq!(res, 10);
     }
 
     #[test]
@@ -843,7 +843,7 @@ mod test {
             for int::range(0, 10) |i| {
                 let j = port.recv();
                 debug!("received %?", j);
-                assert!(i == j);
+                assert_eq!(i, j);
             }
 
             // The test is over!

src/libstd/future.rs

@@ -154,7 +154,7 @@ mod test {
     #[test]
     fn test_from_value() {
         let mut f = from_value(~"snail");
-        assert!(f.get() == ~"snail");
+        assert_eq!(f.get(), ~"snail");
     }
 
     #[test]
@@ -162,31 +162,31 @@ mod test {
         let (po, ch) = oneshot();
         send_one(ch, ~"whale");
         let mut f = from_port(po);
-        assert!(f.get() == ~"whale");
+        assert_eq!(f.get(), ~"whale");
     }
 
     #[test]
     fn test_from_fn() {
         let mut f = from_fn(|| ~"brail");
-        assert!(f.get() == ~"brail");
+        assert_eq!(f.get(), ~"brail");
     }
 
     #[test]
     fn test_interface_get() {
         let mut f = from_value(~"fail");
-        assert!(f.get() == ~"fail");
+        assert_eq!(f.get(), ~"fail");
     }
 
     #[test]
     fn test_get_ref_method() {
         let mut f = from_value(22);
-        assert!(*f.get_ref() == 22);
+        assert_eq!(*f.get_ref(), 22);
     }
 
     #[test]
     fn test_spawn() {
         let mut f = spawn(|| ~"bale");
-        assert!(f.get() == ~"bale");
+        assert_eq!(f.get(), ~"bale");
     }
 
     #[test]
@@ -204,7 +204,7 @@ mod test {
         do task::spawn {
             let mut f = f.take();
             let actual = f.get();
-            assert!(actual == expected);
+            assert_eq!(actual, expected);
         }
     }
 }

src/libstd/getopts.rs

@@ -684,7 +684,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"test")));
-            assert!((opt_str(m, ~"test") == ~"20"));
+            assert_eq!(opt_str(m, ~"test"), ~"20");
           }
           _ => { fail!("test_reqopt_long failed"); }
         }
@@ -731,7 +731,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"t")));
-            assert!((opt_str(m, ~"t") == ~"20"));
+            assert_eq!(opt_str(m, ~"t"), ~"20");
           }
           _ => fail!()
         }
@@ -780,7 +780,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"test")));
-            assert!((opt_str(m, ~"test") == ~"20"));
+            assert_eq!(opt_str(m, ~"test"), ~"20");
           }
           _ => fail!()
         }
@@ -827,7 +827,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"t")));
-            assert!((opt_str(m, ~"t") == ~"20"));
+            assert_eq!(opt_str(m, ~"t"), ~"20");
           }
           _ => fail!()
         }
@@ -946,7 +946,7 @@ mod tests {
           Ok(ref m) => {
             // The next variable after the flag is just a free argument
 
-            assert!((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) => {
-            assert!((opt_count(m, ~"v") == 1));
+            assert_eq!(opt_count(m, ~"v"), 1);
           }
           _ => fail!()
         }
@@ -984,7 +984,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert!((opt_count(m, ~"v") == 2));
+            assert_eq!(opt_count(m, ~"v"), 2);
           }
           _ => fail!()
         }
@@ -997,7 +997,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert!((opt_count(m, ~"v") == 2));
+            assert_eq!(opt_count(m, ~"v"), 2);
           }
           _ => fail!()
         }
@@ -1010,7 +1010,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert!((opt_count(m, ~"verbose") == 1));
+            assert_eq!(opt_count(m, ~"verbose"), 1);
           }
           _ => fail!()
         }
@@ -1023,7 +1023,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert!((opt_count(m, ~"verbose") == 2));
+            assert_eq!(opt_count(m, ~"verbose"), 2);
           }
           _ => fail!()
         }
@@ -1038,7 +1038,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"test")));
-            assert!((opt_str(m, ~"test") == ~"20"));
+            assert_eq!(opt_str(m, ~"test"), ~"20");
           }
           _ => fail!()
         }
@@ -1073,11 +1073,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-              assert!((opt_present(m, ~"test")));
-              assert!((opt_str(m, ~"test") == ~"20"));
+              assert!(opt_present(m, ~"test"));
+              assert_eq!(opt_str(m, ~"test"), ~"20");
               let pair = opt_strs(m, ~"test");
-              assert!((pair[0] == ~"20"));
-              assert!((pair[1] == ~"30"));
+              assert!(pair[0] == ~"20");
+              assert!(pair[1] == ~"30");
           }
           _ => fail!()
         }
@@ -1091,7 +1091,7 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"t")));
-            assert!((opt_str(m, ~"t") == ~"20"));
+            assert_eq!(opt_str(m, ~"t"), ~"20");
           }
           _ => fail!()
         }
@@ -1127,10 +1127,10 @@ mod tests {
         match rs {
           Ok(ref m) => {
             assert!((opt_present(m, ~"t")));
-            assert!((opt_str(m, ~"t") == ~"20"));
+            assert_eq!(opt_str(m, ~"t"), ~"20");
             let pair = opt_strs(m, ~"t");
-            assert!((pair[0] == ~"20"));
-            assert!((pair[1] == ~"30"));
+            assert!(pair[0] == ~"20");
+            assert!(pair[1] == ~"30");
           }
           _ => fail!()
         }
@@ -1171,19 +1171,19 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert!((m.free[0] == ~"prog"));
-            assert!((m.free[1] == ~"free1"));
-            assert!((opt_str(m, ~"s") == ~"20"));
-            assert!((m.free[2] == ~"free2"));
+            assert!(m.free[0] == ~"prog");
+            assert!(m.free[1] == ~"free1");
+            assert_eq!(opt_str(m, ~"s"), ~"20");
+            assert!(m.free[2] == ~"free2");
             assert!((opt_present(m, ~"flag")));
-            assert!((opt_str(m, ~"long") == ~"30"));
+            assert_eq!(opt_str(m, ~"long"), ~"30");
             assert!((opt_present(m, ~"f")));
             let pair = opt_strs(m, ~"m");
-            assert!((pair[0] == ~"40"));
-            assert!((pair[1] == ~"50"));
+            assert!(pair[0] == ~"40");
+            assert!(pair[1] == ~"50");
             let pair = opt_strs(m, ~"n");
-            assert!((pair[0] == ~"-A B"));
-            assert!((pair[1] == ~"-60 70"));
+            assert!(pair[0] == ~"-A B");
+            assert!(pair[1] == ~"-60 70");
             assert!((!opt_present(m, ~"notpresent")));
           }
           _ => fail!()
@@ -1206,10 +1206,10 @@ mod tests {
         assert!(!opts_present(matches, ~[~"thing"]));
         assert!(!opts_present(matches, ~[]));
 
-        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");
+        assert_eq!(opts_str(matches, ~[~"e"]), ~"foo");
+        assert_eq!(opts_str(matches, ~[~"encrypt"]), ~"foo");
+        assert_eq!(opts_str(matches, ~[~"e", ~"encrypt"]), ~"foo");
+        assert_eq!(opts_str(matches, ~[~"encrypt", ~"e"]), ~"foo");
     }
 
     #[test]
@@ -1221,9 +1221,9 @@ mod tests {
           result::Err(_) => fail!()
         };
         assert!(opts_present(matches, ~[~"L"]));
-        assert!(opts_str(matches, ~[~"L"]) == ~"foo");
+        assert_eq!(opts_str(matches, ~[~"L"]), ~"foo");
         assert!(opts_present(matches, ~[~"M"]));
-        assert!(opts_str(matches, ~[~"M"]) == ~".");
+        assert_eq!(opts_str(matches, ~[~"M"]), ~".");
 
     }
 
@@ -1290,7 +1290,7 @@ mod tests {
         let verbose = groups::reqopt(~"b", ~"banana",
                                        ~"some bananas", ~"VAL");
 
-        assert!(groups::long_to_short(&verbose) == short);
+        assert_eq!(groups::long_to_short(&verbose), short);
     }
 
     #[test]
@@ -1347,7 +1347,7 @@ Options:
 
         debug!("expected: <<%s>>", expected);
         debug!("generated: <<%s>>", generated_usage);
-        assert!(generated_usage == expected);
+        assert_eq!(generated_usage, expected);
     }
 
     #[test]