diff options
| author | Corey Richardson <corey@octayn.net> | 2013-05-18 22:02:45 -0400 |
|---|---|---|
| committer | Corey Richardson <corey@octayn.net> | 2013-05-19 08:16:02 -0400 |
| commit | cc57ca012a1f49875e19b1b089c91928dc339979 (patch) | |
| tree | 9f10c27962dbb7c844bc3abb7e20119d75f02aa6 | |
| parent | 3acf37897a4ca7f019ed8894ec3878801377773d (diff) | |
| download | rust-cc57ca012a1f49875e19b1b089c91928dc339979.tar.gz rust-cc57ca012a1f49875e19b1b089c91928dc339979.zip | |
Use assert_eq! rather than assert! where possible
641 files changed, 2831 insertions, 2831 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 93bbf8fb662..44c55563ac5 100644 --- a/src/libcore/at_vec.rs +++ b/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]]); } } diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index b3c0b8cad7a..5ab7f838a57 100644 --- a/src/libcore/bool.rs +++ b/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 }); } } diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs index 7451353458e..8b48376caac 100644 --- a/src/libcore/cast.rs +++ b/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")); } } } diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 87e8d0525e5..b707e3bbb9e 100644 --- a/src/libcore/cell.rs +++ b/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); } diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 4d2b5998b44..2650b96c408 100644 --- a/src/libcore/clone.rs +++ b/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] diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs index cb02364d725..ebc15174c5c 100644 --- a/src/libcore/hash.rs +++ b/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] diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index d9912813cf9..fe44bfba114 100644 --- a/src/libcore/hashmap.rs +++ b/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()); } } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 7b7d278380f..77b486ca446 100644 --- a/src/libcore/io.rs +++ b/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); } } } diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs index 7a44bfdf160..64f6f2d2a9a 100644 --- a/src/libcore/num/int-template/int.rs +++ b/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); } } diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs index d8a4ec19304..b4c9bb65371 100644 --- a/src/libcore/num/uint-template/uint.rs +++ b/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); } } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 0212d4abd29..71c242bb69b 100644 --- a/src/libcore/option.rs +++ b/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); } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index 72e62c80392..2625d03588b 100644 --- a/src/libcore/os.rs +++ b/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))); } diff --git a/src/libcore/path.rs b/src/libcore/path.rs index 8a5d9c0416d..ed9ef864f80 100644 --- a/src/libcore/path.rs +++ b/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); } } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index c0cf4c052c5..1c2b57bb2df 100644 --- a/src/libcore/pipes.rs +++ b/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()); } } } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index e116dc01943..9d40f1b639c 100644 --- a/src/libcore/ptr.rs +++ b/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] diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index daf0b9d094a..84dd7d187e4 100644 --- a/src/libcore/rand.rs +++ b/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] diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs index 53f51fe1da2..a05009e375c 100644 --- a/src/libcore/repr.rs +++ b/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"); diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 72704a429ed..cda2fe13e37 100644 --- a/src/libcore/result.rs +++ b/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); } } diff --git a/src/libcore/rt/io/flate.rs b/src/libcore/rt/io/flate.rs index 24537bef329..db2683dc85d 100644 --- a/src/libcore/rt/io/flate.rs +++ b/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); } -} \ No newline at end of file +} diff --git a/src/libcore/rt/io/mem.rs b/src/libcore/rt/io/mem.rs index 06e1466831d..b2701c1fdc3 100644 --- a/src/libcore/rt/io/mem.rs +++ b/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()); } } diff --git a/src/libcore/rt/io/net/tcp.rs b/src/libcore/rt/io/net/tcp.rs index a833e92fc10..a5fd7a395de 100644 --- a/src/libcore/rt/io/net/tcp.rs +++ b/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); } } diff --git a/src/libcore/rt/io/option.rs b/src/libcore/rt/io/option.rs index 6ae747f8b4b..d71ef55d3ad 100644 --- a/src/libcore/rt/io/option.rs +++ b/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()); diff --git a/src/libcore/rt/mod.rs b/src/libcore/rt/mod.rs index dab627188d0..4dce9da505b 100644 --- a/src/libcore/rt/mod.rs +++ b/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()); diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs index c66f20e01b2..7fd40fb329f 100644 --- a/src/libcore/rt/sched.rs +++ b/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| { diff --git a/src/libcore/rt/thread_local_storage.rs b/src/libcore/rt/thread_local_storage.rs index 6a08c0f59b1..7187d2db41c 100644 --- a/src/libcore/rt/thread_local_storage.rs +++ b/src/libcore/rt/thread_local_storage.rs @@ -21,12 +21,12 @@ pub type Key = pthread_key_t; #[cfg(unix)] pub unsafe fn create(key: &mut Key) { - 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); } } diff --git a/src/libcore/rt/uv/mod.rs b/src/libcore/rt/uv/mod.rs index 99a5252c88a..ad593058303 100644 --- a/src/libcore/rt/uv/mod.rs +++ b/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); } } diff --git a/src/libcore/rt/uv/net.rs b/src/libcore/rt/uv/net.rs index bdd5588014c..68b871e6b31 100644 --- a/src/libcore/rt/uv/net.rs +++ b/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(||()); } diff --git a/src/libcore/rt/uv/uvio.rs b/src/libcore/rt/uv/uvio.rs index ce4eb6aff87..8666d43a100 100644 --- a/src/libcore/rt/uv/uvio.rs +++ b/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); diff --git a/src/libcore/rt/uv/uvll.rs b/src/libcore/rt/uv/uvll.rs index 94e1703b263..ddc9040d730 100644 --- a/src/libcore/rt/uv/uvll.rs +++ b/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()); } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index c84e920a172..02757ab4899 100644 --- a/src/libcore/run.rs +++ b/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] diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 59f769fd92d..a3cb180ed26 100644 --- a/src/libcore/str.rs +++ b/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!((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!(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_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] diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index 50a739ec67d..fc57cf40d1e 100644 --- a/src/libcore/sys.rs +++ b/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); } } diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs index a6edee38e18..e96da3b08c9 100644 --- a/src/libcore/task/mod.rs +++ b/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(()); diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index 5f9642604d0..2ac8fc5f073 100644 --- a/src/libcore/task/spawn.rs +++ b/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); } diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs index 365cb847740..1469471b7ce 100644 --- a/src/libcore/to_str.rs +++ b/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(), ~"{}"); } } diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs index 05ef1cf433f..c9485654b50 100644 --- a/src/libcore/trie.rs +++ b/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); } } diff --git a/src/libcore/unstable/at_exit.rs b/src/libcore/unstable/at_exit.rs index 39c930d415f..d214b509dfb 100644 --- a/src/libcore/unstable/at_exit.rs +++ b/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); } } diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs index 11ac8c14fe4..1a1a89a413f 100644 --- a/src/libcore/unstable/extfmt.rs +++ b/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))); } } diff --git a/src/libcore/unstable/finally.rs b/src/libcore/unstable/finally.rs index 559287b5297..5001fb421cd 100644 --- a/src/libcore/unstable/finally.rs +++ b/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); } \ No newline at end of file diff --git a/src/libcore/unstable/global.rs b/src/libcore/unstable/global.rs index 88433f9cefe..96549a83a8c 100644 --- a/src/libcore/unstable/global.rs +++ b/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 diff --git a/src/libcore/unstable/mod.rs b/src/libcore/unstable/mod.rs index 18a6262f17d..9681a3f36fc 100644 --- a/src/libcore/unstable/mod.rs +++ b/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); } } diff --git a/src/libcore/unstable/sync.rs b/src/libcore/unstable/sync.rs index 4d5c3bf7a78..091031f51fd 100644 --- a/src/libcore/unstable/sync.rs +++ b/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); } } } diff --git a/src/libcore/util.rs b/src/libcore/util.rs index e5067fb90bc..eaf1e31d403 100644 --- a/src/libcore/util.rs +++ b/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() { diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 4c6e0791ba2..f12e70faa8f 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -1389,7 +1389,7 @@ pub fn zip_slice<T:Copy,U:Copy>(v: &const [T], u: &const [U]) let mut zipped = ~[]; let sz = len(v); let mut i = 0u; - assert!(sz == len(u)); + assert_eq!(sz, len(u)); while i < sz { zipped.push((v[i], u[i])); i += 1u; @@ -1405,7 +1405,7 @@ pub fn zip_slice<T:Copy,U:Copy>(v: &const [T], u: &const [U]) */ pub fn zip<T, U>(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] { let mut i = len(v); - assert!(i == len(u)); + assert_eq!(i, len(u)); let mut w = with_capacity(i); while i > 0 { w.push((v.pop(),u.pop())); @@ -1723,7 +1723,7 @@ pub fn eachi_reverse<'r,T>(v: &'r [T], */ #[inline] pub fn _each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool { - assert!(v1.len() == v2.len()); + assert_eq!(v1.len(), v2.len()); for uint::range(0u, v1.len()) |i| { if !f(&v1[i], &v2[i]) { return false; @@ -1751,7 +1751,7 @@ pub fn each2<U, T>(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) -> bool { */ #[inline] pub fn _each2_mut<U, T>(v1: &mut [U], v2: &mut [T], f: &fn(u: &mut U, t: &mut T) -> bool) -> bool { - assert!(v1.len() == v2.len()); + assert_eq!(v1.len(), v2.len()); for uint::range(0u, v1.len()) |i| { if !f(&mut v1[i], &mut v2[i]) { return false; @@ -3139,21 +3139,21 @@ mod tests { let a = ~[1, 2, 3]; let mut ptr = raw::to_ptr(a); let b = from_buf(ptr, 3u); - assert!(b.len() == 3u); - assert!(b[0] == 1); - assert!(b[1] == 2); - assert!(b[2] == 3); + assert_eq!(b.len(), 3u); + assert_eq!(b[0], 1); + assert_eq!(b[1], 2); + assert_eq!(b[2], 3); // Test on-heap copy-from-buf. let c = ~[1, 2, 3, 4, 5]; ptr = raw::to_ptr(c); let d = from_buf(ptr, 5u); - assert!(d.len() == 5u); - assert!(d[0] == 1); - assert!(d[1] == 2); - assert!(d[2] == 3); - assert!(d[3] == 4); - assert!(d[4] == 5); + assert_eq!(d.len(), 5u); + assert_eq!(d[0], 1); + assert_eq!(d[1], 2); + assert_eq!(d[2], 3); + assert_eq!(d[3], 4); + assert_eq!(d[4], 5); } } @@ -3161,37 +3161,37 @@ mod tests { fn test_from_fn() { // Test on-stack from_fn. let mut v = from_fn(3u, square); - assert!(v.len() == 3u); - assert!(v[0] == 0u); - assert!(v[1] == 1u); - assert!(v[2] == 4u); + assert_eq!(v.len(), 3u); + assert_eq!(v[0], 0u); + assert_eq!(v[1], 1u); + assert_eq!(v[2], 4u); // Test on-heap from_fn. v = from_fn(5u, square); - assert!(v.len() == 5u); - assert!(v[0] == 0u); - assert!(v[1] == 1u); - assert!(v[2] == 4u); - assert!(v[3] == 9u); - assert!(v[4] == 16u); + assert_eq!(v.len(), 5u); + assert_eq!(v[0], 0u); + assert_eq!(v[1], 1u); + assert_eq!(v[2], 4u); + assert_eq!(v[3], 9u); + assert_eq!(v[4], 16u); } #[test] fn test_from_elem() { // Test on-stack from_elem. let mut v = from_elem(2u, 10u); - assert!(v.len() == 2u); - assert!(v[0] == 10u); - assert!(v[1] == 10u); + assert_eq!(v.len(), 2u); + assert_eq!(v[0], 10u); + assert_eq!(v[1], 10u); // Test on-heap from_elem. v = from_elem(6u, 20u); - assert!(v[0] == 20u); - assert!(v[1] == 20u); - assert!(v[2] == 20u); - assert!(v[3] == 20u); - assert!(v[4] == 20u); - assert!(v[5] == 20u); + assert_eq!(v[0], 20u); + assert_eq!(v[1], 20u); + assert_eq!(v[2], 20u); + assert_eq!(v[3], 20u); + assert_eq!(v[4], 20u); + assert_eq!(v[5], 20u); } #[test] @@ -3206,18 +3206,18 @@ mod tests { let v0 : &[Z] = &[]; let v1 : &[Z] = &[[]]; let v2 : &[Z] = &[[], []]; - assert!(sys::size_of::<Z>() == 0); - assert!(v0.len() == 0); - assert!(v1.len() == 1); - assert!(v2.len() == 2); + assert_eq!(sys::size_of::<Z>(), 0); + assert_eq!(v0.len(), 0); + assert_eq!(v1.len(), 1); + assert_eq!(v2.len(), 2); } #[test] fn test_head() { let mut a = ~[11]; - assert!(a.head() == &11); + assert_eq!(a.head(), &11); a = ~[11, 12]; - assert!(a.head() == &11); + assert_eq!(a.head(), &11); } #[test] @@ -3231,19 +3231,19 @@ mod tests { #[test] fn test_head_opt() { let mut a = ~[]; - assert!(a.head_opt() == None); + assert_eq!(a.head_opt(), None); a = ~[11]; - assert!(a.head_opt().unwrap() == &11); + assert_eq!(a.head_opt().unwrap(), &11); a = ~[11, 12]; - assert!(a.head_opt().unwrap() == &11); + assert_eq!(a.head_opt().unwrap(), &11); } #[test] fn test_tail() { let mut a = ~[11]; - assert!(a.tail() == &[]); + assert_eq!(a.tail(), &[]); a = ~[11, 12]; - assert!(a.tail() == &[12]); + assert_eq!(a.tail(), &[12]); } #[test] @@ -3257,9 +3257,9 @@ mod tests { #[test] fn test_tailn() { let mut a = ~[11, 12, 13]; - assert!(a.tailn(0) == &[11, 12, 13]); + assert_eq!(a.tailn(0), &[11, 12, 13]); a = ~[11, 12, 13]; - assert!(a.tailn(2) == &[13]); + assert_eq!(a.tailn(2), &[13]); } #[test] @@ -3273,9 +3273,9 @@ mod tests { #[test] fn test_init() { let mut a = ~[11]; - assert!(a.init() == &[]); + assert_eq!(a.init(), &[]); a = ~[11, 12]; - assert!(a.init() == &[11]); + assert_eq!(a.init(), &[11]); } #[init] @@ -3289,9 +3289,9 @@ mod tests { #[test] fn test_initn() { let mut a = ~[11, 12, 13]; - assert!(a.initn(0) == &[11, 12, 13]); + assert_eq!(a.initn(0), &[11, 12, 13]); a = ~[11, 12, 13]; - assert!(a.initn(2) == &[11]); + assert_eq!(a.initn(2), &[11]); } #[init] @@ -3305,9 +3305,9 @@ mod tests { #[test] fn test_last() { let mut a = ~[11]; - assert!(a.last() == &11); + assert_eq!(a.last(), &11); a = ~[11, 12]; - assert!(a.last() == &12); + assert_eq!(a.last(), &12); } #[test] @@ -3321,11 +3321,11 @@ mod tests { #[test] fn test_last_opt() { let mut a = ~[]; - assert!(a.last_opt() == None); + assert_eq!(a.last_opt(), None); a = ~[11]; - assert!(a.last_opt().unwrap() == &11); + assert_eq!(a.last_opt().unwrap(), &11); a = ~[11, 12]; - assert!(a.last_opt().unwrap() == &12); + assert_eq!(a.last_opt().unwrap(), &12); } #[test] @@ -3333,35 +3333,35 @@ mod tests { // Test fixed length vector. let vec_fixed = [1, 2, 3, 4]; let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_vec(); - assert!(v_a.len() == 3u); - assert!(v_a[0] == 2); - assert!(v_a[1] == 3); - assert!(v_a[2] == 4); + assert_eq!(v_a.len(), 3u); + assert_eq!(v_a[0], 2); + assert_eq!(v_a[1], 3); + assert_eq!(v_a[2], 4); // Test on stack. let vec_stack = &[1, 2, 3]; let v_b = slice(vec_stack, 1u, 3u).to_vec(); - assert!(v_b.len() == 2u); - assert!(v_b[0] == 2); - assert!(v_b[1] == 3); + assert_eq!(v_b.len(), 2u); + assert_eq!(v_b[0], 2); + assert_eq!(v_b[1], 3); // Test on managed heap. let vec_managed = @[1, 2, 3, 4, 5]; let v_c = slice(vec_managed, 0u, 3u).to_vec(); - assert!(v_c.len() == 3u); - assert!(v_c[0] == 1); - assert!(v_c[1] == 2); - assert!(v_c[2] == 3); + assert_eq!(v_c.len(), 3u); + assert_eq!(v_c[0], 1); + assert_eq!(v_c[1], 2); + assert_eq!(v_c[2], 3); // Test on exchange heap. let vec_unique = ~[1, 2, 3, 4, 5, 6]; let v_d = slice(vec_unique, 1u, 6u).to_vec(); - assert!(v_d.len() == 5u); - assert!(v_d[0] == 2); - assert!(v_d[1] == 3); - assert!(v_d[2] == 4); - assert!(v_d[3] == 5); - assert!(v_d[4] == 6); + assert_eq!(v_d.len(), 5u); + assert_eq!(v_d[0], 2); + assert_eq!(v_d[1], 3); + assert_eq!(v_d[2], 4); + assert_eq!(v_d[3], 5); + assert_eq!(v_d[4], 6); } #[test] @@ -3369,27 +3369,27 @@ mod tests { // Test on-heap pop. let mut v = ~[1, 2, 3, 4, 5]; let e = v.pop(); - assert!(v.len() == 4u); - assert!(v[0] == 1); - assert!(v[1] == 2); - assert!(v[2] == 3); - assert!(v[3] == 4); - assert!(e == 5); + assert_eq!(v.len(), 4u); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); + assert_eq!(v[3], 4); + assert_eq!(e, 5); } #[test] fn test_swap_remove() { let mut v = ~[1, 2, 3, 4, 5]; let mut e = v.swap_remove(0); - assert!(v.len() == 4); - assert!(e == 1); - assert!(v[0] == 5); + assert_eq!(v.len(), 4); + assert_eq!(e, 1); + assert_eq!(v[0], 5); e = v.swap_remove(3); - assert!(v.len() == 3); - assert!(e == 4); - assert!(v[0] == 5); - assert!(v[1] == 2); - assert!(v[2] == 3); + assert_eq!(v.len(), 3); + assert_eq!(e, 4); + assert_eq!(v[0], 5); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); } #[test] @@ -3399,11 +3399,11 @@ mod tests { ::unstable::sync::exclusive(()), ::unstable::sync::exclusive(())]; let mut _e = v.swap_remove(0); - assert!(v.len() == 2); + assert_eq!(v.len(), 2); _e = v.swap_remove(1); - assert!(v.len() == 1); + assert_eq!(v.len(), 1); _e = v.swap_remove(0); - assert!(v.len() == 0); + assert_eq!(v.len(), 0); } #[test] @@ -3411,14 +3411,14 @@ mod tests { // Test on-stack push(). let mut v = ~[]; v.push(1); - assert!(v.len() == 1u); - assert!(v[0] == 1); + assert_eq!(v.len(), 1u); + assert_eq!(v[0], 1); // Test on-heap push(). v.push(2); - assert!(v.len() == 2u); - assert!(v[0] == 1); - assert!(v[1] == 2); + assert_eq!(v.len(), 2u); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); } #[test] @@ -3426,48 +3426,48 @@ mod tests { // Test on-stack grow(). let mut v = ~[]; v.grow(2u, &1); - assert!(v.len() == 2u); - assert!(v[0] == 1); - assert!(v[1] == 1); + assert_eq!(v.len(), 2u); + assert_eq!(v[0], 1); + assert_eq!(v[1], 1); // Test on-heap grow(). v.grow(3u, &2); - assert!(v.len() == 5u); - assert!(v[0] == 1); - assert!(v[1] == 1); - assert!(v[2] == 2); - assert!(v[3] == 2); - assert!(v[4] == 2); + assert_eq!(v.len(), 5u); + assert_eq!(v[0], 1); + assert_eq!(v[1], 1); + assert_eq!(v[2], 2); + assert_eq!(v[3], 2); + assert_eq!(v[4], 2); } #[test] fn test_grow_fn() { let mut v = ~[]; v.grow_fn(3u, square); - assert!(v.len() == 3u); - assert!(v[0] == 0u); - assert!(v[1] == 1u); - assert!(v[2] == 4u); + assert_eq!(v.len(), 3u); + assert_eq!(v[0], 0u); + assert_eq!(v[1], 1u); + assert_eq!(v[2], 4u); } #[test] fn test_grow_set() { let mut v = ~[1, 2, 3]; v.grow_set(4u, &4, 5); - assert!(v.len() == 5u); - assert!(v[0] == 1); - assert!(v[1] == 2); - assert!(v[2] == 3); - assert!(v[3] == 4); - assert!(v[4] == 5); + assert_eq!(v.len(), 5u); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); + assert_eq!(v[3], 4); + assert_eq!(v[4], 5); } #[test] fn test_truncate() { let mut v = ~[@6,@5,@4]; v.truncate(1); - assert!(v.len() == 1); - assert!(*(v[0]) == 6); + assert_eq!(v.len(), 1); + assert_eq!(*(v[0]), 6); // If the unsafe block didn't drop things properly, we blow up here. } @@ -3475,7 +3475,7 @@ mod tests { fn test_clear() { let mut v = ~[@6,@5,@4]; v.clear(); - assert!(v.len() == 0); + assert_eq!(v.len(), 0); // If the unsafe block didn't drop things properly, we blow up here. } @@ -3484,7 +3484,7 @@ mod tests { fn case(a: ~[uint], b: ~[uint]) { let mut v = a; v.dedup(); - assert!(v == b); + assert_eq!(v, b); } case(~[], ~[]); case(~[1], ~[1]); @@ -3529,20 +3529,20 @@ mod tests { // Test on-stack map. let mut v = ~[1u, 2u, 3u]; let mut w = map(v, square_ref); - assert!(w.len() == 3u); - assert!(w[0] == 1u); - assert!(w[1] == 4u); - assert!(w[2] == 9u); + assert_eq!(w.len(), 3u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 4u); + assert_eq!(w[2], 9u); // Test on-heap map. v = ~[1u, 2u, 3u, 4u, 5u]; w = map(v, square_ref); - assert!(w.len() == 5u); - assert!(w[0] == 1u); - assert!(w[1] == 4u); - assert!(w[2] == 9u); - assert!(w[3] == 16u); - assert!(w[4] == 25u); + assert_eq!(w.len(), 5u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 4u); + assert_eq!(w[2], 9u); + assert_eq!(w[3], 16u); + assert_eq!(w[4], 25u); } #[test] @@ -3561,17 +3561,17 @@ mod tests { // Test on-stack filter-map. let mut v = ~[1u, 2u, 3u]; let mut w = filter_mapped(v, square_if_odd_r); - assert!(w.len() == 2u); - assert!(w[0] == 1u); - assert!(w[1] == 9u); + assert_eq!(w.len(), 2u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 9u); // Test on-heap filter-map. v = ~[1u, 2u, 3u, 4u, 5u]; w = filter_mapped(v, square_if_odd_r); - assert!(w.len() == 3u); - assert!(w[0] == 1u); - assert!(w[1] == 9u); - assert!(w[2] == 25u); + assert_eq!(w.len(), 3u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 9u); + assert_eq!(w[2], 25u); fn halve(i: &int) -> Option<int> { if *i % 2 == 0 { @@ -3588,9 +3588,9 @@ mod tests { let mix_dest: ~[int] = ~[1, 3, 0, 0]; assert!(filter_mapped(all_even, halve) == map(all_even, halve_for_sure)); - assert!(filter_mapped(all_odd1, halve) == ~[]); - assert!(filter_mapped(all_odd2, halve) == ~[]); - assert!(filter_mapped(mix, halve) == mix_dest); + assert_eq!(filter_mapped(all_odd1, halve), ~[]); + assert_eq!(filter_mapped(all_odd2, halve), ~[]); + assert_eq!(filter_mapped(mix, halve), mix_dest); } #[test] @@ -3598,17 +3598,17 @@ mod tests { // Test on-stack filter-map. let mut v = ~[1u, 2u, 3u]; let mut w = filter_map(v, square_if_odd_v); - assert!(w.len() == 2u); - assert!(w[0] == 1u); - assert!(w[1] == 9u); + assert_eq!(w.len(), 2u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 9u); // Test on-heap filter-map. v = ~[1u, 2u, 3u, 4u, 5u]; w = filter_map(v, square_if_odd_v); - assert!(w.len() == 3u); - assert!(w[0] == 1u); - assert!(w[1] == 9u); - assert!(w[2] == 25u); + assert_eq!(w.len(), 3u); + assert_eq!(w[0], 1u); + assert_eq!(w[1], 9u); + assert_eq!(w[2], 25u); fn halve(i: int) -> Option<int> { if i % 2 == 0 { @@ -3626,22 +3626,22 @@ mod tests { let mix_dest: ~[int] = ~[1, 3, 0, 0]; assert!(filter_map(all_even, halve) == map(all_even0, halve_for_sure)); - assert!(filter_map(all_odd1, halve) == ~[]); - assert!(filter_map(all_odd2, halve) == ~[]); - assert!(filter_map(mix, halve) == mix_dest); + assert_eq!(filter_map(all_odd1, halve), ~[]); + assert_eq!(filter_map(all_odd2, halve), ~[]); + assert_eq!(filter_map(mix, halve), mix_dest); } #[test] fn test_filter() { - assert!(filter(~[1u, 2u, 3u], is_odd) == ~[1u, 3u]); - assert!(filter(~[1u, 2u, 4u, 8u, 16u], is_three) == ~[]); + assert_eq!(filter(~[1u, 2u, 3u], is_odd), ~[1u, 3u]); + assert_eq!(filter(~[1u, 2u, 4u, 8u, 16u], is_three), ~[]); } #[test] fn test_retain() { let mut v = ~[1, 2, 3, 4, 5]; v.retain(is_odd); - assert!(v == ~[1, 3, 5]); + assert_eq!(v, ~[1, 3, 5]); } #[test] @@ -3649,12 +3649,12 @@ mod tests { // Test on-stack fold. let mut v = ~[1u, 2u, 3u]; let mut sum = foldl(0u, v, add); - assert!(sum == 6u); + assert_eq!(sum, 6u); // Test on-heap fold. v = ~[1u, 2u, 3u, 4u, 5u]; sum = foldl(0u, v, add); - assert!(sum == 15u); + assert_eq!(sum, 15u); } #[test] @@ -3664,7 +3664,7 @@ mod tests { } let v = ~[1, 2, 3, 4]; let sum = foldl(0, v, sub); - assert!(sum == -10); + assert_eq!(sum, -10); } #[test] @@ -3674,7 +3674,7 @@ mod tests { } let v = ~[1, 2, 3, 4]; let sum = foldr(v, 0, sub); - assert!(sum == -2); + assert_eq!(sum, -2); } #[test] @@ -3690,7 +3690,7 @@ mod tests { for each(~[1, 2, 3]) |v| { i += *v; } - assert!(i == 6); + assert_eq!(i, 6); } #[test] @@ -3698,10 +3698,10 @@ mod tests { let mut i = 0; for eachi(~[1, 2, 3]) |j, v| { if i == 0 { assert!(*v == 1); } - assert!(j + 1u == *v as uint); + assert_eq!(j + 1u, *v as uint); i += *v; } - assert!(i == 6); + assert_eq!(i, 6); } #[test] @@ -3719,7 +3719,7 @@ mod tests { if i == 0 { assert!(*v == 3); } i += *v } - assert!(i == 6); + assert_eq!(i, 6); } #[test] @@ -3727,10 +3727,10 @@ mod tests { let mut i = 0; for eachi_reverse(~[0, 1, 2]) |j, v| { if i == 0 { assert!(*v == 2); } - assert!(j == *v as uint); + assert_eq!(j, *v as uint); i += *v; } - assert!(i == 3); + assert_eq!(i, 3); } #[test] @@ -3747,15 +3747,15 @@ mod tests { results = ~[]; for each_permutation(~[]) |v| { results.push(to_owned(v)); } - assert!(results == ~[~[]]); + assert_eq!(results, ~[~[]]); results = ~[]; for each_permutation(~[7]) |v| { results.push(to_owned(v)); } - assert!(results == ~[~[7]]); + assert_eq!(results, ~[~[7]]); results = ~[]; for each_permutation(~[1,1]) |v| { results.push(to_owned(v)); } - assert!(results == ~[~[1,1],~[1,1]]); + assert_eq!(results, ~[~[1,1],~[1,1]]); results = ~[]; for each_permutation(~[5,2,0]) |v| { results.push(to_owned(v)); } @@ -3797,15 +3797,15 @@ mod tests { let z1 = zip(v1, v2); - assert!((1, 4) == z1[0]); - assert!((2, 5) == z1[1]); - assert!((3, 6) == z1[2]); + assert_eq!((1, 4), z1[0]); + assert_eq!((2, 5), z1[1]); + assert_eq!((3, 6), z1[2]); let (left, right) = unzip(z1); - assert!((1, 4) == (left[0], right[0])); - assert!((2, 5) == (left[1], right[1])); - assert!((3, 6) == (left[2], right[2])); + assert_eq!((1, 4), (left[0], right[0])); + assert_eq!((2, 5), (left[1], right[1])); + assert_eq!((3, 6), (left[2], right[2])); } #[test] @@ -3813,9 +3813,9 @@ mod tests { assert!(position_elem(~[], &1).is_none()); let v1 = ~[1, 2, 3, 3, 2, 5]; - assert!(position_elem(v1, &1) == Some(0u)); - assert!(position_elem(v1, &2) == Some(1u)); - assert!(position_elem(v1, &5) == Some(5u)); + assert_eq!(position_elem(v1, &1), Some(0u)); + assert_eq!(position_elem(v1, &2), Some(1u)); + assert_eq!(position_elem(v1, &5), Some(5u)); assert!(position_elem(v1, &4).is_none()); } @@ -3827,7 +3827,7 @@ mod tests { assert!(position(~[], less_than_three).is_none()); let v1 = ~[5, 4, 3, 2, 1]; - assert!(position(v1, less_than_three) == Some(3u)); + assert_eq!(position(v1, less_than_three), Some(3u)); assert!(position(v1, is_eighteen).is_none()); } @@ -3840,21 +3840,21 @@ mod tests { assert!(position_between(v, 0u, 0u, f).is_none()); assert!(position_between(v, 0u, 1u, f).is_none()); - assert!(position_between(v, 0u, 2u, f) == Some(1u)); - assert!(position_between(v, 0u, 3u, f) == Some(1u)); - assert!(position_between(v, 0u, 4u, f) == Some(1u)); + assert_eq!(position_between(v, 0u, 2u, f), Some(1u)); + assert_eq!(position_between(v, 0u, 3u, f), Some(1u)); + assert_eq!(position_between(v, 0u, 4u, f), Some(1u)); assert!(position_between(v, 1u, 1u, f).is_none()); - assert!(position_between(v, 1u, 2u, f) == Some(1u)); - assert!(position_between(v, 1u, 3u, f) == Some(1u)); - assert!(position_between(v, 1u, 4u, f) == Some(1u)); + assert_eq!(position_between(v, 1u, 2u, f), Some(1u)); + assert_eq!(position_between(v, 1u, 3u, f), Some(1u)); + assert_eq!(position_between(v, 1u, 4u, f), Some(1u)); assert!(position_between(v, 2u, 2u, f).is_none()); assert!(position_between(v, 2u, 3u, f).is_none()); - assert!(position_between(v, 2u, 4u, f) == Some(3u)); + assert_eq!(position_between(v, 2u, 4u, f), Some(3u)); assert!(position_between(v, 3u, 3u, f).is_none()); - assert!(position_between(v, 3u, 4u, f) == Some(3u)); + assert_eq!(position_between(v, 3u, 4u, f), Some(3u)); assert!(position_between(v, 4u, 4u, f).is_none()); } @@ -3867,7 +3867,7 @@ mod tests { fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - assert!(find(v, f) == Some((1, 'b'))); + assert_eq!(find(v, f), Some((1, 'b'))); assert!(find(v, g).is_none()); } @@ -3880,21 +3880,21 @@ mod tests { assert!(find_between(v, 0u, 0u, f).is_none()); assert!(find_between(v, 0u, 1u, f).is_none()); - assert!(find_between(v, 0u, 2u, f) == Some((1, 'b'))); - assert!(find_between(v, 0u, 3u, f) == Some((1, 'b'))); - assert!(find_between(v, 0u, 4u, f) == Some((1, 'b'))); + assert_eq!(find_between(v, 0u, 2u, f), Some((1, 'b'))); + assert_eq!(find_between(v, 0u, 3u, f), Some((1, 'b'))); + assert_eq!(find_between(v, 0u, 4u, f), Some((1, 'b'))); assert!(find_between(v, 1u, 1u, f).is_none()); - assert!(find_between(v, 1u, 2u, f) == Some((1, 'b'))); - assert!(find_between(v, 1u, 3u, f) == Some((1, 'b'))); - assert!(find_between(v, 1u, 4u, f) == Some((1, 'b'))); + assert_eq!(find_between(v, 1u, 2u, f), Some((1, 'b'))); + assert_eq!(find_between(v, 1u, 3u, f), Some((1, 'b'))); + assert_eq!(find_between(v, 1u, 4u, f), Some((1, 'b'))); assert!(find_between(v, 2u, 2u, f).is_none()); assert!(find_between(v, 2u, 3u, f).is_none()); - assert!(find_between(v, 2u, 4u, f) == Some((3, 'b'))); + assert_eq!(find_between(v, 2u, 4u, f), Some((3, 'b'))); assert!(find_between(v, 3u, 3u, f).is_none()); - assert!(find_between(v, 3u, 4u, f) == Some((3, 'b'))); + assert_eq!(find_between(v, 3u, 4u, f), Some((3, 'b'))); assert!(find_between(v, 4u, 4u, f).is_none()); } @@ -3907,7 +3907,7 @@ mod tests { fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - assert!(position(v, f) == Some(1u)); + assert_eq!(position(v, f), Some(1u)); assert!(position(v, g).is_none()); } @@ -3920,21 +3920,21 @@ mod tests { assert!(rposition_between(v, 0u, 0u, f).is_none()); assert!(rposition_between(v, 0u, 1u, f).is_none()); - assert!(rposition_between(v, 0u, 2u, f) == Some(1u)); - assert!(rposition_between(v, 0u, 3u, f) == Some(1u)); - assert!(rposition_between(v, 0u, 4u, f) == Some(3u)); + assert_eq!(rposition_between(v, 0u, 2u, f), Some(1u)); + assert_eq!(rposition_between(v, 0u, 3u, f), Some(1u)); + assert_eq!(rposition_between(v, 0u, 4u, f), Some(3u)); assert!(rposition_between(v, 1u, 1u, f).is_none()); - assert!(rposition_between(v, 1u, 2u, f) == Some(1u)); - assert!(rposition_between(v, 1u, 3u, f) == Some(1u)); - assert!(rposition_between(v, 1u, 4u, f) == Some(3u)); + assert_eq!(rposition_between(v, 1u, 2u, f), Some(1u)); + assert_eq!(rposition_between(v, 1u, 3u, f), Some(1u)); + assert_eq!(rposition_between(v, 1u, 4u, f), Some(3u)); assert!(rposition_between(v, 2u, 2u, f).is_none()); assert!(rposition_between(v, 2u, 3u, f).is_none()); - assert!(rposition_between(v, 2u, 4u, f) == Some(3u)); + assert_eq!(rposition_between(v, 2u, 4u, f), Some(3u)); assert!(rposition_between(v, 3u, 3u, f).is_none()); - assert!(rposition_between(v, 3u, 4u, f) == Some(3u)); + assert_eq!(rposition_between(v, 3u, 4u, f), Some(3u)); assert!(rposition_between(v, 4u, 4u, f).is_none()); } @@ -3947,7 +3947,7 @@ mod tests { fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - assert!(rfind(v, f) == Some((3, 'b'))); + assert_eq!(rfind(v, f), Some((3, 'b'))); assert!(rfind(v, g).is_none()); } @@ -3960,87 +3960,87 @@ mod tests { assert!(rfind_between(v, 0u, 0u, f).is_none()); assert!(rfind_between(v, 0u, 1u, f).is_none()); - assert!(rfind_between(v, 0u, 2u, f) == Some((1, 'b'))); - assert!(rfind_between(v, 0u, 3u, f) == Some((1, 'b'))); - assert!(rfind_between(v, 0u, 4u, f) == Some((3, 'b'))); + assert_eq!(rfind_between(v, 0u, 2u, f), Some((1, 'b'))); + assert_eq!(rfind_between(v, 0u, 3u, f), Some((1, 'b'))); + assert_eq!(rfind_between(v, 0u, 4u, f), Some((3, 'b'))); assert!(rfind_between(v, 1u, 1u, f).is_none()); - assert!(rfind_between(v, 1u, 2u, f) == Some((1, 'b'))); - assert!(rfind_between(v, 1u, 3u, f) == Some((1, 'b'))); - assert!(rfind_between(v, 1u, 4u, f) == Some((3, 'b'))); + assert_eq!(rfind_between(v, 1u, 2u, f), Some((1, 'b'))); + assert_eq!(rfind_between(v, 1u, 3u, f), Some((1, 'b'))); + assert_eq!(rfind_between(v, 1u, 4u, f), Some((3, 'b'))); assert!(rfind_between(v, 2u, 2u, f).is_none()); assert!(rfind_between(v, 2u, 3u, f).is_none()); - assert!(rfind_between(v, 2u, 4u, f) == Some((3, 'b'))); + assert_eq!(rfind_between(v, 2u, 4u, f), Some((3, 'b'))); assert!(rfind_between(v, 3u, 3u, f).is_none()); - assert!(rfind_between(v, 3u, 4u, f) == Some((3, 'b'))); + assert_eq!(rfind_between(v, 3u, 4u, f), Some((3, 'b'))); assert!(rfind_between(v, 4u, 4u, f).is_none()); } #[test] fn test_bsearch_elem() { - assert!(bsearch_elem([1,2,3,4,5], &5) == Some(4)); - assert!(bsearch_elem([1,2,3,4,5], &4) == Some(3)); - assert!(bsearch_elem([1,2,3,4,5], &3) == Some(2)); - assert!(bsearch_elem([1,2,3,4,5], &2) == Some(1)); - assert!(bsearch_elem([1,2,3,4,5], &1) == Some(0)); - - assert!(bsearch_elem([2,4,6,8,10], &1) == None); - assert!(bsearch_elem([2,4,6,8,10], &5) == None); - assert!(bsearch_elem([2,4,6,8,10], &4) == Some(1)); - assert!(bsearch_elem([2,4,6,8,10], &10) == Some(4)); - - assert!(bsearch_elem([2,4,6,8], &1) == None); - assert!(bsearch_elem([2,4,6,8], &5) == None); - assert!(bsearch_elem([2,4,6,8], &4) == Some(1)); - assert!(bsearch_elem([2,4,6,8], &8) == Some(3)); - - assert!(bsearch_elem([2,4,6], &1) == None); - assert!(bsearch_elem([2,4,6], &5) == None); - assert!(bsearch_elem([2,4,6], &4) == Some(1)); - assert!(bsearch_elem([2,4,6], &6) == Some(2)); - - assert!(bsearch_elem([2,4], &1) == None); - assert!(bsearch_elem([2,4], &5) == None); - assert!(bsearch_elem([2,4], &2) == Some(0)); - assert!(bsearch_elem([2,4], &4) == Some(1)); - - assert!(bsearch_elem([2], &1) == None); - assert!(bsearch_elem([2], &5) == None); - assert!(bsearch_elem([2], &2) == Some(0)); - - assert!(bsearch_elem([], &1) == None); - assert!(bsearch_elem([], &5) == None); + assert_eq!(bsearch_elem([1,2,3,4,5], &5), Some(4)); + assert_eq!(bsearch_elem([1,2,3,4,5], &4), Some(3)); + assert_eq!(bsearch_elem([1,2,3,4,5], &3), Some(2)); + assert_eq!(bsearch_elem([1,2,3,4,5], &2), Some(1)); + assert_eq!(bsearch_elem([1,2,3,4,5], &1), Some(0)); + + assert_eq!(bsearch_elem([2,4,6,8,10], &1), None); + assert_eq!(bsearch_elem([2,4,6,8,10], &5), None); + assert_eq!(bsearch_elem([2,4,6,8,10], &4), Some(1)); + assert_eq!(bsearch_elem([2,4,6,8,10], &10), Some(4)); + + assert_eq!(bsearch_elem([2,4,6,8], &1), None); + assert_eq!(bsearch_elem([2,4,6,8], &5), None); + assert_eq!(bsearch_elem([2,4,6,8], &4), Some(1)); + assert_eq!(bsearch_elem([2,4,6,8], &8), Some(3)); + + assert_eq!(bsearch_elem([2,4,6], &1), None); + assert_eq!(bsearch_elem([2,4,6], &5), None); + assert_eq!(bsearch_elem([2,4,6], &4), Some(1)); + assert_eq!(bsearch_elem([2,4,6], &6), Some(2)); + + assert_eq!(bsearch_elem([2,4], &1), None); + assert_eq!(bsearch_elem([2,4], &5), None); + assert_eq!(bsearch_elem([2,4], &2), Some(0)); + assert_eq!(bsearch_elem([2,4], &4), Some(1)); + + assert_eq!(bsearch_elem([2], &1), None); + assert_eq!(bsearch_elem([2], &5), None); + assert_eq!(bsearch_elem([2], &2), Some(0)); + + assert_eq!(bsearch_elem([], &1), None); + assert_eq!(bsearch_elem([], &5), None); assert!(bsearch_elem([1,1,1,1,1], &1) != None); assert!(bsearch_elem([1,1,1,1,2], &1) != None); assert!(bsearch_elem([1,1,1,2,2], &1) != None); assert!(bsearch_elem([1,1,2,2,2], &1) != None); - assert!(bsearch_elem([1,2,2,2,2], &1) == Some(0)); + assert_eq!(bsearch_elem([1,2,2,2,2], &1), Some(0)); - assert!(bsearch_elem([1,2,3,4,5], &6) == None); - assert!(bsearch_elem([1,2,3,4,5], &0) == None); + assert_eq!(bsearch_elem([1,2,3,4,5], &6), None); + assert_eq!(bsearch_elem([1,2,3,4,5], &0), None); } #[test] fn reverse_and_reversed() { let mut v: ~[int] = ~[10, 20]; - assert!(v[0] == 10); - assert!(v[1] == 20); + assert_eq!(v[0], 10); + assert_eq!(v[1], 20); reverse(v); - assert!(v[0] == 20); - assert!(v[1] == 10); + assert_eq!(v[0], 20); + assert_eq!(v[1], 10); let v2 = reversed::<int>(~[10, 20]); - assert!(v2[0] == 20); - assert!(v2[1] == 10); + assert_eq!(v2[0], 20); + assert_eq!(v2[1], 10); v[0] = 30; - assert!(v2[0] == 20); + assert_eq!(v2[0], 20); // Make sure they work with 0-length vectors too. let v4 = reversed::<int>(~[]); - assert!(v4 == ~[]); + assert_eq!(v4, ~[]); let mut v3: ~[int] = ~[]; reverse::<int>(v3); } @@ -4048,29 +4048,29 @@ mod tests { #[test] fn reversed_mut() { let v2 = reversed::<int>(~[10, 20]); - assert!(v2[0] == 20); - assert!(v2[1] == 10); + assert_eq!(v2[0], 20); + assert_eq!(v2[1], 10); } #[test] fn test_split() { fn f(x: &int) -> bool { *x == 3 } - assert!(split(~[], f) == ~[]); - assert!(split(~[1, 2], f) == ~[~[1, 2]]); - assert!(split(~[3, 1, 2], f) == ~[~[], ~[1, 2]]); - assert!(split(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); - assert!(split(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]); + assert_eq!(split(~[], f), ~[]); + assert_eq!(split(~[1, 2], f), ~[~[1, 2]]); + assert_eq!(split(~[3, 1, 2], f), ~[~[], ~[1, 2]]); + assert_eq!(split(~[1, 2, 3], f), ~[~[1, 2], ~[]]); + assert_eq!(split(~[1, 2, 3, 4, 3, 5], f), ~[~[1, 2], ~[4], ~[5]]); } #[test] fn test_splitn() { fn f(x: &int) -> bool { *x == 3 } - assert!(splitn(~[], 1u, f) == ~[]); - assert!(splitn(~[1, 2], 1u, f) == ~[~[1, 2]]); - assert!(splitn(~[3, 1, 2], 1u, f) == ~[~[], ~[1, 2]]); - assert!(splitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); + assert_eq!(splitn(~[], 1u, f), ~[]); + assert_eq!(splitn(~[1, 2], 1u, f), ~[~[1, 2]]); + assert_eq!(splitn(~[3, 1, 2], 1u, f), ~[~[], ~[1, 2]]); + assert_eq!(splitn(~[1, 2, 3], 1u, f), ~[~[1, 2], ~[]]); assert!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) == ~[~[1, 2], ~[4, 3, 5]]); } @@ -4079,9 +4079,9 @@ mod tests { fn test_rsplit() { fn f(x: &int) -> bool { *x == 3 } - assert!(rsplit(~[], f) == ~[]); - assert!(rsplit(~[1, 2], f) == ~[~[1, 2]]); - assert!(rsplit(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); + assert_eq!(rsplit(~[], f), ~[]); + assert_eq!(rsplit(~[1, 2], f), ~[~[1, 2]]); + assert_eq!(rsplit(~[1, 2, 3], f), ~[~[1, 2], ~[]]); assert!(rsplit(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]); } @@ -4090,9 +4090,9 @@ mod tests { fn test_rsplitn() { fn f(x: &int) -> bool { *x == 3 } - assert!(rsplitn(~[], 1u, f) == ~[]); - assert!(rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]); - assert!(rsplitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); + assert_eq!(rsplitn(~[], 1u, f), ~[]); + assert_eq!(rsplitn(~[1, 2], 1u, f), ~[~[1, 2]]); + assert_eq!(rsplitn(~[1, 2, 3], 1u, f), ~[~[1, 2], ~[]]); assert!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) == ~[~[1, 2, 3, 4], ~[5]]); } @@ -4100,7 +4100,7 @@ mod tests { #[test] fn test_partition() { // FIXME (#4355 maybe): using v.partition here crashes - assert!(partition(~[], |x: &int| *x < 3) == (~[], ~[])); + assert_eq!(partition(~[], |x: &int| *x < 3), (~[], ~[])); assert!(partition(~[1, 2, 3], |x: &int| *x < 4) == (~[1, 2, 3], ~[])); assert!(partition(~[1, 2, 3], |x: &int| *x < 2) == @@ -4111,7 +4111,7 @@ mod tests { #[test] fn test_partitioned() { - assert!((~[]).partitioned(|x: &int| *x < 3) == (~[], ~[])); + assert_eq!((~[]).partitioned(|x: &int| *x < 3), (~[], ~[])) assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) == (~[1, 2, 3], ~[])); assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) == @@ -4122,14 +4122,14 @@ mod tests { #[test] fn test_concat() { - assert!(concat(~[~[1], ~[2,3]]) == ~[1, 2, 3]); + assert_eq!(concat(~[~[1], ~[2,3]]), ~[1, 2, 3]); } #[test] fn test_connect() { - assert!(connect(~[], &0) == ~[]); - assert!(connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]); - assert!(connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]); + assert_eq!(connect(~[], &0), ~[]); + assert_eq!(connect(~[~[1], ~[2, 3]], &0), ~[1, 0, 2, 3]); + assert_eq!(connect(~[~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]); } #[test] @@ -4161,26 +4161,26 @@ mod tests { fn test_unshift() { let mut x = ~[1, 2, 3]; x.unshift(0); - assert!(x == ~[0, 1, 2, 3]); + assert_eq!(x, ~[0, 1, 2, 3]); } #[test] fn test_insert() { let mut a = ~[1, 2, 4]; a.insert(2, 3); - assert!(a == ~[1, 2, 3, 4]); + assert_eq!(a, ~[1, 2, 3, 4]); let mut a = ~[1, 2, 3]; a.insert(0, 0); - assert!(a == ~[0, 1, 2, 3]); + assert_eq!(a, ~[0, 1, 2, 3]); let mut a = ~[1, 2, 3]; a.insert(3, 4); - assert!(a == ~[1, 2, 3, 4]); + assert_eq!(a, ~[1, 2, 3, 4]); let mut a = ~[]; a.insert(0, 1); - assert!(a == ~[1]); + assert_eq!(a, ~[1]); } #[test] @@ -4195,15 +4195,15 @@ mod tests { fn test_remove() { let mut a = ~[1, 2, 3, 4]; a.remove(2); - assert!(a == ~[1, 2, 4]); + assert_eq!(a, ~[1, 2, 4]); let mut a = ~[1, 2, 3]; a.remove(0); - assert!(a == ~[2, 3]); + assert_eq!(a, ~[2, 3]); let mut a = ~[1]; a.remove(0); - assert!(a == ~[]); + assert_eq!(a, ~[]); } #[test] @@ -4218,19 +4218,19 @@ mod tests { fn test_capacity() { let mut v = ~[0u64]; reserve(&mut v, 10u); - assert!(capacity(&v) == 10u); + assert_eq!(capacity(&v), 10u); let mut v = ~[0u32]; reserve(&mut v, 10u); - assert!(capacity(&v) == 10u); + assert_eq!(capacity(&v), 10u); } #[test] fn test_slice_2() { let v = ~[1, 2, 3, 4, 5]; let v = v.slice(1u, 3u); - assert!(v.len() == 2u); - assert!(v[0] == 2); - assert!(v[1] == 3); + assert_eq!(v.len(), 2u); + assert_eq!(v[0], 2); + assert_eq!(v[1], 3); } @@ -4844,6 +4844,6 @@ mod tests { for [1, 2, 3].each_val |v| { i += v; } - assert!(i == 6); + assert_eq!(i, 6); } } diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index 37a025cd820..4b3ed4c70f5 100644 --- a/src/librustc/back/rpath.rs +++ b/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"))); } } diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 99ffa8cc94a..572397b7f8a 100644 --- a/src/librustc/driver/driver.rs +++ b/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); } } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 43073728e83..8779cab87f6 100644 --- a/src/librustc/metadata/decoder.rs +++ b/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 { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index d27bfd081bc..8c21998768e 100644 --- a/src/librustc/metadata/encoder.rs +++ b/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; } diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 55a0755f5e3..ad5bd2447a6 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/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)); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 209a14942e9..0235ab47967 100644 --- a/src/librustc/middle/astencode.rs +++ b/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 { diff --git a/src/librustc/middle/borrowck/gather_loans/mod.rs b/src/librustc/middle/borrowck/gather_loans/mod.rs index 0db7b4880e7..a422d99b6f5 100644 --- a/src/librustc/middle/borrowck/gather_loans/mod.rs +++ b/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, diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 9ffd0e6f22c..f4b9e4b62fc 100644 --- a/src/librustc/middle/entry.rs +++ b/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); } } } diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 27b62738793..fce078a708f 100644 --- a/src/librustc/middle/region.rs +++ b/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); } diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index a7e590e359c..1568c3e5535 100644 --- a/src/librustc/middle/resolve.rs +++ b/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. diff --git a/src/librustc/middle/resolve_stage0.rs b/src/librustc/middle/resolve_stage0.rs index 713132b12fc..aefbcbaa87e 100644 --- a/src/librustc/middle/resolve_stage0.rs +++ b/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. diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 21452a736fb..25e97b0c8a8 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/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 = ~[]; diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index b5cca20d8ec..66cca74214a 100644 --- a/src/librustc/middle/trans/base.rs +++ b/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, diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 38f8d271f08..362bcd483b4 100644 --- a/src/librustc/middle/trans/build.rs +++ b/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), diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index dc81a980588..382e80148ec 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/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, diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index c6fa42cb8cb..d9cf1a3b4bc 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/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}); } diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index 48c5a96c8e7..e08cc536a70 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/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) { diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 13f02b8fcac..13b072c6f63 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/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); diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 3ed08eade33..51f17fcf47c 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/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); diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index f8aa3eca284..f77e2e0d52a 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/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. diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index bb18948ce5d..9ea3259e969 100644 --- a/src/librustc/middle/ty.rs +++ b/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)) diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 311aa551601..aeb360dc3f2 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/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; diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index a5e8b42dee5..1437494e5f8 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/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 } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 3bcff923465..d6e652592d8 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/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) } diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs index b8a66eb8f64..47c99a8d9b7 100644 --- a/src/librustdoc/astsrv.rs +++ b/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); } } diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs index 278f77135f9..c25764ab060 100644 --- a/src/librustdoc/desc_to_brief_pass.rs +++ b/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] diff --git a/src/librustdoc/escape_pass.rs b/src/librustdoc/escape_pass.rs index 949573be05e..11e9b71afdf 100644 --- a/src/librustdoc/escape_pass.rs +++ b/src/librustdoc/escape_pass.rs @@ -27,5 +27,5 @@ fn escape(s: &str) -> ~str { fn should_escape_backslashes() { let s = ~"\\n"; let r = escape(s); - assert!(r == ~"\\\\n"); + assert_eq!(r, ~"\\\\n"); } diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 7c66b4f4d4e..4c120aed911 100644 --- a/src/librustdoc/fold.rs +++ b/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); } diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs index 24bfa62305a..2c34f3543b7 100644 --- a/src/librustdoc/markdown_index_pass.rs +++ b/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] diff --git a/src/librustdoc/markdown_writer.rs b/src/librustdoc/markdown_writer.rs index 456a5f09a88..94372127a22 100644 --- a/src/librustdoc/markdown_writer.rs +++ b/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")); } } diff --git a/src/librustdoc/page_pass.rs b/src/librustdoc/page_pass.rs index 89a3acc6cac..02716ff73b6 100644 --- a/src/librustdoc/page_pass.rs +++ b/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] diff --git a/src/librustdoc/pass.rs b/src/librustdoc/pass.rs index b80f43a7bbd..6527481d514 100644 --- a/src/librustdoc/pass.rs +++ b/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"); } } diff --git a/src/librustdoc/path_pass.rs b/src/librustdoc/path_pass.rs index 5560f21af61..a31a8ac5933 100644 --- a/src/librustdoc/path_pass.rs +++ b/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"]); } } diff --git a/src/librustdoc/prune_private_pass.rs b/src/librustdoc/prune_private_pass.rs index 086b5f47601..9dfcc7c4ec6 100644 --- a/src/librustdoc/prune_private_pass.rs +++ b/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] diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs index c69f3b13e26..8c3704d55c7 100644 --- a/src/librustdoc/sectionalize_pass.rs +++ b/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); } } diff --git a/src/librustdoc/sort_item_name_pass.rs b/src/librustdoc/sort_item_name_pass.rs index 86b2cc634fd..572cb7db926 100644 --- a/src/librustdoc/sort_item_name_pass.rs +++ b/src/librustdoc/sort_item_name_pass.rs @@ -31,7 +31,7 @@ fn test() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass().f)(srv.clone(), doc); - 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"); } } diff --git a/src/librustdoc/sort_item_type_pass.rs b/src/librustdoc/sort_item_type_pass.rs index 158d407fff6..cdb1a49c36d 100644 --- a/src/librustdoc/sort_item_type_pass.rs +++ b/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"); } } diff --git a/src/librustdoc/sort_pass.rs b/src/librustdoc/sort_pass.rs index dc7bc8b9df2..72abbd2bdbd 100644 --- a/src/librustdoc/sort_pass.rs +++ b/src/librustdoc/sort_pass.rs @@ -67,10 +67,10 @@ fn test() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass(~"", name_lteq).f)(srv.clone(), doc); - 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"); } } diff --git a/src/librustdoc/text_pass.rs b/src/librustdoc/text_pass.rs index 61768e37a83..3b1a2059622 100644 --- a/src/librustdoc/text_pass.rs +++ b/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] diff --git a/src/librustdoc/trim_pass.rs b/src/librustdoc/trim_pass.rs index e56a5f18ac6..8bfa12ca0b5 100644 --- a/src/librustdoc/trim_pass.rs +++ b/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")); } } diff --git a/src/librustdoc/unindent_pass.rs b/src/librustdoc/unindent_pass.rs index 082c4dd1989..826012a2447 100644 --- a/src/librustdoc/unindent_pass.rs +++ b/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"); } diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 8eba3f06de3..2574ba4e762 100644 --- a/src/librustpkg/tests.rs +++ b/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()); } } diff --git a/src/librustpkg/testsuite/pass/src/install-paths/test.rs b/src/librustpkg/testsuite/pass/src/install-paths/test.rs index acfae9e04fb..011a1540e1b 100644 --- a/src/librustpkg/testsuite/pass/src/install-paths/test.rs +++ b/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); } diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index 4a9c276948a..108a404eb7c 100644 --- a/src/librustpkg/util.rs +++ b/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 } diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index df49771258e..f0158acfa79 100644 --- a/src/libstd/arc.rs +++ b/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); } } diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 68242f88fae..76df1081737 100644 --- a/src/libstd/base64.rs +++ b/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")); } } diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index e31818ecc1c..f0632e550fa 100644 --- a/src/libstd/bitv.rs +++ b/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 { diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 17b7bae6de5..e463e597188 100644 --- a/src/libstd/c_vec.rs +++ b/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 */ } diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs index 20ab2d61ecc..28d3d329b26 100644 --- a/src/libstd/comm.rs +++ b/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"); } } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index c94acaa1f70..eac765de006 100644 --- a/src/libstd/deque.rs +++ b/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)] diff --git a/src/libstd/dlist.rs b/src/libstd/dlist.rs index 84bd803afe7..e0b4d746d53 100644 --- a/src/libstd/dlist.rs +++ b/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); } } diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 64f78d5ab7b..8d550081d1e 100644 --- a/src/libstd/ebml.rs +++ b/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)); diff --git a/src/libstd/flate.rs b/src/libstd/flate.rs index 7485f2645bd..b0d219bc945 100644 --- a/src/libstd/flate.rs +++ b/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); } } diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs index f4b581f84fc..a634f88dcf5 100644 --- a/src/libstd/flatpipes.rs +++ b/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! diff --git a/src/libstd/future.rs b/src/libstd/future.rs index 93b6540a40d..02828b8eaee 100644 --- a/src/libstd/future.rs +++ b/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); } } } diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 1cb63124456..d0b298deb89 100644 --- a/src/libstd/getopts.rs +++ b/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] diff --git a/src/libstd/list.rs b/src/libstd/list.rs index aa4abbac9d3..ae3251b961c 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -228,19 +228,19 @@ mod tests { fn test_from_vec() { let l = from_vec(~[0, 1, 2]); - assert!((head(l) == 0)); + assert_eq!(head(l), 0); let tail_l = tail(l); - assert!((head(tail_l) == 1)); + assert_eq!(head(tail_l), 1); let tail_tail_l = tail(tail_l); - assert!((head(tail_tail_l) == 2)); + assert_eq!(head(tail_tail_l), 2); } #[test] fn test_from_vec_empty() { let empty : @list::List<int> = from_vec(~[]); - assert!((empty == @list::Nil::<int>)); + assert_eq!(empty, @list::Nil::<int>); } #[test] @@ -248,8 +248,8 @@ mod tests { fn add(a: &uint, b: &int) -> uint { return *a + (*b as uint); } let l = from_vec(~[0, 1, 2, 3, 4]); let empty = @list::Nil::<int>; - assert!((list::foldl(0u, l, add) == 10u)); - assert!((list::foldl(0u, empty, add) == 0u)); + assert_eq!(list::foldl(0u, l, add), 10u); + assert_eq!(list::foldl(0u, empty, add), 0u); } #[test] @@ -258,14 +258,14 @@ mod tests { *a - *b } let l = from_vec(~[1, 2, 3, 4]); - assert!((list::foldl(0, l, sub) == -10)); + assert_eq!(list::foldl(0, l, sub), -10); } #[test] fn test_find_success() { fn match_(i: &int) -> bool { return *i == 2; } let l = from_vec(~[0, 1, 2]); - assert!((list::find(l, match_) == option::Some(2))); + assert_eq!(list::find(l, match_), option::Some(2)); } #[test] @@ -273,8 +273,8 @@ mod tests { fn match_(_i: &int) -> bool { return false; } let l = from_vec(~[0, 1, 2]); let empty = @list::Nil::<int>; - assert!((list::find(l, match_) == option::None::<int>)); - assert!((list::find(empty, match_) == option::None::<int>)); + assert_eq!(list::find(l, match_), option::None::<int>); + assert_eq!(list::find(empty, match_), option::None::<int>); } #[test] @@ -291,8 +291,8 @@ mod tests { fn test_len() { let l = from_vec(~[0, 1, 2]); let empty = @list::Nil::<int>; - assert!((list::len(l) == 3u)); - assert!((list::len(empty) == 0u)); + assert_eq!(list::len(l), 3u); + assert_eq!(list::len(empty), 0u); } #[test] diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index 84561256cd1..19cd418915e 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -125,9 +125,9 @@ pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) } #[test] fn test_md4() { - assert!(md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0"); - assert!(md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24"); - assert!(md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d"); + assert_eq!(md4_text(~""), ~"31d6cfe0d16ae931b73c59d7e0c089c0"); + assert_eq!(md4_text(~"a"), ~"bde52cb31de33e46245e05fbdbd6fb24"); + assert_eq!(md4_text(~"abc"), ~"a448017aaf21d8525fc10ae87aa6729d"); assert!(md4_text(~"message digest") == ~"d9130a8164549fe818874806e1c7014b"); assert!(md4_text(~"abcdefghijklmnopqrstuvwxyz") == diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index cc4e7ee0204..4f67f1c5f13 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -383,7 +383,7 @@ mod test { let format_result = format_addr(&v6::parse_addr(localhost_str)); debug!("results: expected: '%s' actual: '%s'", localhost_str, format_result); - assert!(format_result == localhost_str); + assert_eq!(format_result, localhost_str); } #[test] fn test_ip_ipv4_bad_parse() { diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 37578e42baf..db61679890b 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -1623,7 +1623,7 @@ mod test { // This is what we are actually testing! assert!(net::ip::format_addr(&sock.get_peer_addr()) == ~"127.0.0.1"); - assert!(net::ip::get_port(&sock.get_peer_addr()) == 8887); + assert_eq!(net::ip::get_port(&sock.get_peer_addr()), 8887); // Fulfill the protocol the test server expects let resp_bytes = str::to_bytes(~"ping"); diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index e7cf710cf67..ef503817b55 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -722,53 +722,53 @@ impl IterBytes for Url { #[test] fn test_split_char_first() { let (u,v) = split_char_first(~"hello, sweet world", ','); - assert!(u == ~"hello"); - assert!(v == ~" sweet world"); + assert_eq!(u, ~"hello"); + assert_eq!(v, ~" sweet world"); let (u,v) = split_char_first(~"hello sweet world", ','); - assert!(u == ~"hello sweet world"); - assert!(v == ~""); + assert_eq!(u, ~"hello sweet world"); + assert_eq!(v, ~""); } #[test] fn test_get_authority() { let (u, h, p, r) = get_authority( "//user:pass@rust-lang.org/something").unwrap(); - assert!(u == Some(UserInfo::new(~"user", Some(~"pass")))); - assert!(h == ~"rust-lang.org"); + assert_eq!(u, Some(UserInfo::new(~"user", Some(~"pass")))); + assert_eq!(h, ~"rust-lang.org"); assert!(p.is_none()); - assert!(r == ~"/something"); + assert_eq!(r, ~"/something"); let (u, h, p, r) = get_authority( "//rust-lang.org:8000?something").unwrap(); assert!(u.is_none()); - assert!(h == ~"rust-lang.org"); - assert!(p == Some(~"8000")); - assert!(r == ~"?something"); + assert_eq!(h, ~"rust-lang.org"); + assert_eq!(p, Some(~"8000")); + assert_eq!(r, ~"?something"); let (u, h, p, r) = get_authority( "//rust-lang.org#blah").unwrap(); assert!(u.is_none()); - assert!(h == ~"rust-lang.org"); + assert_eq!(h, ~"rust-lang.org"); assert!(p.is_none()); - assert!(r == ~"#blah"); + assert_eq!(r, ~"#blah"); // ipv6 tests let (_, h, _, _) = get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334#blah").unwrap(); - assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert_eq!(h, ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); let (_, h, p, _) = get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah").unwrap(); - assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); - assert!(p == Some(~"8000")); + assert_eq!(h, ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert_eq!(p, Some(~"8000")); let (u, h, p, _) = get_authority( "//us:p@2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah" ).unwrap(); - assert!(u == Some(UserInfo::new(~"us", Some(~"p")))); - assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); - assert!(p == Some(~"8000")); + assert_eq!(u, Some(UserInfo::new(~"us", Some(~"p")))); + assert_eq!(h, ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert_eq!(p, Some(~"8000")); // invalid authorities; assert!(get_authority("//user:pass@rust-lang:something").is_err()); @@ -780,22 +780,22 @@ fn test_get_authority() { // these parse as empty, because they don't start with '//' let (_, h, _, _) = get_authority(~"user:pass@rust-lang").unwrap(); - assert!(h == ~""); + assert_eq!(h, ~""); let (_, h, _, _) = get_authority(~"rust-lang.org").unwrap(); - assert!(h == ~""); + assert_eq!(h, ~""); } #[test] fn test_get_path() { let (p, r) = get_path("/something+%20orother", true).unwrap(); - assert!(p == ~"/something+ orother"); - assert!(r == ~""); + assert_eq!(p, ~"/something+ orother"); + assert_eq!(r, ~""); let (p, r) = get_path("test@email.com#fragment", false).unwrap(); - assert!(p == ~"test@email.com"); - assert!(r == ~"#fragment"); + assert_eq!(p, ~"test@email.com"); + assert_eq!(r, ~"#fragment"); let (p, r) = get_path(~"/gen/:addr=?q=v", false).unwrap(); - assert!(p == ~"/gen/:addr="); - assert!(r == ~"?q=v"); + assert_eq!(p, ~"/gen/:addr="); + assert_eq!(r, ~"?q=v"); //failure cases assert!(get_path(~"something?q", true).is_err()); @@ -860,56 +860,56 @@ mod tests { #[test] fn test_full_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?s=v#something"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_userless_url_parse_and_format() { let url = ~"http://rust-lang.org/doc?s=v#something"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_queryless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc#something"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_empty_query_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?#something"; let should_be = ~"http://user:pass@rust-lang.org/doc#something"; - assert!(from_str(url).unwrap().to_str() == should_be); + assert_eq!(from_str(url).unwrap().to_str(), should_be); } #[test] fn test_fragmentless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?q=v"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_minimal_url_parse_and_format() { let url = ~"http://rust-lang.org/doc"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_scheme_host_only_url_parse_and_format() { let url = ~"http://rust-lang.org"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_pathless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org?q=v#something"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_scheme_host_fragment_only_url_parse_and_format() { let url = ~"http://rust-lang.org#something"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] @@ -923,134 +923,134 @@ mod tests { #[test] fn test_url_without_authority() { let url = ~"mailto:test@email.com"; - assert!(from_str(url).unwrap().to_str() == url); + assert_eq!(from_str(url).unwrap().to_str(), url); } #[test] fn test_encode() { - assert!(encode("") == ~""); - assert!(encode("http://example.com") == ~"http://example.com"); - assert!(encode("foo bar% baz") == ~"foo%20bar%25%20baz"); - assert!(encode(" ") == ~"%20"); - assert!(encode("!") == ~"!"); - assert!(encode("\"") == ~"\""); - assert!(encode("#") == ~"#"); - assert!(encode("$") == ~"$"); - assert!(encode("%") == ~"%25"); - assert!(encode("&") == ~"&"); - assert!(encode("'") == ~"%27"); - assert!(encode("(") == ~"("); - assert!(encode(")") == ~")"); - assert!(encode("*") == ~"*"); - assert!(encode("+") == ~"+"); - assert!(encode(",") == ~","); - assert!(encode("/") == ~"/"); - assert!(encode(":") == ~":"); - assert!(encode(";") == ~";"); - assert!(encode("=") == ~"="); - assert!(encode("?") == ~"?"); - assert!(encode("@") == ~"@"); - assert!(encode("[") == ~"["); - assert!(encode("]") == ~"]"); + assert_eq!(encode(""), ~""); + assert_eq!(encode("http://example.com"), ~"http://example.com"); + assert_eq!(encode("foo bar% baz"), ~"foo%20bar%25%20baz"); + assert_eq!(encode(" "), ~"%20"); + assert_eq!(encode("!"), ~"!"); + assert_eq!(encode("\""), ~"\""); + assert_eq!(encode("#"), ~"#"); + assert_eq!(encode("$"), ~"$"); + assert_eq!(encode("%"), ~"%25"); + assert_eq!(encode("&"), ~"&"); + assert_eq!(encode("'"), ~"%27"); + assert_eq!(encode("("), ~"("); + assert_eq!(encode(")"), ~")"); + assert_eq!(encode("*"), ~"*"); + assert_eq!(encode("+"), ~"+"); + assert_eq!(encode(","), ~","); + assert_eq!(encode("/"), ~"/"); + assert_eq!(encode(":"), ~":"); + assert_eq!(encode(";"), ~";"); + assert_eq!(encode("="), ~"="); + assert_eq!(encode("?"), ~"?"); + assert_eq!(encode("@"), ~"@"); + assert_eq!(encode("["), ~"["); + assert_eq!(encode("]"), ~"]"); } #[test] fn test_encode_component() { - assert!(encode_component("") == ~""); + assert_eq!(encode_component(""), ~""); assert!(encode_component("http://example.com") == ~"http%3A%2F%2Fexample.com"); assert!(encode_component("foo bar% baz") == ~"foo%20bar%25%20baz"); - assert!(encode_component(" ") == ~"%20"); - assert!(encode_component("!") == ~"%21"); - assert!(encode_component("#") == ~"%23"); - assert!(encode_component("$") == ~"%24"); - assert!(encode_component("%") == ~"%25"); - assert!(encode_component("&") == ~"%26"); - assert!(encode_component("'") == ~"%27"); - assert!(encode_component("(") == ~"%28"); - assert!(encode_component(")") == ~"%29"); - assert!(encode_component("*") == ~"%2A"); - assert!(encode_component("+") == ~"%2B"); - assert!(encode_component(",") == ~"%2C"); - assert!(encode_component("/") == ~"%2F"); - assert!(encode_component(":") == ~"%3A"); - assert!(encode_component(";") == ~"%3B"); - assert!(encode_component("=") == ~"%3D"); - assert!(encode_component("?") == ~"%3F"); - assert!(encode_component("@") == ~"%40"); - assert!(encode_component("[") == ~"%5B"); - assert!(encode_component("]") == ~"%5D"); + assert_eq!(encode_component(" "), ~"%20"); + assert_eq!(encode_component("!"), ~"%21"); + assert_eq!(encode_component("#"), ~"%23"); + assert_eq!(encode_component("$"), ~"%24"); + assert_eq!(encode_component("%"), ~"%25"); + assert_eq!(encode_component("&"), ~"%26"); + assert_eq!(encode_component("'"), ~"%27"); + assert_eq!(encode_component("("), ~"%28"); + assert_eq!(encode_component(")"), ~"%29"); + assert_eq!(encode_component("*"), ~"%2A"); + assert_eq!(encode_component("+"), ~"%2B"); + assert_eq!(encode_component(","), ~"%2C"); + assert_eq!(encode_component("/"), ~"%2F"); + assert_eq!(encode_component(":"), ~"%3A"); + assert_eq!(encode_component(";"), ~"%3B"); + assert_eq!(encode_component("="), ~"%3D"); + assert_eq!(encode_component("?"), ~"%3F"); + assert_eq!(encode_component("@"), ~"%40"); + assert_eq!(encode_component("["), ~"%5B"); + assert_eq!(encode_component("]"), ~"%5D"); } #[test] fn test_decode() { - assert!(decode("") == ~""); - assert!(decode("abc/def 123") == ~"abc/def 123"); - assert!(decode("abc%2Fdef%20123") == ~"abc%2Fdef 123"); - assert!(decode("%20") == ~" "); - assert!(decode("%21") == ~"%21"); - assert!(decode("%22") == ~"%22"); - assert!(decode("%23") == ~"%23"); - assert!(decode("%24") == ~"%24"); - assert!(decode("%25") == ~"%"); - assert!(decode("%26") == ~"%26"); - assert!(decode("%27") == ~"'"); - assert!(decode("%28") == ~"%28"); - assert!(decode("%29") == ~"%29"); - assert!(decode("%2A") == ~"%2A"); - assert!(decode("%2B") == ~"%2B"); - assert!(decode("%2C") == ~"%2C"); - assert!(decode("%2F") == ~"%2F"); - assert!(decode("%3A") == ~"%3A"); - assert!(decode("%3B") == ~"%3B"); - assert!(decode("%3D") == ~"%3D"); - assert!(decode("%3F") == ~"%3F"); - assert!(decode("%40") == ~"%40"); - assert!(decode("%5B") == ~"%5B"); - assert!(decode("%5D") == ~"%5D"); + assert_eq!(decode(""), ~""); + assert_eq!(decode("abc/def 123"), ~"abc/def 123"); + assert_eq!(decode("abc%2Fdef%20123"), ~"abc%2Fdef 123"); + assert_eq!(decode("%20"), ~" "); + assert_eq!(decode("%21"), ~"%21"); + assert_eq!(decode("%22"), ~"%22"); + assert_eq!(decode("%23"), ~"%23"); + assert_eq!(decode("%24"), ~"%24"); + assert_eq!(decode("%25"), ~"%"); + assert_eq!(decode("%26"), ~"%26"); + assert_eq!(decode("%27"), ~"'"); + assert_eq!(decode("%28"), ~"%28"); + assert_eq!(decode("%29"), ~"%29"); + assert_eq!(decode("%2A"), ~"%2A"); + assert_eq!(decode("%2B"), ~"%2B"); + assert_eq!(decode("%2C"), ~"%2C"); + assert_eq!(decode("%2F"), ~"%2F"); + assert_eq!(decode("%3A"), ~"%3A"); + assert_eq!(decode("%3B"), ~"%3B"); + assert_eq!(decode("%3D"), ~"%3D"); + assert_eq!(decode("%3F"), ~"%3F"); + assert_eq!(decode("%40"), ~"%40"); + assert_eq!(decode("%5B"), ~"%5B"); + assert_eq!(decode("%5D"), ~"%5D"); } #[test] fn test_decode_component() { - assert!(decode_component("") == ~""); - assert!(decode_component("abc/def 123") == ~"abc/def 123"); - assert!(decode_component("abc%2Fdef%20123") == ~"abc/def 123"); - assert!(decode_component("%20") == ~" "); - assert!(decode_component("%21") == ~"!"); - assert!(decode_component("%22") == ~"\""); - assert!(decode_component("%23") == ~"#"); - assert!(decode_component("%24") == ~"$"); - assert!(decode_component("%25") == ~"%"); - assert!(decode_component("%26") == ~"&"); - assert!(decode_component("%27") == ~"'"); - assert!(decode_component("%28") == ~"("); - assert!(decode_component("%29") == ~")"); - assert!(decode_component("%2A") == ~"*"); - assert!(decode_component("%2B") == ~"+"); - assert!(decode_component("%2C") == ~","); - assert!(decode_component("%2F") == ~"/"); - assert!(decode_component("%3A") == ~":"); - assert!(decode_component("%3B") == ~";"); - assert!(decode_component("%3D") == ~"="); - assert!(decode_component("%3F") == ~"?"); - assert!(decode_component("%40") == ~"@"); - assert!(decode_component("%5B") == ~"["); - assert!(decode_component("%5D") == ~"]"); + assert_eq!(decode_component(""), ~""); + assert_eq!(decode_component("abc/def 123"), ~"abc/def 123"); + assert_eq!(decode_component("abc%2Fdef%20123"), ~"abc/def 123"); + assert_eq!(decode_component("%20"), ~" "); + assert_eq!(decode_component("%21"), ~"!"); + assert_eq!(decode_component("%22"), ~"\""); + assert_eq!(decode_component("%23"), ~"#"); + assert_eq!(decode_component("%24"), ~"$"); + assert_eq!(decode_component("%25"), ~"%"); + assert_eq!(decode_component("%26"), ~"&"); + assert_eq!(decode_component("%27"), ~"'"); + assert_eq!(decode_component("%28"), ~"("); + assert_eq!(decode_component("%29"), ~")"); + assert_eq!(decode_component("%2A"), ~"*"); + assert_eq!(decode_component("%2B"), ~"+"); + assert_eq!(decode_component("%2C"), ~","); + assert_eq!(decode_component("%2F"), ~"/"); + assert_eq!(decode_component("%3A"), ~":"); + assert_eq!(decode_component("%3B"), ~";"); + assert_eq!(decode_component("%3D"), ~"="); + assert_eq!(decode_component("%3F"), ~"?"); + assert_eq!(decode_component("%40"), ~"@"); + assert_eq!(decode_component("%5B"), ~"["); + assert_eq!(decode_component("%5D"), ~"]"); } #[test] fn test_encode_form_urlencoded() { let mut m = HashMap::new(); - assert!(encode_form_urlencoded(&m) == ~""); + assert_eq!(encode_form_urlencoded(&m), ~""); m.insert(~"", ~[]); m.insert(~"foo", ~[]); - assert!(encode_form_urlencoded(&m) == ~""); + assert_eq!(encode_form_urlencoded(&m), ~""); let mut m = HashMap::new(); m.insert(~"foo", ~[~"bar", ~"123"]); - assert!(encode_form_urlencoded(&m) == ~"foo=bar&foo=123"); + assert_eq!(encode_form_urlencoded(&m), ~"foo=bar&foo=123"); let mut m = HashMap::new(); m.insert(~"foo bar", ~[~"abc", ~"12 = 34"]); @@ -1063,13 +1063,13 @@ mod tests { // FIXME #4449: Commented out because this causes an ICE, but only // on FreeBSD /* - assert!(decode_form_urlencoded(~[]).len() == 0); + assert_eq!(decode_form_urlencoded(~[]).len(), 0); let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34"); let form = decode_form_urlencoded(s); - assert!(form.len() == 2); - assert!(form.get_ref(&~"a") == &~[~"1"]); - assert!(form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"]); + assert_eq!(form.len(), 2); + assert_eq!(form.get_ref(&~"a"), &~[~"1"]); + assert_eq!(form.get_ref(&~"foo bar"), &~[~"abc", ~"12 = 34"]); */ } } diff --git a/src/libstd/num/bigint.rs b/src/libstd/num/bigint.rs index c35415c5331..21685b03c07 100644 --- a/src/libstd/num/bigint.rs +++ b/src/libstd/num/bigint.rs @@ -238,7 +238,7 @@ impl Sub<BigUint, BigUint> for BigUint { lo }; - assert!(borrow == 0); // <=> assert!((self >= other)); + assert_eq!(borrow, 0); // <=> assert!((self >= other)); return BigUint::new(diff); } } @@ -1170,7 +1170,7 @@ mod biguint_tests { if i == j { assert_eq!(ni.cmp(nj), Equal); assert_eq!(nj.cmp(ni), Equal); - assert!(ni == nj); + assert_eq!(ni, nj); assert!(!(ni != nj)); assert!(ni <= nj); assert!(ni >= nj); @@ -1200,7 +1200,7 @@ mod biguint_tests { #[test] fn test_shl() { fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) { - assert!(BigUint::new(v) << shift == BigUint::new(ans)); + assert_eq!(BigUint::new(v) << shift, BigUint::new(ans)); } check(~[], 3, ~[]); @@ -1245,7 +1245,7 @@ mod biguint_tests { #[ignore(cfg(target_arch = "mips"))] fn test_shr() { fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) { - assert!(BigUint::new(v) >> shift == BigUint::new(ans)); + assert_eq!(BigUint::new(v) >> shift, BigUint::new(ans)); } check(~[], 3, ~[]); @@ -1298,9 +1298,9 @@ mod biguint_tests { check(~[ 0, 1], ((uint::max_value >> BigDigit::bits) + 1) as int); check(~[-1, -1 >> 1], int::max_value); - assert!(BigUint::new(~[0, -1]).to_int() == int::max_value); - assert!(BigUint::new(~[0, 0, 1]).to_int() == int::max_value); - assert!(BigUint::new(~[0, 0, -1]).to_int() == int::max_value); + assert_eq!(BigUint::new(~[0, -1]).to_int(), int::max_value); + assert_eq!(BigUint::new(~[0, 0, 1]).to_int(), int::max_value); + assert_eq!(BigUint::new(~[0, 0, -1]).to_int(), int::max_value); } #[test] @@ -1318,8 +1318,8 @@ mod biguint_tests { check(~[ 0, -1], uint::max_value << BigDigit::bits); check(~[-1, -1], uint::max_value); - assert!(BigUint::new(~[0, 0, 1]).to_uint() == uint::max_value); - assert!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value); + assert_eq!(BigUint::new(~[0, 0, 1]).to_uint(), uint::max_value); + assert_eq!(BigUint::new(~[0, 0, -1]).to_uint(), uint::max_value); } static sum_triples: &'static [(&'static [BigDigit], @@ -1433,10 +1433,10 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); if !a.is_zero() { - assert!(c.div_rem(&a) == (b.clone(), Zero::zero())); + assert_eq!(c.div_rem(&a), (b.clone(), Zero::zero())); } if !b.is_zero() { - assert!(c.div_rem(&b) == (a.clone(), Zero::zero())); + assert_eq!(c.div_rem(&b), (a.clone(), Zero::zero())); } } @@ -1560,7 +1560,7 @@ mod biguint_tests { let &(n, rs) = num_pair; for rs.each |str_pair| { let &(radix, str) = str_pair; - assert!(n.to_str_radix(radix) == str); + assert_eq!(n.to_str_radix(radix), str); } } } @@ -1597,7 +1597,7 @@ mod biguint_tests { let ans = match FromStrRadix::from_str_radix(s, 10) { Some(x) => x, None => fail!() }; - assert!(n == ans); + assert_eq!(n, ans); } check(3, "6"); @@ -1618,7 +1618,7 @@ mod bigint_tests { fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) { let inp = BigInt::from_biguint(inp_s, BigUint::from_uint(inp_n)); let ans = BigInt { sign: ans_s, data: BigUint::from_uint(ans_n)}; - assert!(inp == ans); + assert_eq!(inp, ans); } check(Plus, 1, Plus, 1); check(Plus, 0, Zero, 0); @@ -1640,7 +1640,7 @@ mod bigint_tests { if i == j { assert_eq!(ni.cmp(nj), Equal); assert_eq!(nj.cmp(ni), Equal); - assert!(ni == nj); + assert_eq!(ni, nj); assert!(!(ni != nj)); assert!(ni <= nj); assert!(ni >= nj); @@ -1751,7 +1751,7 @@ mod bigint_tests { assert!(c + (-b) == a); assert!(a + (-c) == (-b)); assert!(b + (-c) == (-a)); - assert!((-a) + (-b) == (-c)); + assert!((-a) + (-b) == (-c)) assert!(a + (-a) == Zero::zero()); } } @@ -1766,8 +1766,8 @@ mod bigint_tests { assert!(c - a == b); assert!(c - b == a); - assert!((-b) - a == (-c)); - assert!((-a) - b == (-c)); + assert!((-b) - a == (-c)) + assert!((-a) - b == (-c)) assert!(b - (-a) == c); assert!(a - (-b) == c); assert!((-c) - (-a) == (-b)); @@ -1845,7 +1845,7 @@ mod bigint_tests { fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) { let (d, m) = a.div_mod_floor(b); if !m.is_zero() { - assert!(m.sign == b.sign); + assert_eq!(m.sign, b.sign); } assert!(m.abs() <= b.abs()); assert!(*a == b * d + m); @@ -1896,7 +1896,7 @@ mod bigint_tests { fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) { let (q, r) = a.div_rem(b); if !r.is_zero() { - assert!(r.sign == a.sign); + assert_eq!(r.sign, a.sign); } assert!(r.abs() <= b.abs()); assert!(*a == b * q + r); @@ -1999,7 +1999,7 @@ mod bigint_tests { fn test_from_str_radix() { fn check(s: &str, ans: Option<int>) { let ans = ans.map(|&n| IntConvertible::from_int::<BigInt>(n)); - assert!(FromStrRadix::from_str_radix(s, 10) == ans); + assert_eq!(FromStrRadix::from_str_radix(s, 10), ans); } check("10", Some(10)); check("1", Some(1)); @@ -2016,6 +2016,6 @@ mod bigint_tests { BigInt::new(Minus, ~[1, 1, 1])); assert!(-BigInt::new(Minus, ~[1, 1, 1]) == BigInt::new(Plus, ~[1, 1, 1])); - assert!(-Zero::zero::<BigInt>() == Zero::zero::<BigInt>()); + assert_eq!(-Zero::zero::<BigInt>(), Zero::zero::<BigInt>()); } } diff --git a/src/libstd/par.rs b/src/libstd/par.rs index d1af484cb22..e766d2d3bf0 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -59,7 +59,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>( let slice : &[A] = cast::transmute(slice); info!("slice: %?", (base, slice.len(), end - base)); - assert!(slice.len() == end - base); + assert_eq!(slice.len(), end - base); f(base, slice) } }; @@ -70,7 +70,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>( info!("tasks spawned"); info!("num_tasks: %?", (num_tasks, futures.len())); - assert!((num_tasks == futures.len())); + assert_eq!(num_tasks, futures.len()); let r = do vec::map_consume(futures) |ys| { let mut ys = ys; @@ -106,7 +106,7 @@ pub fn mapi<A:Copy + Owned,B:Copy + Owned>( }); let r = vec::concat(slices); info!("%?", (r.len(), xs.len())); - assert!((r.len() == xs.len())); + assert_eq!(r.len(), xs.len()); r } diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs index 3c96a8e145d..b54fc81aac1 100644 --- a/src/libstd/priority_queue.rs +++ b/src/libstd/priority_queue.rs @@ -196,87 +196,87 @@ mod tests { let mut sorted = merge_sort(data, le); let mut heap = from_vec(data); while !heap.is_empty() { - assert!(heap.top() == sorted.last()); - assert!(heap.pop() == sorted.pop()); + assert_eq!(heap.top(), sorted.last()); + assert_eq!(heap.pop(), sorted.pop()); } } #[test] fn test_push() { let mut heap = from_vec(~[2, 4, 9]); - assert!(heap.len() == 3); + assert_eq!(heap.len(), 3); assert!(*heap.top() == 9); heap.push(11); - assert!(heap.len() == 4); + assert_eq!(heap.len(), 4); assert!(*heap.top() == 11); heap.push(5); - assert!(heap.len() == 5); + assert_eq!(heap.len(), 5); assert!(*heap.top() == 11); heap.push(27); - assert!(heap.len() == 6); + assert_eq!(heap.len(), 6); assert!(*heap.top() == 27); heap.push(3); - assert!(heap.len() == 7); + assert_eq!(heap.len(), 7); assert!(*heap.top() == 27); heap.push(103); - assert!(heap.len() == 8); + assert_eq!(heap.len(), 8); assert!(*heap.top() == 103); } #[test] fn test_push_unique() { let mut heap = from_vec(~[~2, ~4, ~9]); - assert!(heap.len() == 3); + assert_eq!(heap.len(), 3); assert!(*heap.top() == ~9); heap.push(~11); - assert!(heap.len() == 4); + assert_eq!(heap.len(), 4); assert!(*heap.top() == ~11); heap.push(~5); - assert!(heap.len() == 5); + assert_eq!(heap.len(), 5); assert!(*heap.top() == ~11); heap.push(~27); - assert!(heap.len() == 6); + assert_eq!(heap.len(), 6); assert!(*heap.top() == ~27); heap.push(~3); - assert!(heap.len() == 7); + assert_eq!(heap.len(), 7); assert!(*heap.top() == ~27); heap.push(~103); - assert!(heap.len() == 8); + assert_eq!(heap.len(), 8); assert!(*heap.top() == ~103); } #[test] fn test_push_pop() { let mut heap = from_vec(~[5, 5, 2, 1, 3]); - assert!(heap.len() == 5); - assert!(heap.push_pop(6) == 6); - assert!(heap.len() == 5); - assert!(heap.push_pop(0) == 5); - assert!(heap.len() == 5); - assert!(heap.push_pop(4) == 5); - assert!(heap.len() == 5); - assert!(heap.push_pop(1) == 4); - assert!(heap.len() == 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.push_pop(6), 6); + assert_eq!(heap.len(), 5); + assert_eq!(heap.push_pop(0), 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.push_pop(4), 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.push_pop(1), 4); + assert_eq!(heap.len(), 5); } #[test] fn test_replace() { let mut heap = from_vec(~[5, 5, 2, 1, 3]); - assert!(heap.len() == 5); - assert!(heap.replace(6) == 5); - assert!(heap.len() == 5); - assert!(heap.replace(0) == 6); - assert!(heap.len() == 5); - assert!(heap.replace(4) == 5); - assert!(heap.len() == 5); - assert!(heap.replace(1) == 4); - assert!(heap.len() == 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.replace(6), 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.replace(0), 6); + assert_eq!(heap.len(), 5); + assert_eq!(heap.replace(4), 5); + assert_eq!(heap.len(), 5); + assert_eq!(heap.replace(1), 4); + assert_eq!(heap.len(), 5); } fn check_to_vec(data: ~[int]) { let heap = from_vec(copy data); - assert!(merge_sort((copy heap).to_vec(), le) == merge_sort(data, le)); - assert!(heap.to_sorted_vec() == merge_sort(data, le)); + assert_eq!(merge_sort((copy heap).to_vec(), le), merge_sort(data, le)); + assert_eq!(heap.to_sorted_vec(), merge_sort(data, le)); } #[test] diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs index 46f50eafec1..cc1492ba448 100644 --- a/src/libstd/rc.rs +++ b/src/libstd/rc.rs @@ -218,7 +218,7 @@ pub impl<T> RcMut<T> { #[inline] fn with_mut_borrow<U>(&self, f: &fn(&mut T) -> U) -> U { unsafe { - assert!((*self.ptr).borrow == Nothing); + assert_eq!((*self.ptr).borrow, Nothing); (*self.ptr).borrow = Mutable; let res = f(&mut (*self.ptr).value); (*self.ptr).borrow = Nothing; diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 9afa7262ce4..925f79b66c9 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -1281,8 +1281,8 @@ mod tests { #[test] fn trivial() { - assert!(char_len(empty()) == 0u); - assert!(byte_len(empty()) == 0u); + assert_eq!(char_len(empty()), 0u); + assert_eq!(byte_len(empty()), 0u); } #[test] @@ -1290,7 +1290,7 @@ mod tests { let sample = @~"0123456789ABCDE"; let r = of_str(sample); - assert!(char_len(r) == str::char_len(*sample)); + assert_eq!(char_len(r), str::char_len(*sample)); assert!(rope_to_string(r) == *sample); } @@ -1352,7 +1352,7 @@ mod tests { } } - assert!(len == str::char_len(*sample)); + assert_eq!(len, str::char_len(*sample)); } #[test] @@ -1375,7 +1375,7 @@ mod tests { assert!(eq(r1, r2)); let r3 = bal(r2); - assert!(char_len(r1) == char_len(r3)); + assert_eq!(char_len(r1), char_len(r3)); assert!(eq(r1, r3)); } diff --git a/src/libstd/semver.rs b/src/libstd/semver.rs index f6d1b1ba2ec..09855c9334e 100644 --- a/src/libstd/semver.rs +++ b/src/libstd/semver.rs @@ -239,16 +239,16 @@ pub fn parse(s: &str) -> Option<Version> { #[test] fn test_parse() { - assert!(parse("") == None); - assert!(parse(" ") == None); - assert!(parse("1") == None); - assert!(parse("1.2") == None); - assert!(parse("1.2") == None); - assert!(parse("1") == None); - assert!(parse("1.2") == None); - assert!(parse("1.2.3-") == None); - assert!(parse("a.b.c") == None); - assert!(parse("1.2.3 abc") == None); + assert_eq!(parse(""), None); + assert_eq!(parse(" "), None); + assert_eq!(parse("1"), None); + assert_eq!(parse("1.2"), None); + assert_eq!(parse("1.2"), None); + assert_eq!(parse("1"), None); + assert_eq!(parse("1.2"), None); + assert_eq!(parse("1.2.3-"), None); + assert_eq!(parse("a.b.c"), None); + assert_eq!(parse("1.2.3 abc"), None); assert!(parse("1.2.3") == Some(Version { major: 1u, @@ -320,8 +320,8 @@ fn test_parse() { #[test] fn test_eq() { - assert!(parse("1.2.3") == parse("1.2.3")); - assert!(parse("1.2.3-alpha1") == parse("1.2.3-alpha1")); + assert_eq!(parse("1.2.3"), parse("1.2.3")); + assert_eq!(parse("1.2.3-alpha1"), parse("1.2.3-alpha1")); } #[test] diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index a5d2604b6f6..c270f46751f 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -500,7 +500,7 @@ impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S> for (T0, T1) { impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D> for (T0, T1) { fn decode(d: &mut D) -> (T0, T1) { do d.read_seq |d, len| { - assert!(len == 2); + assert_eq!(len, 2); ( d.read_seq_elt(0, |d| Decodable::decode(d)), d.read_seq_elt(1, |d| Decodable::decode(d)) @@ -536,7 +536,7 @@ impl< > Decodable<D> for (T0, T1, T2) { fn decode(d: &mut D) -> (T0, T1, T2) { do d.read_seq |d, len| { - assert!(len == 3); + assert_eq!(len, 3); ( d.read_seq_elt(0, |d| Decodable::decode(d)), d.read_seq_elt(1, |d| Decodable::decode(d)), @@ -576,7 +576,7 @@ impl< > Decodable<D> for (T0, T1, T2, T3) { fn decode(d: &mut D) -> (T0, T1, T2, T3) { do d.read_seq |d, len| { - assert!(len == 4); + assert_eq!(len, 4); ( d.read_seq_elt(0, |d| Decodable::decode(d)), d.read_seq_elt(1, |d| Decodable::decode(d)), @@ -620,7 +620,7 @@ impl< > Decodable<D> for (T0, T1, T2, T3, T4) { fn decode(d: &mut D) -> (T0, T1, T2, T3, T4) { do d.read_seq |d, len| { - assert!(len == 5); + assert_eq!(len, 5); ( d.read_seq_elt(0, |d| Decodable::decode(d)), d.read_seq_elt(1, |d| Decodable::decode(d)), diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index 6d8bf20d837..bb3be8a55ea 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -90,8 +90,8 @@ pub fn sha1() -> @Sha1 { } } fn process_msg_block(st: &mut Sha1State) { - assert!(st.h.len() == digest_buf_len); - assert!(vec::uniq_len(st.work_buf) == work_buf_len); + assert_eq!(st.h.len(), digest_buf_len); + assert_eq!(vec::uniq_len(st.work_buf), work_buf_len); let mut t: int; // Loop counter let w = st.work_buf; @@ -192,7 +192,7 @@ pub fn sha1() -> @Sha1 { * can be assumed that the message digest has been computed. */ fn pad_msg(st: &mut Sha1State) { - assert!((vec::len((*st).msg_block) == msg_block_len)); + assert_eq!(vec::len((*st).msg_block), msg_block_len); /* * Check to see if the current message block is too small to hold @@ -230,7 +230,7 @@ pub fn sha1() -> @Sha1 { impl Sha1 for Sha1State { fn reset(&mut self) { - assert!(self.h.len() == digest_buf_len); + assert_eq!(self.h.len(), digest_buf_len); self.len_low = 0u32; self.len_high = 0u32; self.msg_block_idx = 0u; @@ -365,13 +365,13 @@ mod tests { ]; let tests = fips_180_1_tests + wikipedia_tests; fn check_vec_eq(v0: ~[u8], v1: ~[u8]) { - assert!((vec::len::<u8>(v0) == vec::len::<u8>(v1))); + assert_eq!(vec::len::<u8>(v0), vec::len::<u8>(v1)); let len = vec::len::<u8>(v0); let mut i = 0u; while i < len { let a = v0[i]; let b = v1[i]; - assert!((a == b)); + assert_eq!(a, b); i += 1u; } } @@ -384,8 +384,8 @@ mod tests { check_vec_eq(copy t.output, out); let out_str = sh.result_str(); - assert!((out_str.len() == 40)); - assert!((out_str == t.output_str)); + assert_eq!(out_str.len(), 40); + assert!(out_str == t.output_str); sh.reset(); } @@ -405,8 +405,8 @@ mod tests { check_vec_eq(copy t.output, out); let out_str = sh.result_str(); - assert!((out_str.len() == 40)); - assert!((out_str == t.output_str)); + assert_eq!(out_str.len(), 40); + assert!(out_str == t.output_str); sh.reset(); } diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index afc1d0fe65f..a336bd54a61 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -249,16 +249,16 @@ mod tests { #[test] fn test_len() { let mut map = SmallIntMap::new(); - assert!(map.len() == 0); + assert_eq!(map.len(), 0); assert!(map.is_empty()); assert!(map.insert(5, 20)); - assert!(map.len() == 1); + assert_eq!(map.len(), 1); assert!(!map.is_empty()); assert!(map.insert(11, 12)); - assert!(map.len() == 2); + assert_eq!(map.len(), 2); assert!(!map.is_empty()); assert!(map.insert(14, 22)); - assert!(map.len() == 3); + assert_eq!(map.len(), 3); assert!(!map.is_empty()); } @@ -297,9 +297,9 @@ mod tests { map.update_with_key(3, 2, addMoreToCount); // check the total counts - assert!(map.find(&3).get() == &10); - assert!(map.find(&5).get() == &3); - assert!(map.find(&9).get() == &1); + assert_eq!(map.find(&3).get(), &10); + assert_eq!(map.find(&5).get(), &3); + assert_eq!(map.find(&9).get(), &1); // sadly, no sevens were counted assert!(map.find(&7).is_none()); @@ -308,16 +308,16 @@ mod tests { #[test] fn test_swap() { let mut m = SmallIntMap::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 = SmallIntMap::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); } } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 0d94a1830a6..ca752a48298 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -261,7 +261,7 @@ fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) { left = mid+1; } } - assert!(left == right); + assert_eq!(left, right); let n = start-left; shift_vec(array, left+1, left, n); @@ -357,7 +357,7 @@ fn gallop_left<T:Copy + Ord>(key: &T, ofs = m; } } - assert!(last_ofs == ofs); + assert_eq!(last_ofs, ofs); return ofs; } @@ -410,7 +410,7 @@ fn gallop_right<T:Copy + Ord>(key: &T, ofs = m; } } - assert!(last_ofs == ofs); + assert_eq!(last_ofs, ofs); return ofs; } @@ -449,7 +449,7 @@ impl<T:Copy + Ord> MergeState<T> { let l2 = self.runs[n+1].len; assert!(l1 > 0 && l2 > 0); - assert!(b1 + l1 == b2); + assert_eq!(b1 + l1, b2); self.runs[n].len = l1 + l2; if n == size-3 { @@ -583,7 +583,7 @@ impl<T:Copy + Ord> MergeState<T> { } else if len1 == 0 { fail!("Comparison violates its contract!"); } else { - assert!(len2 == 0); + assert_eq!(len2, 0); assert!(len1 > 1); copy_vec(array, dest, tmp.slice(c1, c1+len1)); } @@ -705,7 +705,7 @@ impl<T:Copy + Ord> MergeState<T> { } else if len2 == 0 { fail!("Comparison violates its contract!"); } else { - assert!(len1 == 0); + assert_eq!(len1, 0); assert!(len2 != 0); copy_vec(array, dest-(len2-1), tmp.slice(0, len2)); } @@ -818,7 +818,7 @@ mod test_qsort { let mut i = 0u; while i < len { // debug!(v2[i]); - assert!((v2[i] == v1[i])); + assert_eq!(v2[i], v1[i]); i += 1; } } @@ -863,7 +863,7 @@ mod test_qsort { for pairs.each |p| { let (a, b) = *p; debug!("%d %d", a, b); - assert!((a == b)); + assert_eq!(a, b); } } } @@ -883,7 +883,7 @@ mod tests { let mut i = 0u; while i < len { debug!(v3[i]); - assert!((v3[i] == v2[i])); + assert_eq!(v3[i], v2[i]); i += 1; } } @@ -910,7 +910,7 @@ mod tests { pub fn le(a: &int, b: &int) -> bool { *a <= *b } let mut v1 = ~[3, 2, 1]; let v2 = merge_sort(v1, le); - assert!(v2 == ~[1, 2, 3]); + assert_eq!(v2, ~[1, 2, 3]); } #[test] @@ -932,7 +932,7 @@ mod tests { let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob", "JOE Bob", "JOE BOB", "Sally Mae"]; let names3 = merge_sort(names1, ile); - assert!(names3 == names2); + assert_eq!(names3, names2); } } @@ -964,7 +964,7 @@ mod test_tim_sort { let mut i = 0u; while i < len { // debug!(v2[i]); - assert!((v2[i] == v1[i])); + assert_eq!(v2[i], v1[i]); i += 1u; } } diff --git a/src/libstd/sort_stage0.rs b/src/libstd/sort_stage0.rs index 270f7196d29..cdef8e220ce 100644 --- a/src/libstd/sort_stage0.rs +++ b/src/libstd/sort_stage0.rs @@ -261,7 +261,7 @@ fn binarysort<T:Copy + Ord>(array: &mut [T], start: uint) { left = mid+1; } } - assert!(left == right); + assert_eq!(left, right); let n = start-left; copy_vec(array, left+1, array, left, n); @@ -357,7 +357,7 @@ fn gallop_left<T:Copy + Ord>(key: &const T, ofs = m; } } - assert!(last_ofs == ofs); + assert_eq!(last_ofs, ofs); return ofs; } @@ -410,7 +410,7 @@ fn gallop_right<T:Copy + Ord>(key: &const T, ofs = m; } } - assert!(last_ofs == ofs); + assert_eq!(last_ofs, ofs); return ofs; } @@ -449,7 +449,7 @@ impl<T:Copy + Ord> MergeState<T> { let l2 = self.runs[n+1].len; assert!(l1 > 0 && l2 > 0); - assert!(b1 + l1 == b2); + assert_eq!(b1 + l1, b2); self.runs[n].len = l1 + l2; if n == size-3 { @@ -579,7 +579,7 @@ impl<T:Copy + Ord> MergeState<T> { } else if len1 == 0 { fail!("Comparison violates its contract!"); } else { - assert!(len2 == 0); + assert_eq!(len2, 0); assert!(len1 > 1); copy_vec(array, dest, tmp, c1, len1); } @@ -587,7 +587,7 @@ impl<T:Copy + Ord> MergeState<T> { fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint, base2: uint, len2: uint) { - assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2); + assert!(len1 != 1 && len2 != 0 && base1+len1 == base2); let mut tmp = ~[]; for uint::range(base2, base2+len2) |i| { @@ -701,7 +701,7 @@ impl<T:Copy + Ord> MergeState<T> { } else if len2 == 0 { fail!("Comparison violates its contract!"); } else { - assert!(len1 == 0); + assert_eq!(len1, 0); assert!(len2 != 0); copy_vec(array, dest-(len2-1), tmp, 0, len2); } @@ -766,7 +766,7 @@ mod test_qsort3 { let mut i = 0; while i < len { // debug!(v2[i]); - assert!((v2[i] == v1[i])); + assert_eq!(v2[i], v1[i]); i += 1; } } @@ -811,7 +811,7 @@ mod test_qsort { let mut i = 0u; while i < len { // debug!(v2[i]); - assert!((v2[i] == v1[i])); + assert_eq!(v2[i], v1[i]); i += 1; } } @@ -856,7 +856,7 @@ mod test_qsort { for pairs.each |p| { let (a, b) = *p; debug!("%d %d", a, b); - assert!((a == b)); + assert_eq!(a, b); } } } @@ -876,7 +876,7 @@ mod tests { let mut i = 0u; while i < len { debug!(v3[i]); - assert!((v3[i] == v2[i])); + assert_eq!(v3[i], v2[i]); i += 1; } } @@ -903,7 +903,7 @@ mod tests { pub fn le(a: &int, b: &int) -> bool { *a <= *b } let mut v1 = ~[3, 2, 1]; let v2 = merge_sort(v1, le); - assert!(v2 == ~[1, 2, 3]); + assert_eq!(v2, ~[1, 2, 3]); } #[test] @@ -925,7 +925,7 @@ mod tests { let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob", "JOE Bob", "JOE BOB", "Sally Mae"]; let names3 = merge_sort(names1, ile); - assert!(names3 == names2); + assert_eq!(names3, names2); } } @@ -955,7 +955,7 @@ mod test_tim_sort { let mut i = 0u; while i < len { // debug!(v2[i]); - assert!((v2[i] == v1[i])); + assert_eq!(v2[i], v1[i]); i += 1u; } } diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 449edacad32..002c6b2eca3 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -839,7 +839,7 @@ mod tests { access_shared(sharedstate, m, 10); let _ = p.recv(); - assert!(*sharedstate == 20); + assert_eq!(*sharedstate, 20); } fn access_shared(sharedstate: &mut int, m: &Mutex, n: uint) { @@ -906,7 +906,7 @@ mod tests { for ports.each |port| { let _ = port.recv(); } do m.lock_cond |cond| { let num_woken = cond.broadcast(); - assert!(num_woken == num_waiters); + assert_eq!(num_woken, num_waiters); } // wait until all children wake up for ports.each |port| { let _ = port.recv(); } @@ -1006,7 +1006,7 @@ mod tests { for vec::each(p.recv()) |p| { p.recv(); } // wait on all its siblings do m.lock_cond |cond| { let woken = cond.broadcast(); - assert!(woken == 0); + assert_eq!(woken, 0); } struct SendOnFailure { c: comm::Chan<()>, @@ -1120,7 +1120,7 @@ mod tests { access_shared(sharedstate, x, mode2, 10); let _ = p.recv(); - assert!(*sharedstate == 20); + assert_eq!(*sharedstate, 20); } fn access_shared(sharedstate: &mut int, x: &RWlock, mode: RWlockMode, @@ -1273,7 +1273,7 @@ mod tests { for ports.each |port| { let _ = port.recv(); } do lock_cond(x, dg2) |cond| { let num_woken = cond.broadcast(); - assert!(num_woken == num_waiters); + assert_eq!(num_woken, num_waiters); } // wait until all children wake up for ports.each |port| { let _ = port.recv(); } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index b2f73df316d..e9fd4e9a2b8 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -804,7 +804,7 @@ mod tests { let ch = SharedChan::new(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - assert!(res == TrIgnored); + assert_eq!(res, TrIgnored); } #[test] @@ -823,7 +823,7 @@ mod tests { let ch = SharedChan::new(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - assert!(res == TrOk); + assert_eq!(res, TrOk); } #[test] @@ -841,7 +841,7 @@ mod tests { let ch = SharedChan::new(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - assert!(res == TrFailed); + assert_eq!(res, TrFailed); } #[test] @@ -901,9 +901,9 @@ mod tests { ]; let filtered = filter_tests(&opts, tests); - assert!(filtered.len() == 1); - assert!((filtered[0].desc.name.to_str() == ~"1")); - assert!((filtered[0].desc.ignore == false)); + assert_eq!(filtered.len(), 1); + assert_eq!(filtered[0].desc.name.to_str(), ~"1"); + assert!(filtered[0].desc.ignore == false); } #[test] @@ -958,7 +958,7 @@ mod tests { for pairs.each |p| { match *p { (ref a, ref b) => { - assert!((*a == b.desc.name.to_str())); + assert!(*a == b.desc.name.to_str()); } } } diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 202b96f9797..9e6a45137a4 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -952,8 +952,8 @@ mod tests { let time = ::time::Timespec::new(1234567890, 54321); let utc = at_utc(time); - assert!(utc.to_timespec() == time); - assert!(utc.to_local().to_timespec() == time); + assert_eq!(utc.to_timespec(), time); + assert_eq!(utc.to_local().to_timespec(), time); } fn test_conversions() { @@ -985,7 +985,7 @@ mod tests { assert!(tm.tm_mon == 0_i32); assert!(tm.tm_year == 0_i32); assert!(tm.tm_wday == 0_i32); - assert!(tm.tm_isdst== 0_i32); + assert!(tm.tm_isdst == 0_i32); assert!(tm.tm_gmtoff == 0_i32); assert!(tm.tm_zone == ~""); assert!(tm.tm_nsec == 0_i32); @@ -994,7 +994,7 @@ mod tests { } let format = ~"%a %b %e %T %Y"; - assert!(strptime(~"", format) == Err(~"Invalid time")); + assert_eq!(strptime(~"", format), Err(~"Invalid time")); assert!(strptime(~"Fri Feb 13 15:31:30", format) == Err(~"Invalid time")); @@ -1140,8 +1140,8 @@ mod tests { error!("test_ctime: %? %?", utc.ctime(), local.ctime()); - assert!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); - assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); + assert_eq!(utc.ctime(), ~"Fri Feb 13 23:31:30 2009"); + assert_eq!(local.ctime(), ~"Fri Feb 13 15:31:30 2009"); } fn test_strftime() { @@ -1152,53 +1152,53 @@ mod tests { let utc = at_utc(time); let local = at(time); - assert!(local.strftime(~"") == ~""); - assert!(local.strftime(~"%A") == ~"Friday"); - assert!(local.strftime(~"%a") == ~"Fri"); - assert!(local.strftime(~"%B") == ~"February"); - assert!(local.strftime(~"%b") == ~"Feb"); - assert!(local.strftime(~"%C") == ~"20"); - assert!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009"); - assert!(local.strftime(~"%D") == ~"02/13/09"); - assert!(local.strftime(~"%d") == ~"13"); - assert!(local.strftime(~"%e") == ~"13"); - assert!(local.strftime(~"%F") == ~"2009-02-13"); + assert_eq!(local.strftime(~""), ~""); + assert_eq!(local.strftime(~"%A"), ~"Friday"); + assert_eq!(local.strftime(~"%a"), ~"Fri"); + assert_eq!(local.strftime(~"%B"), ~"February"); + assert_eq!(local.strftime(~"%b"), ~"Feb"); + assert_eq!(local.strftime(~"%C"), ~"20"); + assert_eq!(local.strftime(~"%c"), ~"Fri Feb 13 15:31:30 2009"); + assert_eq!(local.strftime(~"%D"), ~"02/13/09"); + assert_eq!(local.strftime(~"%d"), ~"13"); + assert_eq!(local.strftime(~"%e"), ~"13"); + assert_eq!(local.strftime(~"%F"), ~"2009-02-13"); // assert!(local.strftime("%G") == "2009"); // assert!(local.strftime("%g") == "09"); - assert!(local.strftime(~"%H") == ~"15"); - assert!(local.strftime(~"%I") == ~"03"); - assert!(local.strftime(~"%j") == ~"044"); - assert!(local.strftime(~"%k") == ~"15"); - assert!(local.strftime(~"%l") == ~" 3"); - assert!(local.strftime(~"%M") == ~"31"); - assert!(local.strftime(~"%m") == ~"02"); - assert!(local.strftime(~"%n") == ~"\n"); - assert!(local.strftime(~"%P") == ~"pm"); - assert!(local.strftime(~"%p") == ~"PM"); - assert!(local.strftime(~"%R") == ~"15:31"); - assert!(local.strftime(~"%r") == ~"03:31:30 PM"); - assert!(local.strftime(~"%S") == ~"30"); - assert!(local.strftime(~"%s") == ~"1234567890"); - assert!(local.strftime(~"%T") == ~"15:31:30"); - assert!(local.strftime(~"%t") == ~"\t"); + assert_eq!(local.strftime(~"%H"), ~"15"); + assert_eq!(local.strftime(~"%I"), ~"03"); + assert_eq!(local.strftime(~"%j"), ~"044"); + assert_eq!(local.strftime(~"%k"), ~"15"); + assert_eq!(local.strftime(~"%l"), ~" 3"); + assert_eq!(local.strftime(~"%M"), ~"31"); + assert_eq!(local.strftime(~"%m"), ~"02"); + assert_eq!(local.strftime(~"%n"), ~"\n"); + assert_eq!(local.strftime(~"%P"), ~"pm"); + assert_eq!(local.strftime(~"%p"), ~"PM"); + assert_eq!(local.strftime(~"%R"), ~"15:31"); + assert_eq!(local.strftime(~"%r"), ~"03:31:30 PM"); + assert_eq!(local.strftime(~"%S"), ~"30"); + assert_eq!(local.strftime(~"%s"), ~"1234567890"); + assert_eq!(local.strftime(~"%T"), ~"15:31:30"); + assert_eq!(local.strftime(~"%t"), ~"\t"); // assert!(local.strftime("%U") == "06"); - assert!(local.strftime(~"%u") == ~"5"); + assert_eq!(local.strftime(~"%u"), ~"5"); // assert!(local.strftime("%V") == "07"); - assert!(local.strftime(~"%v") == ~"13-Feb-2009"); + assert_eq!(local.strftime(~"%v"), ~"13-Feb-2009"); // assert!(local.strftime("%W") == "06"); - assert!(local.strftime(~"%w") == ~"5"); + assert_eq!(local.strftime(~"%w"), ~"5"); // handle "%X" // handle "%x" - assert!(local.strftime(~"%Y") == ~"2009"); - assert!(local.strftime(~"%y") == ~"09"); + assert_eq!(local.strftime(~"%Y"), ~"2009"); + assert_eq!(local.strftime(~"%y"), ~"09"); // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let zone = local.strftime(~"%Z"); assert!(zone == ~"PST" || zone == ~"Pacific Standard Time"); - assert!(local.strftime(~"%z") == ~"-0800"); - assert!(local.strftime(~"%%") == ~"%"); + assert_eq!(local.strftime(~"%z"), ~"-0800"); + assert_eq!(local.strftime(~"%%"), ~"%"); // FIXME (#2350): We should probably standardize on the timezone // abbreviation. @@ -1207,14 +1207,14 @@ mod tests { assert!(rfc822 == prefix + ~"PST" || rfc822 == prefix + ~"Pacific Standard Time"); - assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); - assert!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800"); - assert!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00"); + assert_eq!(local.ctime(), ~"Fri Feb 13 15:31:30 2009"); + assert_eq!(local.rfc822z(), ~"Fri, 13 Feb 2009 15:31:30 -0800"); + assert_eq!(local.rfc3339(), ~"2009-02-13T15:31:30-08:00"); - assert!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); - assert!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT"); - assert!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000"); - assert!(utc.rfc3339() == ~"2009-02-13T23:31:30Z"); + assert_eq!(utc.ctime(), ~"Fri Feb 13 23:31:30 2009"); + assert_eq!(utc.rfc822(), ~"Fri, 13 Feb 2009 23:31:30 GMT"); + assert_eq!(utc.rfc822z(), ~"Fri, 13 Feb 2009 23:31:30 -0000"); + assert_eq!(utc.rfc3339(), ~"2009-02-13T23:31:30Z"); } fn test_timespec_eq_ord() { diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index e9fd0414244..7fea94a39a7 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -256,7 +256,7 @@ mod test { match recv_timeout(hl_loop, 10u, &test_po) { Some(val) => { - assert!(val == expected); + assert_eq!(val, expected); successes += 1; } _ => failures += 1 diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index e0ee3a1ee01..e4026d7306f 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -920,7 +920,7 @@ mod test_treemap { assert!(m.insert(1, 2)); assert!(m.insert(5, 3)); assert!(m.insert(9, 3)); - assert!(m.find(&2) == None); + assert_eq!(m.find(&2), None); } #[test] @@ -942,7 +942,7 @@ mod test_treemap { assert!(m.insert(5, 2)); assert!(m.insert(2, 9)); assert!(!m.insert(2, 11)); - assert!(m.find(&2).unwrap() == &11); + assert_eq!(m.find(&2).unwrap(), &11); } #[test] @@ -971,13 +971,13 @@ mod test_treemap { m.insert(copy k1, copy v1); m.insert(copy k2, copy v2); - assert!(m.find(&k2) == Some(&v2)); - assert!(m.find(&k1) == Some(&v1)); + assert_eq!(m.find(&k2), Some(&v2)); + assert_eq!(m.find(&k1), Some(&v1)); } fn check_equal<K: Eq + TotalOrd, V: Eq>(ctrl: &[(K, V)], map: &TreeMap<K, V>) { - assert!(ctrl.is_empty() == map.is_empty()); + assert_eq!(ctrl.is_empty(), map.is_empty()); for ctrl.each |x| { let &(k, v) = x; assert!(map.find(&k).unwrap() == &v) @@ -1000,7 +1000,7 @@ mod test_treemap { parent: &~TreeNode<K, V>) { match *node { Some(ref r) => { - assert!(r.key.cmp(&parent.key) == Less); + assert_eq!(r.key.cmp(&parent.key), Less); assert!(r.level == parent.level - 1); // left is black check_left(&r.left, r); check_right(&r.right, r, false); @@ -1014,7 +1014,7 @@ mod test_treemap { parent_red: bool) { match *node { Some(ref r) => { - assert!(r.key.cmp(&parent.key) == Greater); + assert_eq!(r.key.cmp(&parent.key), Greater); let red = r.level == parent.level; if parent_red { assert!(!red) } // no dual horizontal links // Right red or black @@ -1072,19 +1072,19 @@ mod test_treemap { fn test_len() { let mut m = TreeMap::new(); assert!(m.insert(3, 6)); - assert!(m.len() == 1); + assert_eq!(m.len(), 1); assert!(m.insert(0, 0)); - assert!(m.len() == 2); + assert_eq!(m.len(), 2); assert!(m.insert(4, 8)); - assert!(m.len() == 3); + assert_eq!(m.len(), 3); assert!(m.remove(&3)); - assert!(m.len() == 2); + assert_eq!(m.len(), 2); assert!(!m.remove(&5)); - assert!(m.len() == 2); + assert_eq!(m.len(), 2); assert!(m.insert(2, 4)); - assert!(m.len() == 3); + assert_eq!(m.len(), 3); assert!(m.insert(1, 2)); - assert!(m.len() == 4); + assert_eq!(m.len(), 4); } #[test] @@ -1099,8 +1099,8 @@ mod test_treemap { 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; } } @@ -1117,8 +1117,8 @@ mod test_treemap { 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; } } @@ -1191,11 +1191,11 @@ mod test_treemap { let m = m; let mut a = m.iter(); - assert!(a.next().unwrap() == (&x1, &y1)); - assert!(a.next().unwrap() == (&x2, &y2)); - assert!(a.next().unwrap() == (&x3, &y3)); - assert!(a.next().unwrap() == (&x4, &y4)); - assert!(a.next().unwrap() == (&x5, &y5)); + assert_eq!(a.next().unwrap(), (&x1, &y1)); + assert_eq!(a.next().unwrap(), (&x2, &y2)); + assert_eq!(a.next().unwrap(), (&x3, &y3)); + assert_eq!(a.next().unwrap(), (&x4, &y4)); + assert_eq!(a.next().unwrap(), (&x5, &y5)); assert!(a.next().is_none()); @@ -1206,7 +1206,7 @@ mod test_treemap { let mut i = 0; for b.advance |x| { - assert!(expected[i] == x); + assert_eq!(expected[i], x); i += 1; if i == 2 { @@ -1215,7 +1215,7 @@ mod test_treemap { } for b.advance |x| { - assert!(expected[i] == x); + assert_eq!(expected[i], x); i += 1; } } @@ -1303,7 +1303,7 @@ mod test_set { let mut n = 0; for m.each |x| { - assert!(*x == n); + assert_eq!(*x, n); n += 1 } } @@ -1320,7 +1320,7 @@ mod test_set { let mut n = 4; for m.each_reverse |x| { - assert!(*x == n); + assert_eq!(*x, n); n -= 1 } } @@ -1335,10 +1335,10 @@ mod test_set { let mut i = 0; for f(&set_a, &set_b) |x| { - assert!(*x == expected[i]); + assert_eq!(*x, expected[i]); i += 1; } - assert!(i == expected.len()); + assert_eq!(i, expected.len()); } #[test] @@ -1421,10 +1421,10 @@ mod test_set { // FIXME: #5801: this needs a type hint to compile... let result: Option<(&uint, & &'static str)> = z.next(); - assert!(result.unwrap() == (&5u, & &"bar")); + assert_eq!(result.unwrap(), (&5u, & &"bar")); let result: Option<(&uint, & &'static str)> = z.next(); - assert!(result.unwrap() == (&11u, & &"foo")); + assert_eq!(result.unwrap(), (&11u, & &"foo")); let result: Option<(&uint, & &'static str)> = z.next(); assert!(result.is_none()); @@ -1433,16 +1433,16 @@ mod test_set { #[test] fn test_swap() { let mut m = TreeMap::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 = TreeMap::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); } } diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 2922f403f34..d1a95c5b9f7 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -183,7 +183,7 @@ extern fn tear_down_walk_cb(handle: *libc::c_void, arg: *libc::c_void) { // pretty much, if we still have an active handle and it is *not* // the async handle that facilities global loop communication, we // want to barf out and fail - assert!(handle == arg); + assert_eq!(handle, arg); } extern fn tear_down_close_cb(handle: *ll::uv_async_t) { diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 44a368738fd..61921fbf090 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -319,7 +319,7 @@ pub impl FileMap { fn next_line(&self, pos: BytePos) { // the new charpos must be > the last one (or it's the first one). let lines = &mut *self.lines; - assert!((lines.len() == 0) || (lines[lines.len() - 1] < pos)); + assert!((lines.len() == 0) || (lines[lines.len() - 1] < pos)) lines.push(pos); } @@ -458,7 +458,7 @@ pub impl CodeMap { pub fn span_to_snippet(&self, sp: span) -> ~str { let begin = self.lookup_byte_offset(sp.lo); let end = self.lookup_byte_offset(sp.hi); - assert!(begin.fm.start_pos == end.fm.start_pos); + assert_eq!(begin.fm.start_pos, end.fm.start_pos); return str::slice(*begin.fm.src, begin.pos.to_uint(), end.pos.to_uint()).to_owned(); } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 9a8a6620652..fa52f3dde3d 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -381,7 +381,7 @@ mod test { i.intern("c"); i.intern("d"); i.intern("return"); - assert!(i.get(ast::ident{repr:101,ctxt:0}) == @~"b"); + assert_eq!(i.get(ast::ident{repr:101,ctxt:0}), @~"b"); i } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 38c58612f43..52495522613 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -111,7 +111,7 @@ pub fn tok_str(t: token) -> ~str { pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint, lim: uint) -> ~str { let n = toks.len(); - assert!(n == szs.len()); + assert_eq!(n, szs.len()); let mut i = left; let mut L = lim; let mut s = ~"["; @@ -400,7 +400,7 @@ pub impl Printer { match x { BREAK(b) => self.left_total += b.blank_space, STRING(_, len) => { - assert!((len == L)); self.left_total += len; + assert_eq!(len, L); self.left_total += len; } _ => () } @@ -526,7 +526,7 @@ pub impl Printer { } STRING(s, len) => { debug!("print STRING(%s)", *s); - assert!((L == len)); + assert_eq!(L, len); // assert!(L <= space); self.space -= len; self.print_str(*s); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index ea1682978a4..b2db752af11 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2067,7 +2067,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) { pub fn print_comment(s: @ps, cmnt: &comments::cmnt) { match cmnt.style { comments::mixed => { - assert!(cmnt.lines.len() == 1u); + assert_eq!(cmnt.lines.len(), 1u); zerobreak(s.s); word(s.s, cmnt.lines[0]); zerobreak(s.s); diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index cb494ec9d20..0d951771d70 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -35,7 +35,7 @@ fn ascending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) { do timed("search") { for uint::range(0, n_keys) |i| { - assert!(map.find(&i).unwrap() == &(i + 1)); + assert_eq!(map.find(&i).unwrap(), &(i + 1)); } } @@ -57,7 +57,7 @@ fn descending<M: Map<uint, uint>>(map: &mut M, n_keys: uint) { do timed("search") { for uint::range_rev(n_keys, 0) |i| { - assert!(map.find(&i).unwrap() == &(i + 1)); + assert_eq!(map.find(&i).unwrap(), &(i + 1)); } } @@ -78,7 +78,7 @@ fn vector<M: Map<uint, uint>>(map: &mut M, n_keys: uint, dist: &[uint]) { do timed("search") { for uint::range(0, n_keys) |i| { - assert!(map.find(&dist[i]).unwrap() == &(i + 1)); + assert_eq!(map.find(&dist[i]).unwrap(), &(i + 1)); } } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index ddf6f4bfc55..4be2cca0b48 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -296,7 +296,7 @@ fn pbfs(graph: &arc::ARC<graph>, key: node_id) -> bfs_result { }; result }; - assert!((colors.len() == old_len)); + assert_eq!(colors.len(), old_len); } // Convert the results. diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 95758b3fe64..d1be03e944a 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -93,7 +93,7 @@ fn run(args: &[~str]) { io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed)); let thruput = ((size / workers * workers) as float) / (elapsed as float); io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput)); - assert!(result == num_bytes * size); + assert_eq!(result, num_bytes * size); } fn main() { diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index e213a44b49a..b72a38d4054 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -90,7 +90,7 @@ fn run(args: &[~str]) { io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed)); let thruput = ((size / workers * workers) as float) / (elapsed as float); io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput)); - assert!(result == num_bytes * size); + assert_eq!(result, num_bytes * size); } fn main() { diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index b7ae331c8f3..31945310eb3 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -70,7 +70,7 @@ fn stress_task(id: int) { let mut i = 0; loop { let n = 15; - assert!((fib(n) == fib(n))); + assert_eq!(fib(n), fib(n)); i += 1; error!("%d: Completed %d iterations", id, i); } diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 4b0d34d2315..7b8aca2694e 100644 --- a/src/test/bench/std-smallintmap.rs +++ b/src/test/bench/std-smallintmap.rs @@ -22,7 +22,7 @@ fn append_sequential(min: uint, max: uint, map: &mut SmallIntMap<uint>) { fn check_sequential(min: uint, max: uint, map: &SmallIntMap<uint>) { for uint::range(min, max) |i| { - assert!(*map.get(&i) == i + 22u); + assert_eq!(*map.get(&i), i + 22u); } } diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index c18c1eaedd6..4d8614b5edd 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -212,30 +212,30 @@ static default_solution: [[u8, ..9], ..9] = [ #[test] fn colors_new_works() { - assert!(*Colors::new(1) == 1022u16); - assert!(*Colors::new(2) == 1020u16); - assert!(*Colors::new(3) == 1016u16); - assert!(*Colors::new(4) == 1008u16); - assert!(*Colors::new(5) == 992u16); - assert!(*Colors::new(6) == 960u16); - assert!(*Colors::new(7) == 896u16); - assert!(*Colors::new(8) == 768u16); - assert!(*Colors::new(9) == 512u16); + assert_eq!(*Colors::new(1), 1022u16); + assert_eq!(*Colors::new(2), 1020u16); + assert_eq!(*Colors::new(3), 1016u16); + assert_eq!(*Colors::new(4), 1008u16); + assert_eq!(*Colors::new(5), 992u16); + assert_eq!(*Colors::new(6), 960u16); + assert_eq!(*Colors::new(7), 896u16); + assert_eq!(*Colors::new(8), 768u16); + assert_eq!(*Colors::new(9), 512u16); } #[test] fn colors_next_works() { - assert!(Colors(0).next() == 0u8); - assert!(Colors(2).next() == 1u8); - assert!(Colors(4).next() == 2u8); - assert!(Colors(8).next() == 3u8); - assert!(Colors(16).next() == 4u8); - assert!(Colors(32).next() == 5u8); - assert!(Colors(64).next() == 6u8); - assert!(Colors(128).next() == 7u8); - assert!(Colors(256).next() == 8u8); - assert!(Colors(512).next() == 9u8); - assert!(Colors(1024).next() == 0u8); + assert_eq!(Colors(0).next(), 0u8); + assert_eq!(Colors(2).next(), 1u8); + assert_eq!(Colors(4).next(), 2u8); + assert_eq!(Colors(8).next(), 3u8); + assert_eq!(Colors(16).next(), 4u8); + assert_eq!(Colors(32).next(), 5u8); + assert_eq!(Colors(64).next(), 6u8); + assert_eq!(Colors(128).next(), 7u8); + assert_eq!(Colors(256).next(), 8u8); + assert_eq!(Colors(512).next(), 9u8); + assert_eq!(Colors(1024).next(), 0u8); } #[test] @@ -247,7 +247,7 @@ fn colors_remove_works() { colors.remove(1); // THEN - assert!(colors.next() == 2u8); + assert_eq!(colors.next(), 2u8); } #[test] diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs index 6015f21be72..aacdf678bbf 100644 --- a/src/test/bench/task-perf-linked-failure.rs +++ b/src/test/bench/task-perf-linked-failure.rs @@ -54,7 +54,7 @@ fn spawn_supervised_blocking(myname: &str, f: ~fn()) { builder.spawn(f); error!("%s group waiting", myname); let x = res.unwrap().recv(); - assert!(x == task::Success); + assert_eq!(x, task::Success); } fn main() { diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index ecd31d0dde4..e38c22004ed 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -22,10 +22,10 @@ fn main() { let b: clam = clam{x: @10, y: @20}; let z: int = a.x + b.y; //~ ERROR binary operation + cannot be applied to type `@int` debug!(z); - assert!((z == 21)); + assert_eq!(z, 21); let forty: fish = fish{a: @40}; let two: fish = fish{a: @2}; let answer: int = forty.a + two.a; //~ ERROR binary operation + cannot be applied to type `@int` debug!(answer); - assert!((answer == 42)); + assert_eq!(answer, 42); } diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs index 42c5ffe3e91..73a53d6cc98 100644 --- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs +++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs @@ -19,5 +19,5 @@ fn compute1() -> float { fn main() { let x = compute1(); debug!(x); - assert!((x == -4f)); + assert_eq!(x, -4f); } diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs index f8415a38573..ae8779eafcc 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs @@ -16,8 +16,8 @@ fn box_imm() { let mut v = ~3; do borrow(v) |w| { v = ~4; //~ ERROR cannot assign to `v` because it is borrowed - assert!(*v == 3); - assert!(*w == 4); + assert_eq!(*v, 3); + assert_eq!(*w, 4); } } diff --git a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs index 3a37116a166..4a34b85c3ed 100644 --- a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs +++ b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs @@ -16,5 +16,5 @@ fn destructure(x: Option<int>) -> int { } fn main() { - assert!(destructure(Some(22)) == 22); + assert_eq!(destructure(Some(22)), 22); } diff --git a/src/test/compile-fail/issue-1896-1.rs b/src/test/compile-fail/issue-1896-1.rs index 13adcd42da2..4750f68d59b 100644 --- a/src/test/compile-fail/issue-1896-1.rs +++ b/src/test/compile-fail/issue-1896-1.rs @@ -22,5 +22,5 @@ fn main () { let myInt: uint = (aFn.theFn)(); - assert!(myInt == 10); + assert_eq!(myInt, 10); } diff --git a/src/test/compile-fail/issue-2467.rs b/src/test/compile-fail/issue-2467.rs index fd6e5a762b2..3149db8a03f 100644 --- a/src/test/compile-fail/issue-2467.rs +++ b/src/test/compile-fail/issue-2467.rs @@ -12,5 +12,5 @@ enum test { thing = 3u } //~ ERROR mismatched types //~^ ERROR expected signed integer constant fn main() { error!(thing as int); - assert!((thing as int == 3)); + assert_eq!(thing as int, 3); } diff --git a/src/test/compile-fail/issue-2548.rs b/src/test/compile-fail/issue-2548.rs index 9c2d7baa23c..fdaf1f562c8 100644 --- a/src/test/compile-fail/issue-2548.rs +++ b/src/test/compile-fail/issue-2548.rs @@ -38,8 +38,8 @@ fn main() { let mut v = ~[]; v = ~[(res)] + v; //~ instantiating a type parameter with an incompatible type `foo`, which does not fulfill `Copy` - assert!((v.len() == 2)); + assert_eq!(v.len(), 2); } - assert!(*x == 1); + assert_eq!(*x, 1); } diff --git a/src/test/compile-fail/issue-2969.rs b/src/test/compile-fail/issue-2969.rs index 927e81db5c1..a9c26fc415e 100644 --- a/src/test/compile-fail/issue-2969.rs +++ b/src/test/compile-fail/issue-2969.rs @@ -15,5 +15,5 @@ fn main() let mut x = [1, 2, 4]; let v : &int = &x[2]; x[2] = 6; - assert!(*v == 6); + assert_eq!(*v, 6); } diff --git a/src/test/compile-fail/kindck-owned-trait-scoped.rs b/src/test/compile-fail/kindck-owned-trait-scoped.rs index bb0ba87c098..dc3717085ca 100644 --- a/src/test/compile-fail/kindck-owned-trait-scoped.rs +++ b/src/test/compile-fail/kindck-owned-trait-scoped.rs @@ -30,7 +30,7 @@ fn to_foo<T:Copy>(t: T) { let v = &3; struct F<T> { f: T } let x = @F {f:t} as @foo; - assert!(x.foo(v) == 3); + assert_eq!(x.foo(v), 3); } fn to_foo_2<T:Copy>(t: T) -> @foo { diff --git a/src/test/compile-fail/mod_file_not_exist.rs b/src/test/compile-fail/mod_file_not_exist.rs index 17ca8dca273..9b16738e951 100644 --- a/src/test/compile-fail/mod_file_not_exist.rs +++ b/src/test/compile-fail/mod_file_not_exist.rs @@ -11,5 +11,5 @@ mod not_a_real_file; //~ ERROR not_a_real_file.rs fn main() { - assert!(mod_file_aux::bar() == 10); + assert_eq!(mod_file_aux::bar(), 10); } diff --git a/src/test/compile-fail/mod_file_with_path_attr.rs b/src/test/compile-fail/mod_file_with_path_attr.rs index 827c77bda47..ff330047c4e 100644 --- a/src/test/compile-fail/mod_file_with_path_attr.rs +++ b/src/test/compile-fail/mod_file_with_path_attr.rs @@ -12,5 +12,5 @@ mod m; //~ ERROR not_a_real_file.rs fn main() { - assert!(m::foo() == 10); + assert_eq!(m::foo(), 10); } diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 2c8c98ad5d6..4c206a949a2 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -19,10 +19,10 @@ fn main() { do task::spawn() { let v = *arc::get(&arc_v); - assert!(v[3] == 4); + assert_eq!(v[3], 4); }; - assert!((*arc::get(&arc_v))[2] == 3); + assert_eq!((*arc::get(&arc_v))[2], 3); info!(arc_v); } diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index 75cd706985c..46eaded4527 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -17,7 +17,7 @@ fn main() { do task::spawn() { //~ NOTE `arc_v` moved into closure environment here let v = *arc::get(&arc_v); - assert!(v[3] == 4); + assert_eq!(v[3], 4); }; assert!((*arc::get(&arc_v))[2] == 3); //~ ERROR use of moved value: `arc_v` diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index 9a4974849a5..61300b92afd 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -37,5 +37,5 @@ mod argparse { fn main () { let f : argparse::Flag = argparse::flag(~"flag", ~"My flag"); let updated_flag = f.set_desc(~"My new flag"); - assert!(updated_flag.desc == "My new flag"); + assert_eq!(updated_flag.desc, "My new flag"); } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs index d519397f68c..5710188ed9f 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs @@ -19,7 +19,7 @@ fn x_coord<'r>(p: &'r point) -> &'r int { fn foo(p: @point) -> &int { let xc = x_coord(p); //~ ERROR cannot root - assert!(*xc == 3); + assert_eq!(*xc, 3); return xc; } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs index 3b88c634598..2ffd0796e30 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs @@ -19,7 +19,7 @@ fn foo(cond: &fn() -> bool, box: &fn() -> @int) { // of this borrow is the fn body as a whole. y = borrow(x); //~ ERROR cannot root - assert!(*x == *y); + assert_eq!(*x, *y); if cond() { break; } } assert!(*y != 0); diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs index ff75ba4473d..ae697ad1181 100644 --- a/src/test/compile-fail/regions-trait-1.rs +++ b/src/test/compile-fail/regions-trait-1.rs @@ -34,5 +34,5 @@ fn get_v(gc: @get_ctxt) -> uint { fn main() { let ctxt = ctxt { v: 22u }; let hc = has_ctxt { c: &ctxt }; - assert!(get_v(@hc as @get_ctxt) == 22u); + assert_eq!(get_v(@hc as @get_ctxt), 22u); } diff --git a/src/test/compile-fail/regions-var-type-out-of-scope.rs b/src/test/compile-fail/regions-var-type-out-of-scope.rs index addf20fd702..8955a26de0b 100644 --- a/src/test/compile-fail/regions-var-type-out-of-scope.rs +++ b/src/test/compile-fail/regions-var-type-out-of-scope.rs @@ -15,7 +15,7 @@ fn foo(cond: bool) { if cond { x = &3; //~ ERROR borrowed value does not live long enough - assert!((*x == 3)); + assert_eq!(*x, 3); } } diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs index dd0ae87f311..5d0991024c4 100644 --- a/src/test/compile-fail/vtable-res-trait-param.rs +++ b/src/test/compile-fail/vtable-res-trait-param.rs @@ -29,5 +29,5 @@ fn call_it<B:TraitB>(b: B) -> int { fn main() { let x = 3i; - assert!(call_it(x) == 22); + assert_eq!(call_it(x), 22); } diff --git a/src/test/pretty/record-trailing-comma.rs b/src/test/pretty/record-trailing-comma.rs index 1ea0e104132..67059e07c89 100644 --- a/src/test/pretty/record-trailing-comma.rs +++ b/src/test/pretty/record-trailing-comma.rs @@ -18,5 +18,5 @@ struct Thing { fn main() { let sth = Thing{x: 0, y: 1,}; let sth2 = Thing{y: 9 , ..sth}; - assert!(sth.x + sth2.y == 9); + assert_eq!(sth.x + sth2.y, 9); } diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs index 38b73ea5698..5ec2c093eeb 100644 --- a/src/test/run-fail/str-overrun.rs +++ b/src/test/run-fail/str-overrun.rs @@ -15,5 +15,5 @@ fn main() { let s: ~str = ~"hello"; // Bounds-check failure. - assert!((s[5] == 0x0 as u8)); + assert_eq!(s[5], 0x0 as u8); } diff --git a/src/test/run-fail/unwind-alt.rs b/src/test/run-fail/unwind-alt.rs index d7e079ad907..a9761017c73 100644 --- a/src/test/run-fail/unwind-alt.rs +++ b/src/test/run-fail/unwind-alt.rs @@ -16,7 +16,7 @@ fn test_box() { fn test_str() { let res = match false { true => { ~"happy" }, _ => fail!("non-exhaustive match failure") }; - assert!(res == ~"happy"); + assert_eq!(res, ~"happy"); } fn main() { test_box(); diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs index ab9dcf32781..411895a2ef0 100644 --- a/src/test/run-fail/vec-overrun.rs +++ b/src/test/run-fail/vec-overrun.rs @@ -14,8 +14,8 @@ fn main() { let v: ~[int] = ~[10]; let x: int = 0; - assert!((v[x] == 10)); + assert_eq!(v[x], 10); // Bounds-check failure. - assert!((v[x + 2] == 20)); + assert_eq!(v[x + 2], 20); } diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs index 6f403fd7721..99ce79b3b6c 100644 --- a/src/test/run-fail/vec-underrun.rs +++ b/src/test/run-fail/vec-underrun.rs @@ -14,8 +14,8 @@ fn main() { let v: ~[int] = ~[10, 20]; let x: int = 0; - assert!((v[x] == 10)); + assert_eq!(v[x], 10); // Bounds-check failure. - assert!((v[x - 1] == 20)); + assert_eq!(v[x - 1], 20); } diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index 84edb990a75..53385e16759 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -82,6 +82,6 @@ fn check_pp<T>(cx: fake_ext_ctxt, stdout().write_line(s); if expect != ~"" { error!("expect: '%s', got: '%s'", expect, s); - assert!(s == expect); + assert_eq!(s, expect); } } diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs index e3a544af309..bf96d6cfab5 100644 --- a/src/test/run-pass/alignment-gep-tup-like-1.rs +++ b/src/test/run-pass/alignment-gep-tup-like-1.rs @@ -20,6 +20,6 @@ fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) { pub fn main() { let (a, b) = f(22_u64, 44u16)(); debug!("a=%? b=%?", a, b); - assert!(a == 22u64); - assert!(b == 44u16); + assert_eq!(a, 22u64); + assert_eq!(b, 44u16); } diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs index 847e6fce8ee..6bf4e96bc05 100644 --- a/src/test/run-pass/alignment-gep-tup-like-2.rs +++ b/src/test/run-pass/alignment-gep-tup-like-2.rs @@ -35,6 +35,6 @@ pub fn main() { make_cycle(z); let (a, b) = z(); debug!("a=%u b=%u", *a as uint, b as uint); - assert!(*a == x); - assert!(b == y); + assert_eq!(*a, x); + assert_eq!(b, y); } diff --git a/src/test/run-pass/alt-ref-binding-mut-option.rs b/src/test/run-pass/alt-ref-binding-mut-option.rs index 9ef414d1170..8d1e483bcd8 100644 --- a/src/test/run-pass/alt-ref-binding-mut-option.rs +++ b/src/test/run-pass/alt-ref-binding-mut-option.rs @@ -14,5 +14,5 @@ pub fn main() { None => {} Some(ref mut p) => { *p += 1; } } - assert!(v == Some(23)); + assert_eq!(v, Some(23)); } diff --git a/src/test/run-pass/alt-ref-binding-mut.rs b/src/test/run-pass/alt-ref-binding-mut.rs index 2bd55b46784..266f7cdde11 100644 --- a/src/test/run-pass/alt-ref-binding-mut.rs +++ b/src/test/run-pass/alt-ref-binding-mut.rs @@ -21,5 +21,5 @@ fn destructure(x: &mut Rec) { pub fn main() { let mut v = Rec {f: 22}; destructure(&mut v); - assert!(v.f == 23); + assert_eq!(v.f, 23); } diff --git a/src/test/run-pass/alt-ref-binding.rs b/src/test/run-pass/alt-ref-binding.rs index 23b3062a83a..0b613df18ee 100644 --- a/src/test/run-pass/alt-ref-binding.rs +++ b/src/test/run-pass/alt-ref-binding.rs @@ -16,5 +16,5 @@ fn destructure(x: Option<int>) -> int { } pub fn main() { - assert!(destructure(Some(22)) == 22); + assert_eq!(destructure(Some(22)), 22); } diff --git a/src/test/run-pass/alt-str.rs b/src/test/run-pass/alt-str.rs index e41ec8a99e9..8bbcc507f18 100644 --- a/src/test/run-pass/alt-str.rs +++ b/src/test/run-pass/alt-str.rs @@ -24,7 +24,7 @@ pub fn main() { } let x = match ~"a" { ~"a" => 1, ~"b" => 2, _ => fail!() }; - assert!((x == 1)); + assert_eq!(x, 1); match ~"a" { ~"a" => { } ~"b" => { }, _ => fail!() } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index e2e1bf540c2..9eeb12d9c45 100644 --- a/src/test/run-pass/alt-tag.rs +++ b/src/test/run-pass/alt-tag.rs @@ -32,7 +32,7 @@ pub fn main() { let gray: color = rgb(127, 127, 127); let clear: color = rgba(50, 150, 250, 0); let red: color = hsl(0, 255, 255); - assert!((process(gray) == 127)); - assert!((process(clear) == 0)); - assert!((process(red) == 255)); + assert_eq!(process(gray), 127); + assert_eq!(process(clear), 0); + assert_eq!(process(red), 255); } diff --git a/src/test/run-pass/alt-unique-bind.rs b/src/test/run-pass/alt-unique-bind.rs index 2fb0a345157..997cc1ee9ff 100644 --- a/src/test/run-pass/alt-unique-bind.rs +++ b/src/test/run-pass/alt-unique-bind.rs @@ -12,7 +12,7 @@ pub fn main() { match ~100 { ~x => { debug!("%?", x); - assert!(x == 100); + assert_eq!(x, 100); } } } diff --git a/src/test/run-pass/alt-with-ret-arm.rs b/src/test/run-pass/alt-with-ret-arm.rs index d5d2e20cba3..f46521f1d55 100644 --- a/src/test/run-pass/alt-with-ret-arm.rs +++ b/src/test/run-pass/alt-with-ret-arm.rs @@ -16,6 +16,6 @@ pub fn main() { None => return (), Some(num) => num as u32 }; - assert!(f == 1234u32); + assert_eq!(f, 1234u32); error!(f) } diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs index 8c84187ff6f..7e56edbedf6 100644 --- a/src/test/run-pass/argument-passing.rs +++ b/src/test/run-pass/argument-passing.rs @@ -25,9 +25,9 @@ fn f2(a: int, f: &fn(int)) -> int { f(1); return a; } pub fn main() { let mut a = X {x: 1}, b = 2, c = 3; - assert!((f1(&mut a, &mut b, c) == 6)); - assert!((a.x == 0)); - assert!((b == 10)); - assert!((f2(a.x, |x| a.x = 50) == 0)); - assert!((a.x == 50)); + assert_eq!(f1(&mut a, &mut b, c), 6); + assert_eq!(a.x, 0); + assert_eq!(b, 10); + assert_eq!(f2(a.x, |x| a.x = 50), 0); + assert_eq!(a.x, 50); } diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs index a0512ffff2a..308a5c2721c 100644 --- a/src/test/run-pass/arith-0.rs +++ b/src/test/run-pass/arith-0.rs @@ -13,5 +13,5 @@ pub fn main() { let a: int = 10; debug!(a); - assert!((a * (a - 1) == 90)); + assert_eq!(a * (a - 1), 90); } diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs index c0db96f99c7..a6321439db9 100644 --- a/src/test/run-pass/arith-1.rs +++ b/src/test/run-pass/arith-1.rs @@ -12,22 +12,22 @@ pub fn main() { let i32_a: int = 10; - assert!((i32_a == 10)); - assert!((i32_a - 10 == 0)); - assert!((i32_a / 10 == 1)); - assert!((i32_a - 20 == -10)); - assert!((i32_a << 10 == 10240)); - assert!((i32_a << 16 == 655360)); - assert!((i32_a * 16 == 160)); - assert!((i32_a * i32_a * i32_a == 1000)); - assert!((i32_a * i32_a * i32_a * i32_a == 10000)); - assert!((i32_a * i32_a / i32_a * i32_a == 100)); - assert!((i32_a * (i32_a - 1) << 2 + i32_a == 368640)); + assert_eq!(i32_a, 10); + assert_eq!(i32_a - 10, 0); + assert_eq!(i32_a / 10, 1); + assert_eq!(i32_a - 20, -10); + assert_eq!(i32_a << 10, 10240); + assert_eq!(i32_a << 16, 655360); + assert_eq!(i32_a * 16, 160); + assert_eq!(i32_a * i32_a * i32_a, 1000); + assert_eq!(i32_a * i32_a * i32_a * i32_a, 10000); + assert_eq!(i32_a * i32_a / i32_a * i32_a, 100); + assert_eq!(i32_a * (i32_a - 1) << 2 + i32_a, 368640); let i32_b: int = 0x10101010; - assert!((i32_b + 1 - 1 == i32_b)); - assert!((i32_b << 1 == i32_b << 1)); - assert!((i32_b >> 1 == i32_b >> 1)); - assert!((i32_b & i32_b << 1 == 0)); + assert_eq!(i32_b + 1 - 1, i32_b); + assert_eq!(i32_b << 1, i32_b << 1); + assert_eq!(i32_b >> 1, i32_b >> 1); + assert_eq!(i32_b & i32_b << 1, 0); debug!(i32_b | i32_b << 1); - assert!((i32_b | i32_b << 1 == 0x30303030)); + assert_eq!(i32_b | i32_b << 1, 0x30303030); } diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs index a921d9f7ddc..0eb4e7ad92e 100644 --- a/src/test/run-pass/arith-unsigned.rs +++ b/src/test/run-pass/arith-unsigned.rs @@ -17,20 +17,20 @@ pub fn main() { assert!((0u8 <= 255u8)); assert!((255u8 > 0u8)); assert!((255u8 >= 0u8)); - assert!((250u8 / 10u8 == 25u8)); - assert!((255u8 % 10u8 == 5u8)); + assert_eq!(250u8 / 10u8, 25u8); + assert_eq!(255u8 % 10u8, 5u8); assert!((0u16 < 60000u16)); assert!((0u16 <= 60000u16)); assert!((60000u16 > 0u16)); assert!((60000u16 >= 0u16)); - assert!((60000u16 / 10u16 == 6000u16)); - assert!((60005u16 % 10u16 == 5u16)); + assert_eq!(60000u16 / 10u16, 6000u16); + assert_eq!(60005u16 % 10u16, 5u16); assert!((0u32 < 4000000000u32)); assert!((0u32 <= 4000000000u32)); assert!((4000000000u32 > 0u32)); assert!((4000000000u32 >= 0u32)); - assert!((4000000000u32 / 10u32 == 400000000u32)); - assert!((4000000005u32 % 10u32 == 5u32)); + assert_eq!(4000000000u32 / 10u32, 400000000u32); + assert_eq!(4000000005u32 % 10u32, 5u32); // 64-bit numbers have some flakiness yet. Not tested } diff --git a/src/test/run-pass/assign-assign.rs b/src/test/run-pass/assign-assign.rs index dc0850b24f1..5fe2aa6cc7c 100644 --- a/src/test/run-pass/assign-assign.rs +++ b/src/test/run-pass/assign-assign.rs @@ -12,21 +12,21 @@ fn test_assign() { let mut x: int; let mut y: () = x = 10; - assert!((x == 10)); + assert_eq!(x, 10); let mut z = x = 11; - assert!((x == 11)); + assert_eq!(x, 11); z = x = 12; - assert!((x == 12)); + assert_eq!(x, 12); } fn test_assign_op() { let mut x: int = 0; let mut y: () = x += 10; - assert!((x == 10)); + assert_eq!(x, 10); let mut z = x += 11; - assert!((x == 21)); + assert_eq!(x, 21); z = x += 12; - assert!((x == 33)); + assert_eq!(x, 33); } pub fn main() { test_assign(); test_assign_op(); } diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index b21213bb221..64e1e20e4ba 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -39,15 +39,15 @@ pub fn main() { // Call a method for x.iterate() |y| { assert!(x[*y] == *y); } // Call a parameterized function - assert!(length(x.clone()) == x.len()); + assert_eq!(length(x.clone()), x.len()); // Call a parameterized function, with type arguments that require // a borrow - assert!(length::<int, &[int]>(x) == x.len()); + assert_eq!(length::<int, &[int]>(x), x.len()); // Now try it with a type that *needs* to be borrowed let z = [0,1,2,3]; // Call a method for z.iterate() |y| { assert!(z[*y] == *y); } // Call a parameterized function - assert!(length::<int, &[int]>(z) == z.len()); + assert_eq!(length::<int, &[int]>(z), z.len()); } diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs index e988028dd11..dbcbb77efa3 100644 --- a/src/test/run-pass/auto-loop.rs +++ b/src/test/run-pass/auto-loop.rs @@ -13,5 +13,5 @@ pub fn main() { for vec::each(~[1, 2, 3, 4, 5]) |x| { sum += *x; } - assert!((sum == 15)); + assert_eq!(sum, 15); } diff --git a/src/test/run-pass/auto-ref-newtype.rs b/src/test/run-pass/auto-ref-newtype.rs index a9fca0ccb15..26ef339daf5 100644 --- a/src/test/run-pass/auto-ref-newtype.rs +++ b/src/test/run-pass/auto-ref-newtype.rs @@ -19,5 +19,5 @@ pub impl Foo { pub fn main() { let m = Foo(3); - assert!(m.len() == 3); + assert_eq!(m.len(), 3); } diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index f74d78f99d0..8e2b3b56736 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -22,5 +22,5 @@ pub fn main() { let mut v = ~[1]; v.push_val(2); v.push_val(3); - assert!(v == ~[1, 2, 3]); + assert_eq!(v, ~[1, 2, 3]); } diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index afaafd45b7b..0788c74d078 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -13,7 +13,7 @@ fn f<T:Copy>(x: ~[T]) -> T { return x[0]; } fn g(act: &fn(~[int]) -> int) -> int { return act(~[1, 2, 3]); } pub fn main() { - assert!((g(f) == 1)); + assert_eq!(g(f), 1); let f1: &fn(~[~str]) -> ~str = f; - assert!((f1(~[~"x", ~"y", ~"z"]) == ~"x")); + assert_eq!(f1(~[~"x", ~"y", ~"z"]), ~"x"); } diff --git a/src/test/run-pass/autoderef-method-newtype.rs b/src/test/run-pass/autoderef-method-newtype.rs index 2d6f03c1daf..e3a19b23e91 100644 --- a/src/test/run-pass/autoderef-method-newtype.rs +++ b/src/test/run-pass/autoderef-method-newtype.rs @@ -20,5 +20,5 @@ struct foo(uint); pub fn main() { let x = foo(3u); - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs index 32f09369d98..9bc71517c1f 100644 --- a/src/test/run-pass/autoderef-method-on-trait.rs +++ b/src/test/run-pass/autoderef-method-on-trait.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @(@3u as @double); - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs index eaef1ae3477..9cfdac0a330 100644 --- a/src/test/run-pass/autoderef-method-priority.rs +++ b/src/test/run-pass/autoderef-method-priority.rs @@ -25,5 +25,5 @@ impl double for @uint { pub fn main() { let x = @3u; - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs index c04efd7e18f..299760289c2 100644 --- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs +++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs @@ -18,5 +18,5 @@ impl double for @uint { pub fn main() { let x = @@@@@3u; - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs index 0a2a93d40d1..f93f0605269 100644 --- a/src/test/run-pass/autoderef-method-twice.rs +++ b/src/test/run-pass/autoderef-method-twice.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @@3u; - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs index b704011ad98..eb173e3d5f8 100644 --- a/src/test/run-pass/autoderef-method.rs +++ b/src/test/run-pass/autoderef-method.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @3u; - assert!(x.double() == 6u); + assert_eq!(x.double(), 6u); } diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs index 5325242b99c..cae3bff8043 100644 --- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs +++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs @@ -26,5 +26,5 @@ impl Foo for uint { pub fn main() { let x = @3u; - assert!(x.foo() == ~"@3"); + assert_eq!(x.foo(), ~"@3"); } diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs index 41aa2042796..96615b740b7 100644 --- a/src/test/run-pass/big-literals.rs +++ b/src/test/run-pass/big-literals.rs @@ -11,11 +11,11 @@ // except according to those terms. pub fn main() { - assert!(0xffffffffu32 == (-1 as u32)); - assert!(4294967295u32 == (-1 as u32)); - assert!(0xffffffffffffffffu64 == (-1 as u64)); - assert!(18446744073709551615u64 == (-1 as u64)); + assert_eq!(0xffffffffu32, (-1 as u32)); + assert_eq!(4294967295u32, (-1 as u32)); + assert_eq!(0xffffffffffffffffu64, (-1 as u64)); + assert_eq!(18446744073709551615u64, (-1 as u64)); - assert!(-2147483648i32 - 1i32 == 2147483647i32); - assert!(-9223372036854775808i64 - 1i64 == 9223372036854775807i64); + assert_eq!(-2147483648i32 - 1i32, 2147483647i32); + assert_eq!(-9223372036854775808i64 - 1i64, 9223372036854775807i64); } diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs index 93f57c6722f..78edf3e112e 100644 --- a/src/test/run-pass/binary-minus-without-space.rs +++ b/src/test/run-pass/binary-minus-without-space.rs @@ -12,5 +12,5 @@ pub fn main() { match -1 { -1 => {}, _ => fail!("wat") } - assert!(1-1 == 0); + assert_eq!(1-1, 0); } diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index e755a34f058..9039730f119 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -11,7 +11,7 @@ // Binop corner cases fn test_nil() { - assert!((() == ())); + assert_eq!((), ()); assert!((!(() != ()))); assert!((!(() < ()))); assert!((() <= ())); @@ -31,35 +31,35 @@ fn test_bool() { assert!((!(false >= true))); // Bools support bitwise binops - assert!((false & false == false)); - assert!((true & false == false)); - assert!((true & true == true)); - assert!((false | false == false)); - assert!((true | false == true)); - assert!((true | true == true)); - assert!((false ^ false == false)); - assert!((true ^ false == true)); - assert!((true ^ true == false)); + assert_eq!(false & false, false); + assert_eq!(true & false, false); + assert_eq!(true & true, true); + assert_eq!(false | false, false); + assert_eq!(true | false, true); + assert_eq!(true | true, true); + assert_eq!(false ^ false, false); + assert_eq!(true ^ false, true); + assert_eq!(true ^ true, false); } fn test_char() { let ch10 = 10 as char; let ch4 = 4 as char; let ch2 = 2 as char; - assert!((ch10 + ch4 == 14 as char)); - assert!((ch10 - ch4 == 6 as char)); - assert!((ch10 * ch4 == 40 as char)); - assert!((ch10 / ch4 == ch2)); - assert!((ch10 % ch4 == ch2)); - assert!((ch10 >> ch2 == ch2)); - assert!((ch10 << ch4 == 160 as char)); - assert!((ch10 | ch4 == 14 as char)); - assert!((ch10 & ch2 == ch2)); - assert!((ch10 ^ ch2 == 8 as char)); + assert_eq!(ch10 + ch4, 14 as char); + assert_eq!(ch10 - ch4, 6 as char); + assert_eq!(ch10 * ch4, 40 as char); + assert_eq!(ch10 / ch4, ch2); + assert_eq!(ch10 % ch4, ch2); + assert_eq!(ch10 >> ch2, ch2); + assert_eq!(ch10 << ch4, 160 as char); + assert_eq!(ch10 | ch4, 14 as char); + assert_eq!(ch10 & ch2, ch2); + assert_eq!(ch10 ^ ch2, 8 as char); } fn test_box() { - assert!((@10 == @10)); + assert_eq!(@10, @10); } fn test_ptr() { @@ -68,7 +68,7 @@ fn test_ptr() { let p2: *u8 = ::core::cast::transmute(0); let p3: *u8 = ::core::cast::transmute(1); - assert!(p1 == p2); + assert_eq!(p1, p2); assert!(p1 != p3); assert!(p1 < p3); assert!(p1 <= p3); @@ -110,10 +110,10 @@ fn test_class() { (::core::cast::transmute::<*p, uint>(&q)), (::core::cast::transmute::<*p, uint>(&r))); } - assert!((q == r)); + assert_eq!(q, r); r.y = 17; assert!((r.y != q.y)); - assert!((r.y == 17)); + assert_eq!(r.y, 17); assert!((q != r)); } diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index ce06f09d321..d3d1a1d12b2 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -13,12 +13,12 @@ #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] fn target() { - assert!((-1000 as uint >> 3u == 536870787u)); + assert_eq!(-1000 as uint >> 3u, 536870787u); } #[cfg(target_arch = "x86_64")] fn target() { - assert!((-1000 as uint >> 3u == 2305843009213693827u)); + assert_eq!(-1000 as uint >> 3u, 2305843009213693827u); } fn general() { @@ -29,14 +29,14 @@ fn general() { a = a ^ b; debug!(a); debug!(b); - assert!((b == 1)); - assert!((a == 2)); - assert!((!0xf0 & 0xff == 0xf)); - assert!((0xf0 | 0xf == 0xff)); - assert!((0xf << 4 == 0xf0)); - assert!((0xf0 >> 4 == 0xf)); - assert!((-16 >> 2 == -4)); - assert!((0b1010_1010 | 0b0101_0101 == 0xff)); + assert_eq!(b, 1); + assert_eq!(a, 2); + assert_eq!(!0xf0 & 0xff, 0xf); + assert_eq!(0xf0 | 0xf, 0xff); + assert_eq!(0xf << 4, 0xf0); + assert_eq!(0xf0 >> 4, 0xf); + assert_eq!(-16 >> 2, -4); + assert_eq!(0b1010_1010 | 0b0101_0101, 0xff); } pub fn main() { diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs index 22d495e2c1b..e2745832769 100644 --- a/src/test/run-pass/block-arg-call-as.rs +++ b/src/test/run-pass/block-arg-call-as.rs @@ -24,9 +24,9 @@ fn asBlock( f : &fn()->uint ) -> uint { pub fn main() { let x = asSendfn(|| 22u); - assert!((x == 22u)); + assert_eq!(x, 22u); let x = asLambda(|| 22u); - assert!((x == 22u)); + assert_eq!(x, 22u); let x = asBlock(|| 22u); - assert!((x == 22u)); + assert_eq!(x, 22u); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs index 74756d27fe7..d10bcaa216a 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs @@ -14,5 +14,5 @@ pub fn main() { // Trailing expressions don't require parentheses: let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; - assert!(y == 15f); + assert_eq!(y, 15f); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs index 4cadb883d99..194fa297361 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs @@ -12,5 +12,5 @@ pub fn main() { fn f(i: &fn() -> uint) -> uint { i() } let v = ~[-1f, 0f, 1f, 2f, 3f]; let z = do do vec::foldl(f, v) |x, _y| { x } { 22u }; - assert!(z == 22u); + assert_eq!(z, 22u); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs index ac584324cec..5243eae30ca 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-call.rs @@ -12,5 +12,5 @@ pub fn main() { fn f(i: uint) -> uint { i } let v = ~[-1f, 0f, 1f, 2f, 3f]; let z = do vec::foldl(f, v) |x, _y| { x } (22u); - assert!(z == 22u); + assert_eq!(z, 22u); } diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs index ad53bd22754..ea189de562a 100644 --- a/src/test/run-pass/block-arg-in-parentheses.rs +++ b/src/test/run-pass/block-arg-in-parentheses.rs @@ -28,8 +28,8 @@ fn w_ret(v: ~[int]) -> int { } pub fn main() { - assert!(w_semi(~[0, 1, 2, 3]) == -10); - assert!(w_paren1(~[0, 1, 2, 3]) == -4); - assert!(w_paren2(~[0, 1, 2, 3]) == -4); - assert!(w_ret(~[0, 1, 2, 3]) == -4); + assert_eq!(w_semi(~[0, 1, 2, 3]), -10); + assert_eq!(w_paren1(~[0, 1, 2, 3]), -4); + assert_eq!(w_paren2(~[0, 1, 2, 3]), -4); + assert_eq!(w_ret(~[0, 1, 2, 3]), -4); } diff --git a/src/test/run-pass/block-arg-used-as-any.rs b/src/test/run-pass/block-arg-used-as-any.rs index d8aeba355d1..7ee9d9e5b54 100644 --- a/src/test/run-pass/block-arg-used-as-any.rs +++ b/src/test/run-pass/block-arg-used-as-any.rs @@ -14,5 +14,5 @@ fn call_any(f: &fn() -> uint) -> uint { pub fn main() { let x_r = do call_any { 22u }; - assert!(x_r == 22u); + assert_eq!(x_r, 22u); } diff --git a/src/test/run-pass/block-arg-used-as-lambda.rs b/src/test/run-pass/block-arg-used-as-lambda.rs index 2a7bfe4e328..34fa7e36d97 100644 --- a/src/test/run-pass/block-arg-used-as-lambda.rs +++ b/src/test/run-pass/block-arg-used-as-lambda.rs @@ -19,6 +19,6 @@ pub fn main() { let x_r = x(22u); let y_r = y(x_r); - assert!(x_r == 44u); - assert!(y_r == 88u); + assert_eq!(x_r, 44u); + assert_eq!(y_r, 88u); } diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index 04032900c51..de29ec99167 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -51,8 +51,8 @@ pub fn main() { let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y }; - assert!(w == y); - assert!(y == z); + assert_eq!(w, y); + assert_eq!(y, z); // In the tail of a block let w = diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs index d8f6f167f20..ace372dd2d3 100644 --- a/src/test/run-pass/block-expr-precedence.rs +++ b/src/test/run-pass/block-expr-precedence.rs @@ -58,8 +58,8 @@ pub fn main() { let num = 12; - assert!(if (true) { 12 } else { 12 } - num == 0); - assert!(12 - if (true) { 12 } else { 12 } == 0); + assert_eq!(if (true) { 12 } else { 12 } - num, 0); + assert_eq!(12 - if (true) { 12 } else { 12 }, 0); if (true) { 12; } {-num}; if (true) { 12; }; {-num}; if (true) { 12; };;; -num; diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs index 5a4b2f8bfd6..19e1fd4099b 100644 --- a/src/test/run-pass/block-fn-coerce.rs +++ b/src/test/run-pass/block-fn-coerce.rs @@ -11,7 +11,7 @@ fn force(f: &fn() -> int) -> int { return f(); } pub fn main() { fn f() -> int { return 7; } - assert!((force(f) == 7)); + assert_eq!(force(f), 7); let g = {||force(f)}; - assert!((g() == 7)); + assert_eq!(g(), 7); } diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs index 0a3458ed814..34b77b4a844 100644 --- a/src/test/run-pass/block-iter-1.rs +++ b/src/test/run-pass/block-iter-1.rs @@ -21,5 +21,5 @@ pub fn main() { } }); error!(odds); - assert!((odds == 4)); + assert_eq!(odds, 4); } diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs index e5c527db556..dc4ff5a054f 100644 --- a/src/test/run-pass/block-iter-2.rs +++ b/src/test/run-pass/block-iter-2.rs @@ -21,5 +21,5 @@ pub fn main() { }); }); error!(sum); - assert!((sum == 225)); + assert_eq!(sum, 225); } diff --git a/src/test/run-pass/block-vec-map_zip.rs b/src/test/run-pass/block-vec-map_zip.rs index 5d637ba8cef..b859dc91fba 100644 --- a/src/test/run-pass/block-vec-map_zip.rs +++ b/src/test/run-pass/block-vec-map_zip.rs @@ -16,5 +16,5 @@ pub fn main() { ~[true, false, false, true, true], |i, b| if *b { -(*i) } else { *i } ); error!(v.clone()); - assert!((v == ~[-1, 2, 3, -4, -5])); + assert_eq!(v, ~[-1, 2, 3, -4, -5]); } diff --git a/src/test/run-pass/borrowck-borrow-from-at-vec.rs b/src/test/run-pass/borrowck-borrow-from-at-vec.rs index e5f2a18df63..fb91e9a787e 100644 --- a/src/test/run-pass/borrowck-borrow-from-at-vec.rs +++ b/src/test/run-pass/borrowck-borrow-from-at-vec.rs @@ -16,5 +16,5 @@ fn sum_slice(x: &[int]) -> int { pub fn main() { let x = @[1, 2, 3]; - assert!(sum_slice(x) == 6); + assert_eq!(sum_slice(x), 6); } diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs index d65a043bf47..5149c87c490 100644 --- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs +++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs @@ -16,7 +16,7 @@ fn test1(x: @~int) { do borrow(&*(*x).clone()) |p| { let x_a = ptr::to_unsafe_ptr(&**x); assert!((x_a as uint) != ptr::to_uint(p)); - assert!(unsafe{*x_a} == *p); + assert_eq!(unsafe{*x_a}, *p); } } diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs index e9d4a248068..ee561fdb0be 100644 --- a/src/test/run-pass/borrowck-fixed-length-vecs.rs +++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs @@ -11,5 +11,5 @@ pub fn main() { let x = [22]; let y = &x[0]; - assert!(*y == 22); + assert_eq!(*y, 22); } diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs index 8f66faab014..4b5d73f597e 100644 --- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs +++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs @@ -19,5 +19,5 @@ fn has_mut_vec(v: ~[int]) -> int { } pub fn main() { - assert!(has_mut_vec(~[1, 2, 3]) == 6); + assert_eq!(has_mut_vec(~[1, 2, 3]), 6); } diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs index db886466313..5a94e2f5cd0 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x = @F {f: ~3}; match x { @F {f: ref b_x} => { - assert!(**b_x == 3); - assert!(ptr::to_unsafe_ptr(&(*x.f)) == ptr::to_unsafe_ptr(&(**b_x))); + assert_eq!(**b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(**b_x))); x = @F {f: ~4}; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(**b_x)) as uint); - assert!(**b_x == 3); + assert_eq!(**b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(**b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs index 3c95054d10c..f86471fd209 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-field.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - assert!(before == after); + assert_eq!(before, after); } struct F { f: ~int } @@ -22,13 +22,13 @@ struct F { f: ~int } pub fn main() { let mut x = @F {f: ~3}; do borrow(x.f) |b_x| { - assert!(*b_x == 3); - assert!(ptr::to_unsafe_ptr(&(*x.f)) == ptr::to_unsafe_ptr(&(*b_x))); + assert_eq!(*b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x))); x = @F {f: ~4}; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(*b_x)) as uint); - assert!(*b_x == 3); + assert_eq!(*b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs index ad0c5b69ba8..17f9dcb627d 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x = @mut @F {f: ~3}; match x { @@F{f: ref b_x} => { - assert!(**b_x == 3); - assert!(ptr::to_unsafe_ptr(&(x.f)) == ptr::to_unsafe_ptr(b_x)); + assert_eq!(**b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(x.f)), ptr::to_unsafe_ptr(b_x)); *x = @F {f: ~4}; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(**b_x)) as uint); - assert!(**b_x == 3); + assert_eq!(**b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(**b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs index cce08ab2356..25bc5c0c982 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - assert!(before == after); + assert_eq!(before, after); } struct F { f: ~int } @@ -22,13 +22,13 @@ struct F { f: ~int } pub fn main() { let mut x = ~@F{f: ~3}; do borrow(x.f) |b_x| { - assert!(*b_x == 3); - assert!(ptr::to_unsafe_ptr(&(*x.f)) == ptr::to_unsafe_ptr(&(*b_x))); + assert_eq!(*b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x))); *x = @F{f: ~4}; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(*b_x)) as uint); - assert!(*b_x == 3); + assert_eq!(*b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs index 104b0ae6bc5..5f4d907e962 100644 --- a/src/test/run-pass/borrowck-preserve-box.rs +++ b/src/test/run-pass/borrowck-preserve-box.rs @@ -14,19 +14,19 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - assert!(before == after); + assert_eq!(before, after); } pub fn main() { let mut x = @3; do borrow(x) |b_x| { - assert!(*b_x == 3); - assert!(ptr::to_unsafe_ptr(&(*x)) == ptr::to_unsafe_ptr(&(*b_x))); + assert_eq!(*b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(*x)), ptr::to_unsafe_ptr(&(*b_x))); x = @22; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(*b_x)) as uint); - assert!(*b_x == 3); + assert_eq!(*b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x)) != ptr::to_unsafe_ptr(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-cond-box.rs b/src/test/run-pass/borrowck-preserve-cond-box.rs index 18c185cfef1..d9adcbb06f1 100644 --- a/src/test/run-pass/borrowck-preserve-cond-box.rs +++ b/src/test/run-pass/borrowck-preserve-cond-box.rs @@ -25,13 +25,13 @@ fn testfn(cond: bool) { } debug!("*r = %d, exp = %d", *r, exp); - assert!(*r == exp); + assert_eq!(*r, exp); x = @5; y = @6; debug!("*r = %d, exp = %d", *r, exp); - assert!(*r == exp); + assert_eq!(*r, exp); } pub fn main() { diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs index 4c5b9f9bf1f..ac1463caddf 100644 --- a/src/test/run-pass/borrowck-preserve-expl-deref.rs +++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - assert!(before == after); + assert_eq!(before, after); } struct F { f: ~int } @@ -22,13 +22,13 @@ struct F { f: ~int } pub fn main() { let mut x = @F {f: ~3}; do borrow((*x).f) |b_x| { - assert!(*b_x == 3); - assert!(ptr::to_unsafe_ptr(&(*x.f)) == ptr::to_unsafe_ptr(&(*b_x))); + assert_eq!(*b_x, 3); + assert_eq!(ptr::to_unsafe_ptr(&(*x.f)), ptr::to_unsafe_ptr(&(*b_x))); x = @F {f: ~4}; debug!("ptr::to_unsafe_ptr(*b_x) = %x", ptr::to_unsafe_ptr(&(*b_x)) as uint); - assert!(*b_x == 3); + assert_eq!(*b_x, 3); assert!(ptr::to_unsafe_ptr(&(*x.f)) != ptr::to_unsafe_ptr(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-univariant-enum.rs b/src/test/run-pass/borrowck-univariant-enum.rs index 3ec061c2dea..bb8710aad48 100644 --- a/src/test/run-pass/borrowck-univariant-enum.rs +++ b/src/test/run-pass/borrowck-univariant-enum.rs @@ -25,5 +25,5 @@ pub fn main() { *x * b } }; - assert!(z == 18); + assert_eq!(z, 18); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs index d49ea86402a..4e9ba6d3158 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs @@ -10,7 +10,7 @@ pub fn main() { let (&x, &y, &z) = (&3, &'a', &@"No pets!"); - assert!(x == 3); - assert!(y == 'a'); - assert!(z == @"No pets!"); + assert_eq!(x, 3); + assert_eq!(y, 'a'); + assert_eq!(z, @"No pets!"); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index dc620d0733d..4775e5fe0a8 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-option.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs @@ -19,5 +19,5 @@ fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> { pub fn main() { let x = None; let y = Some(3); - assert!(select(&x, &y).get() == 3); + assert_eq!(select(&x, &y).get(), 3); } diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs index 44485b5c8df..e0af2e80508 100644 --- a/src/test/run-pass/borrowed-ptr-pattern.rs +++ b/src/test/run-pass/borrowed-ptr-pattern.rs @@ -15,7 +15,7 @@ fn foo<T:Copy>(x: &T) -> T{ } pub fn main() { - assert!(foo(&3) == 3); - assert!(foo(&'a') == 'a'); - assert!(foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool"); + assert_eq!(foo(&3), 3); + assert_eq!(foo(&'a'), 'a'); + assert_eq!(foo(&@"Dogs rule, cats drool"), @"Dogs rule, cats drool"); } diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index 96fc7b84bcd..e7dc4365679 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -18,5 +18,5 @@ pub fn main() { let foo: int = 17; let bfoo: Box<int> = Box {c: @foo}; debug!("see what's in our box"); - assert!((unbox::<int>(bfoo) == foo)); + assert_eq!(unbox::<int>(bfoo), foo); } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index a182dcf2ca0..da362c8194d 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -11,9 +11,9 @@ pub fn main() { let mut i = 0; while i < 20 { i += 1; if i == 10 { break; } } - assert!((i == 10)); + assert_eq!(i, 10); loop { i += 1; if i == 20 { break; } } - assert!((i == 20)); + assert_eq!(i, 20); for vec::each(~[1, 2, 3, 4, 5, 6]) |x| { if *x == 3 { break; } assert!((*x <= 3)); } diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs index a87dbaab5c9..ec204e7a4c2 100644 --- a/src/test/run-pass/c-stack-returning-int64.rs +++ b/src/test/run-pass/c-stack-returning-int64.rs @@ -29,7 +29,7 @@ fn atoll(s: ~str) -> i64 { pub fn main() { unsafe { - assert!(atol(~"1024") * 10 == atol(~"10240")); + assert_eq!(atol(~"1024") * 10, atol(~"10240")); assert!((atoll(~"11111111111111111") * 10i64) == atoll(~"111111111111111110")); } diff --git a/src/test/run-pass/call-closure-from-overloaded-op.rs b/src/test/run-pass/call-closure-from-overloaded-op.rs index 8832620c4bf..cc8d8e96195 100644 --- a/src/test/run-pass/call-closure-from-overloaded-op.rs +++ b/src/test/run-pass/call-closure-from-overloaded-op.rs @@ -13,5 +13,5 @@ fn foo() -> int { 22 } pub fn main() { let mut x: ~[@fn() -> int] = ~[]; x.push(foo); - assert!((x[0])() == 22); + assert_eq!((x[0])(), 22); } diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs index 5d20990a5a9..19939650633 100644 --- a/src/test/run-pass/cap-clause-move.rs +++ b/src/test/run-pass/cap-clause-move.rs @@ -12,20 +12,20 @@ pub fn main() { let x = ~1; let y = ptr::to_unsafe_ptr(&(*x)) as uint; let lam_move: @fn() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint; - assert!(lam_move() == y); + assert_eq!(lam_move(), y); let x = ~2; let y = ptr::to_unsafe_ptr(&(*x)) as uint; let lam_move: @fn() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint; - assert!(lam_move() == y); + assert_eq!(lam_move(), y); let x = ~3; let y = ptr::to_unsafe_ptr(&(*x)) as uint; let snd_move: ~fn() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint; - assert!(snd_move() == y); + assert_eq!(snd_move(), y); let x = ~4; let y = ptr::to_unsafe_ptr(&(*x)) as uint; let lam_move: ~fn() -> uint = || ptr::to_unsafe_ptr(&(*x)) as uint; - assert!(lam_move() == y); + assert_eq!(lam_move(), y); } diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs index 1df1f3b4c8b..10407420a43 100644 --- a/src/test/run-pass/cast.rs +++ b/src/test/run-pass/cast.rs @@ -14,13 +14,13 @@ // -*- rust -*- pub fn main() { let i: int = 'Q' as int; - assert!((i == 0x51)); + assert_eq!(i, 0x51); let u: u32 = i as u32; - assert!((u == 0x51 as u32)); - assert!((u == 'Q' as u32)); - assert!((i as u8 == 'Q' as u8)); - assert!((i as u8 as i8 == 'Q' as u8 as i8)); - assert!((0x51 as char == 'Q')); - assert!((true == 1 as bool)); - assert!((0 as u32 == false as u32)); + assert_eq!(u, 0x51 as u32); + assert_eq!(u, 'Q' as u32); + assert_eq!(i as u8, 'Q' as u8); + assert_eq!(i as u8 as i8, 'Q' as u8 as i8); + assert_eq!(0x51 as char, 'Q'); + assert_eq!(true, 1 as bool); + assert_eq!(0 as u32, false as u32); } diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs index e6ec46acd23..460d6136caf 100644 --- a/src/test/run-pass/cci_borrow.rs +++ b/src/test/run-pass/cci_borrow.rs @@ -18,5 +18,5 @@ pub fn main() { let p = @22u; let r = foo(p); debug!("r=%u", r); - assert!(r == 22u); + assert_eq!(r, 22u); } diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs index 847d8a4d1f9..231cd37db5d 100644 --- a/src/test/run-pass/cci_nested_exe.rs +++ b/src/test/run-pass/cci_nested_exe.rs @@ -18,12 +18,12 @@ pub fn main() { let lst = new_int_alist(); alist_add(&lst, 22, ~"hi"); alist_add(&lst, 44, ~"ho"); - assert!(alist_get(&lst, 22) == ~"hi"); - assert!(alist_get(&lst, 44) == ~"ho"); + assert_eq!(alist_get(&lst, 22), ~"hi"); + assert_eq!(alist_get(&lst, 44), ~"ho"); let lst = new_int_alist_2(); alist_add(&lst, 22, ~"hi"); alist_add(&lst, 44, ~"ho"); - assert!(alist_get(&lst, 22) == ~"hi"); - assert!(alist_get(&lst, 44) == ~"ho"); + assert_eq!(alist_get(&lst, 22), ~"hi"); + assert_eq!(alist_get(&lst, 44), ~"ho"); } diff --git a/src/test/run-pass/cfgs-on-items.rs b/src/test/run-pass/cfgs-on-items.rs index ed025623ac3..237fa3f7ea9 100644 --- a/src/test/run-pass/cfgs-on-items.rs +++ b/src/test/run-pass/cfgs-on-items.rs @@ -26,6 +26,6 @@ fn foo2() -> int { 3 } fn main() { - assert!(1 == foo1()); - assert!(3 == foo2()); + assert_eq!(1, foo1()); + assert_eq!(3, foo2()); } diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs index bcfc6a3ccd9..f982d3723b4 100644 --- a/src/test/run-pass/char.rs +++ b/src/test/run-pass/char.rs @@ -13,11 +13,11 @@ pub fn main() { let c: char = 'x'; let d: char = 'x'; - assert!((c == 'x')); - assert!(('x' == c)); - assert!((c == c)); - assert!((c == d)); - assert!((d == c)); - assert!((d == 'x')); - assert!(('x' == d)); + assert_eq!(c, 'x'); + assert_eq!('x', c); + assert_eq!(c, c); + assert_eq!(c, d); + assert_eq!(d, c); + assert_eq!(d, 'x'); + assert_eq!('x', d); } diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs index 76f4e3b68f7..8bedfef89d0 100644 --- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs +++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs @@ -17,7 +17,7 @@ use cci_class_cast::kitty::*; fn print_out(thing: @ToStr, expected: ~str) { let actual = thing.to_str(); debug!("%s", actual); - assert!((actual == expected)); + assert_eq!(actual, expected); } pub fn main() { diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate.rs b/src/test/run-pass/class-cast-to-trait-cross-crate.rs index 10cce8cf56a..6674147e147 100644 --- a/src/test/run-pass/class-cast-to-trait-cross-crate.rs +++ b/src/test/run-pass/class-cast-to-trait-cross-crate.rs @@ -51,7 +51,7 @@ class cat : to_str { fn print_out<T:to_str>(thing: T, expected: str) { let actual = thing.to_str(); debug!("%s", actual); - assert!((actual == expected)); + assert_eq!(actual, expected); } pub fn main() { diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs index be63e339478..051c09fac53 100644 --- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs +++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs @@ -88,6 +88,6 @@ pub fn main() { let whitefang : dog = dog(); annoy_neighbors(@(copy nyan) as @noisy); annoy_neighbors(@(copy whitefang) as @noisy); - assert!((nyan.meow_count() == 10u)); - assert!((*whitefang.volume == 1)); + assert_eq!(nyan.meow_count(), 10u); + assert_eq!(*whitefang.volume, 1); } diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs index 6684a729d23..eb2c26478b6 100644 --- a/src/test/run-pass/class-exports.rs +++ b/src/test/run-pass/class-exports.rs @@ -34,5 +34,5 @@ mod kitty { } pub fn main() { - assert!((cat(~"Spreckles").get_name() == ~"Spreckles")); + assert_eq!(cat(~"Spreckles").get_name(), ~"Spreckles"); } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index f7d526cde91..ae3d088c539 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -136,11 +136,11 @@ priv impl<T> cat<T> { pub fn main() { let mut nyan: cat<~str> = cat::new(0, 2, ~"nyan"); for uint::range(1, 5) |_| { nyan.speak(); } - assert!((*nyan.find(&1).unwrap() == ~"nyan")); - assert!((nyan.find(&10) == None)); + assert!(*nyan.find(&1).unwrap() == ~"nyan"); + assert_eq!(nyan.find(&10), None); let mut spotty: cat<cat_type> = cat::new(2, 57, tuxedo); for uint::range(0, 6) |_| { spotty.speak(); } - assert!((spotty.len() == 8)); + assert_eq!(spotty.len(), 8); assert!((spotty.contains_key(&2))); - assert!((spotty.get(&3) == &tuxedo)); + assert_eq!(spotty.get(&3), &tuxedo); } diff --git a/src/test/run-pass/class-implements-multiple-traits.rs b/src/test/run-pass/class-implements-multiple-traits.rs index 61dfcfed7bd..9545f5340df 100644 --- a/src/test/run-pass/class-implements-multiple-traits.rs +++ b/src/test/run-pass/class-implements-multiple-traits.rs @@ -123,7 +123,7 @@ fn scratched_something<T:scratchy>(critter: T) -> bool { pub fn main() { let nyan : cat = cat(0u, 2, "nyan"); annoy_neighbors(nyan as noisy); - assert!((nyan.meow_count() == 10u)); + assert_eq!(nyan.meow_count(), 10u); assert!((bite_everything(nyan as bitey))); assert!((scratched_something(nyan as scratchy))); } diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs index a6ab91a2c88..d2c78c7f1ad 100644 --- a/src/test/run-pass/class-method-cross-crate.rs +++ b/src/test/run-pass/class-method-cross-crate.rs @@ -16,7 +16,7 @@ use cci_class_2::kitties::*; pub fn main() { let nyan : cat = cat(52u, 99); let kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(); } diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs index 8e5843c6a85..c5e37cab2b8 100644 --- a/src/test/run-pass/class-methods-cross-crate.rs +++ b/src/test/run-pass/class-methods-cross-crate.rs @@ -16,8 +16,8 @@ use cci_class_3::kitties::*; pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(); - assert!((nyan.meow_count() == 53u)); + assert_eq!(nyan.meow_count(), 53u); } diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs index 1c4c83999f7..fa358f4b132 100644 --- a/src/test/run-pass/class-methods.rs +++ b/src/test/run-pass/class-methods.rs @@ -29,8 +29,8 @@ fn cat(in_x: uint, in_y: int) -> cat { pub fn main() { let mut nyan: cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(); - assert!((nyan.meow_count() == 53u)); + assert_eq!(nyan.meow_count(), 53u); } diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs index cde171a44e2..62ff5438895 100644 --- a/src/test/run-pass/class-poly-methods-cross-crate.rs +++ b/src/test/run-pass/class-poly-methods-cross-crate.rs @@ -16,10 +16,10 @@ use cci_class_6::kitties::*; pub fn main() { let mut nyan : cat<char> = cat::<char>(52u, 99, ~['p']); let mut kitty = cat(1000u, 2, ~[~"tabby"]); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(~[1u,2u,3u]); - assert!((nyan.meow_count() == 55u)); + assert_eq!(nyan.meow_count(), 55u); kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); - assert!((kitty.meow_count() == 1004u)); + assert_eq!(kitty.meow_count(), 1004u); } diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index 9774d8d1488..f538eb054a6 100644 --- a/src/test/run-pass/class-poly-methods.rs +++ b/src/test/run-pass/class-poly-methods.rs @@ -33,10 +33,10 @@ fn cat<U>(in_x : uint, in_y : int, in_info: ~[U]) -> cat<U> { pub fn main() { let mut nyan : cat<int> = cat::<int>(52u, 99, ~[9]); let mut kitty = cat(1000u, 2, ~[~"tabby"]); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(~[1,2,3]); - assert!((nyan.meow_count() == 55u)); + assert_eq!(nyan.meow_count(), 55u); kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); - assert!((kitty.meow_count() == 1004u)); + assert_eq!(kitty.meow_count(), 1004u); } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index e058b3331b3..1952520d018 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -62,7 +62,7 @@ impl ToStr for cat { fn print_out(thing: @ToStr, expected: ~str) { let actual = thing.to_str(); debug!("%s", actual); - assert!((actual == expected)); + assert_eq!(actual, expected); } pub fn main() { diff --git a/src/test/run-pass/class-trait-bounded-param.rs b/src/test/run-pass/class-trait-bounded-param.rs index e1929d33d5b..0246946102b 100644 --- a/src/test/run-pass/class-trait-bounded-param.rs +++ b/src/test/run-pass/class-trait-bounded-param.rs @@ -31,5 +31,5 @@ pub fn main() { let m = int_hash(); m.insert(1, 2); m.insert(3, 4); - assert!(old_iter::to_vec(keys(m)) == ~[1, 3]); + assert_eq!(old_iter::to_vec(keys(m)), ~[1, 3]); } diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs index 6c35d113e0e..0df04c40fb7 100644 --- a/src/test/run-pass/classes-simple-cross-crate.rs +++ b/src/test/run-pass/classes-simple-cross-crate.rs @@ -16,6 +16,6 @@ use cci_class::kitties::*; pub fn main() { let nyan : cat = cat(52u, 99); let kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); } diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs index cd318ab6c6b..9de1066ec57 100644 --- a/src/test/run-pass/classes-simple-method.rs +++ b/src/test/run-pass/classes-simple-method.rs @@ -28,7 +28,7 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); nyan.speak(); } diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs index 0af281bdce4..3d2b08d7a85 100644 --- a/src/test/run-pass/classes-simple.rs +++ b/src/test/run-pass/classes-simple.rs @@ -24,6 +24,6 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - assert!((nyan.how_hungry == 99)); - assert!((kitty.how_hungry == 2)); + assert_eq!(nyan.how_hungry, 99); + assert_eq!(kitty.how_hungry, 2); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index ae2983b1594..091f955aca0 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -20,8 +20,8 @@ pub fn main() { let z = ~Pair { a : 10, b : 12}; let f: ~fn() = || { - assert!((z.a == 10)); - assert!((z.b == 12)); + assert_eq!(z.a, 10); + assert_eq!(z.b, 12); }; spawn(f); diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs index 0cff05ed19f..736c0f91941 100644 --- a/src/test/run-pass/close-over-big-then-small-data.rs +++ b/src/test/run-pass/close-over-big-then-small-data.rs @@ -24,6 +24,6 @@ fn f<A:Copy + 'static>(a: A, b: u16) -> @fn() -> (A, u16) { pub fn main() { let (a, b) = f(22_u64, 44u16)(); debug!("a=%? b=%?", a, b); - assert!(a == 22u64); - assert!(b == 44u16); + assert_eq!(a, 22u64); + assert_eq!(b, 44u16); } diff --git a/src/test/run-pass/closure-inference.rs b/src/test/run-pass/closure-inference.rs index 6cdb8f393d5..167fbdf3fc0 100644 --- a/src/test/run-pass/closure-inference.rs +++ b/src/test/run-pass/closure-inference.rs @@ -16,5 +16,5 @@ fn apply<A>(f: &fn(A) -> A, v: A) -> A { f(v) } pub fn main() { let f = {|i| foo(i)}; - assert!(apply(f, 2) == 3); + assert_eq!(apply(f, 2), 3); } diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs index 4e297239445..fa16ea00145 100644 --- a/src/test/run-pass/closure-inference2.rs +++ b/src/test/run-pass/closure-inference2.rs @@ -12,6 +12,6 @@ pub fn main() { let f = {|i| i}; - assert!(f(2) == 2); - assert!(f(5) == 5); + assert_eq!(f(2), 2); + assert_eq!(f(5), 5); } diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs index c4bed1e7d7d..6c78cd250dd 100644 --- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs @@ -12,5 +12,5 @@ fn foo(speaker: &const SpeechMaker) -> uint { pub fn main() { let mut lincoln = SpeechMaker {speeches: 22}; - assert!(foo(&const lincoln) == 55); + assert_eq!(foo(&const lincoln), 55); } diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs index 1511eab8241..7ab80920849 100644 --- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs @@ -14,7 +14,7 @@ fn bip(v: &[uint]) -> ~[uint] { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; - assert!(the_vec == foo(the_vec)); - assert!(the_vec == bar(the_vec)); - assert!(the_vec == bip(the_vec)); + assert_eq!(the_vec, foo(the_vec)); + assert_eq!(the_vec, bar(the_vec)); + assert_eq!(the_vec, bip(the_vec)); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index bfc1de4d1e7..18a28722c70 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -11,5 +11,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; bar(the_vec); - assert!(the_vec == ~[100, 3, 2, 1]); + assert_eq!(the_vec, ~[100, 3, 2, 1]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index b0d06dae10d..aa787328c41 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -17,5 +17,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; bar(the_vec); - assert!(the_vec == ~[100, 3, 2, 1]); + assert_eq!(the_vec, ~[100, 3, 2, 1]); } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index a01b06d4d7c..510976c5646 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -17,7 +17,7 @@ pub fn main() { let y = p.recv(); error!("received"); error!(y); - assert!((y == 10)); + assert_eq!(y, 10); } fn child(c: &Chan<int>) { diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs index 73fdb219c19..3fe33eae84d 100644 --- a/src/test/run-pass/conditional-compile.rs +++ b/src/test/run-pass/conditional-compile.rs @@ -104,7 +104,7 @@ fn test_in_fn_ctxt() { #[cfg(bogus)] static i: int = 0; static i: int = 1; - assert!((i == 1)); + assert_eq!(i, 1); } mod test_foreign_items { diff --git a/src/test/run-pass/const-autoderef-newtype.rs b/src/test/run-pass/const-autoderef-newtype.rs index 021196bf707..19dea653a4a 100644 --- a/src/test/run-pass/const-autoderef-newtype.rs +++ b/src/test/run-pass/const-autoderef-newtype.rs @@ -13,5 +13,5 @@ static C0: S = S([3]); static C1: int = C0[0]; pub fn main() { - assert!(C1 == 3); + assert_eq!(C1, 3); } diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs index a7f9b57718c..e80ed7c984b 100644 --- a/src/test/run-pass/const-autoderef.rs +++ b/src/test/run-pass/const-autoderef.rs @@ -14,6 +14,6 @@ static C: &'static &'static &'static &'static [u8, ..1] = & & & &A; static D: u8 = (&C)[0]; pub fn main() { - assert!(B == A[0]); - assert!(D == A[0]); + assert_eq!(B, A[0]); + assert_eq!(D, A[0]); } diff --git a/src/test/run-pass/const-big-enum.rs b/src/test/run-pass/const-big-enum.rs index 3aa7fd475b0..ac2e879ceac 100644 --- a/src/test/run-pass/const-big-enum.rs +++ b/src/test/run-pass/const-big-enum.rs @@ -27,8 +27,8 @@ pub fn main() { } match Z { Quux(d,h) => { - assert!((d == 0x123456789abcdef0)); - assert!((h == 0x1234)); + assert_eq!(d, 0x123456789abcdef0); + assert_eq!(h, 0x1234); } _ => fail!() } diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs index ea5533da14d..3dc94936304 100644 --- a/src/test/run-pass/const-cast-ptr-int.rs +++ b/src/test/run-pass/const-cast-ptr-int.rs @@ -11,5 +11,5 @@ static a: *u8 = 0 as *u8; pub fn main() { - assert!(a == ptr::null()); + assert_eq!(a, ptr::null()); } diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs index d35ad9d2da3..1c8e92b91cd 100644 --- a/src/test/run-pass/const-cast.rs +++ b/src/test/run-pass/const-cast.rs @@ -16,6 +16,6 @@ static a: &'static int = &10; static b: *int = a as *int; pub fn main() { - assert!(x as *libc::c_void == y); - assert!(a as *int == b); + assert_eq!(x as *libc::c_void, y); + assert_eq!(a as *int, b); } diff --git a/src/test/run-pass/const-const.rs b/src/test/run-pass/const-const.rs index e68bf8a74c3..bdb2b3d2110 100644 --- a/src/test/run-pass/const-const.rs +++ b/src/test/run-pass/const-const.rs @@ -12,5 +12,5 @@ static a: int = 1; static b: int = a + 2; pub fn main() { - assert!(b == 3); + assert_eq!(b, 3); } diff --git a/src/test/run-pass/const-contents.rs b/src/test/run-pass/const-contents.rs index 19ce5b3713d..5b31c9a44de 100644 --- a/src/test/run-pass/const-contents.rs +++ b/src/test/run-pass/const-contents.rs @@ -18,10 +18,10 @@ static notb : bool = !true; static neg : int = -(1); pub fn main() { - assert!((lsl == 4)); - assert!((add == 3)); - assert!((addf == 3.0f)); - assert!((not == -1)); - assert!((notb == false)); - assert!((neg == -1)); + assert_eq!(lsl, 4); + assert_eq!(add, 3); + assert_eq!(addf, 3.0f); + assert_eq!(not, -1); + assert_eq!(notb, false); + assert_eq!(neg, -1); } diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs index 55975d364c8..607d0c72b89 100644 --- a/src/test/run-pass/const-cross-crate-const.rs +++ b/src/test/run-pass/const-cross-crate-const.rs @@ -17,9 +17,9 @@ static a: uint = cci_const::uint_val; static b: uint = cci_const::uint_expr + 5; fn main() { - assert!(a == 12); + assert_eq!(a, 12); let foo2 = a; - assert!(foo2 == cci_const::uint_val); - assert!(b == cci_const::uint_expr + 5); - assert!(foo == cci_const::foopy); + assert_eq!(foo2, cci_const::uint_val); + assert_eq!(b, cci_const::uint_expr + 5); + assert_eq!(foo, cci_const::foopy); } diff --git a/src/test/run-pass/const-cross-crate-extern.rs b/src/test/run-pass/const-cross-crate-extern.rs index bac84d12e4c..5281c217626 100644 --- a/src/test/run-pass/const-cross-crate-extern.rs +++ b/src/test/run-pass/const-cross-crate-extern.rs @@ -16,5 +16,5 @@ use cci_const::bar; static foo: *u8 = bar; pub fn main() { - assert!(foo == cci_const::bar); + assert_eq!(foo, cci_const::bar); } diff --git a/src/test/run-pass/const-deref.rs b/src/test/run-pass/const-deref.rs index ee98e60f4d6..b1797857d04 100644 --- a/src/test/run-pass/const-deref.rs +++ b/src/test/run-pass/const-deref.rs @@ -15,6 +15,6 @@ static E: &'static S = &S(C); static F: int = ***E; pub fn main() { - assert!(D == 1000); - assert!(F == 1000); + assert_eq!(D, 1000); + assert_eq!(F, 1000); } diff --git a/src/test/run-pass/const-enum-cast.rs b/src/test/run-pass/const-enum-cast.rs index 89990e9d892..616c7567adf 100644 --- a/src/test/run-pass/const-enum-cast.rs +++ b/src/test/run-pass/const-enum-cast.rs @@ -20,12 +20,12 @@ pub fn main () { let a2 = B2 as int; let a3 = A2 as float; let a4 = B2 as float; - assert!(c1 == 1); - assert!(c2 == 2); - assert!(c3 == 1.0); - assert!(c4 == 2.0); - assert!(a1 == 1); - assert!(a2 == 2); - assert!(a3 == 1.0); - assert!(a4 == 2.0); + assert_eq!(c1, 1); + assert_eq!(c2, 2); + assert_eq!(c3, 1.0); + assert_eq!(c4, 2.0); + assert_eq!(a1, 1); + assert_eq!(a2, 2); + assert_eq!(a3, 1.0); + assert_eq!(a4, 2.0); } diff --git a/src/test/run-pass/const-enum-struct.rs b/src/test/run-pass/const-enum-struct.rs index b6d916a9c38..3229293fd7a 100644 --- a/src/test/run-pass/const-enum-struct.rs +++ b/src/test/run-pass/const-enum-struct.rs @@ -15,5 +15,5 @@ static C: S = S { a: V16(0xDEAD), b: 0x600D, c: 0xBAD }; pub fn main() { let n = C.b; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-enum-struct2.rs b/src/test/run-pass/const-enum-struct2.rs index 3d9f7fc2044..4530a650027 100644 --- a/src/test/run-pass/const-enum-struct2.rs +++ b/src/test/run-pass/const-enum-struct2.rs @@ -15,5 +15,5 @@ static C: S = S { a: V0, b: 0x600D, c: 0xBAD }; pub fn main() { let n = C.b; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-enum-tuple.rs b/src/test/run-pass/const-enum-tuple.rs index ade3dfd6b63..17d8341457d 100644 --- a/src/test/run-pass/const-enum-tuple.rs +++ b/src/test/run-pass/const-enum-tuple.rs @@ -14,5 +14,5 @@ static C: (E, u16, u16) = (V16(0xDEAD), 0x600D, 0xBAD); pub fn main() { let (_, n, _) = C; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-enum-tuple2.rs b/src/test/run-pass/const-enum-tuple2.rs index 14da9438af0..5d7a161720c 100644 --- a/src/test/run-pass/const-enum-tuple2.rs +++ b/src/test/run-pass/const-enum-tuple2.rs @@ -14,5 +14,5 @@ static C: (E, u16, u16) = (V0, 0x600D, 0xBAD); pub fn main() { let (_, n, _) = C; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-enum-tuplestruct.rs b/src/test/run-pass/const-enum-tuplestruct.rs index 885664f7ef0..40137afa2ee 100644 --- a/src/test/run-pass/const-enum-tuplestruct.rs +++ b/src/test/run-pass/const-enum-tuplestruct.rs @@ -15,5 +15,5 @@ static C: S = S(V16(0xDEAD), 0x600D, 0xBAD); pub fn main() { let S(_, n, _) = C; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-enum-tuplestruct2.rs b/src/test/run-pass/const-enum-tuplestruct2.rs index ad4befd92d1..f6345efcb43 100644 --- a/src/test/run-pass/const-enum-tuplestruct2.rs +++ b/src/test/run-pass/const-enum-tuplestruct2.rs @@ -15,5 +15,5 @@ static C: S = S(V0, 0x600D, 0xBAD); pub fn main() { let S(_, n, _) = C; assert!(n != 0xBAD); - assert!(n == 0x600D); + assert_eq!(n, 0x600D); } diff --git a/src/test/run-pass/const-extern-function.rs b/src/test/run-pass/const-extern-function.rs index a9d036f1219..9a8104cb14f 100644 --- a/src/test/run-pass/const-extern-function.rs +++ b/src/test/run-pass/const-extern-function.rs @@ -18,6 +18,6 @@ struct S { } pub fn main() { - assert!(foopy == f); - assert!(f == s.f); + assert_eq!(foopy, f); + assert_eq!(f, s.f); } diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs index 014ec19d565..ccc7b486d1e 100644 --- a/src/test/run-pass/const-fields-and-indexing.rs +++ b/src/test/run-pass/const-fields-and-indexing.rs @@ -28,7 +28,7 @@ pub fn main() { io::println(fmt!("%?", p)); io::println(fmt!("%?", q)); io::println(fmt!("%?", t)); - assert!(p == 3); - assert!(q == 3); - assert!(t == 20); + assert_eq!(p, 3); + assert_eq!(q, 3); + assert_eq!(t, 20); } diff --git a/src/test/run-pass/const-fn-val.rs b/src/test/run-pass/const-fn-val.rs index 544d6714312..dfcfb30f77f 100644 --- a/src/test/run-pass/const-fn-val.rs +++ b/src/test/run-pass/const-fn-val.rs @@ -17,5 +17,5 @@ struct Bar<'self> { f: &'self fn() -> int } static b : Bar<'static> = Bar { f: foo }; pub fn main() { - assert!((b.f)() == 0xca7f000d); + assert_eq!((b.f)(), 0xca7f000d); } diff --git a/src/test/run-pass/const-negative.rs b/src/test/run-pass/const-negative.rs index e4905d5c532..4e2be013c11 100644 --- a/src/test/run-pass/const-negative.rs +++ b/src/test/run-pass/const-negative.rs @@ -13,5 +13,5 @@ static toplevel_mod: int = -1; pub fn main() { - assert!(toplevel_mod == -1); + assert_eq!(toplevel_mod, -1); } diff --git a/src/test/run-pass/const-nullary-univariant-enum.rs b/src/test/run-pass/const-nullary-univariant-enum.rs index 0d0674aa962..30fbe38aed0 100644 --- a/src/test/run-pass/const-nullary-univariant-enum.rs +++ b/src/test/run-pass/const-nullary-univariant-enum.rs @@ -15,8 +15,8 @@ enum Foo { static X: Foo = Bar; pub fn main() { - assert!(((X as uint) == 0xDEADBEE)); - assert!(((Y as uint) == 0xDEADBEE)); + assert_eq!((X as uint), 0xDEADBEE); + assert_eq!((Y as uint), 0xDEADBEE); } static Y: Foo = Bar; diff --git a/src/test/run-pass/const-rec-and-tup.rs b/src/test/run-pass/const-rec-and-tup.rs index 557fa427e43..acb7fa2f0f4 100644 --- a/src/test/run-pass/const-rec-and-tup.rs +++ b/src/test/run-pass/const-rec-and-tup.rs @@ -20,6 +20,6 @@ static y : AnotherPair = AnotherPair{ x: (0xf0f0f0f0_f0f0f0f0, pub fn main() { let (p, _) = y.x; - assert!(p == - 1085102592571150096); + assert_eq!(p, - 1085102592571150096); io::println(fmt!("0x%x", p as uint)); } diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs index b8812649fd1..14397569ad9 100644 --- a/src/test/run-pass/const-region-ptrs-noncopy.rs +++ b/src/test/run-pass/const-region-ptrs-noncopy.rs @@ -14,5 +14,5 @@ static x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]); static y: &'static Pair<'static> = &Pair {a: 15, b: x}; pub fn main() { - assert!(ptr::to_unsafe_ptr(x) == ptr::to_unsafe_ptr(y.b)); + assert_eq!(ptr::to_unsafe_ptr(x), ptr::to_unsafe_ptr(y.b)); } diff --git a/src/test/run-pass/const-region-ptrs.rs b/src/test/run-pass/const-region-ptrs.rs index a2bedc85cdd..12712844c8a 100644 --- a/src/test/run-pass/const-region-ptrs.rs +++ b/src/test/run-pass/const-region-ptrs.rs @@ -18,6 +18,6 @@ static y: &'static Pair<'static> = &Pair {a: 15, b: x}; pub fn main() { io::println(fmt!("x = %?", *x)); io::println(fmt!("y = {a: %?, b: %?}", y.a, *(y.b))); - assert!(*x == 10); - assert!(*(y.b) == 10); + assert_eq!(*x, 10); + assert_eq!(*(y.b), 10); } diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index 2f98036a5b1..48eb4d6ce59 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -14,9 +14,9 @@ static b: *u8 = c as *u8; pub fn main() { let foo = &a as *u8; - assert!(unsafe { str::raw::from_bytes(a) } == ~"hi\x00"); - assert!(unsafe { str::raw::from_buf(foo) } == ~"hi"); - assert!(unsafe { str::raw::from_buf(b) } == ~"hi"); + assert_eq!(unsafe { str::raw::from_bytes(a) }, ~"hi\x00"); + assert_eq!(unsafe { str::raw::from_buf(foo) }, ~"hi"); + assert_eq!(unsafe { str::raw::from_buf(b) }, ~"hi"); assert!(unsafe { *b == a[0] }); assert!(unsafe { *(&c[0] as *u8) == a[0] }); } diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs index f75b4321e90..24542f54922 100644 --- a/src/test/run-pass/const-struct.rs +++ b/src/test/run-pass/const-struct.rs @@ -25,9 +25,9 @@ static y : foo = foo { b:2, c:3, a: 1 }; static z : &'static foo = &foo { a: 10, b: 22, c: 12 }; pub fn main() { - assert!(x.b == 2); - assert!(x == y); - assert!(z.b == 22); + assert_eq!(x.b, 2); + assert_eq!(x, y); + assert_eq!(z.b, 22); io::println(fmt!("0x%x", x.b as uint)); io::println(fmt!("0x%x", z.c as uint)); } diff --git a/src/test/run-pass/const-tuple-struct.rs b/src/test/run-pass/const-tuple-struct.rs index 828c20912a1..54116dd4082 100644 --- a/src/test/run-pass/const-tuple-struct.rs +++ b/src/test/run-pass/const-tuple-struct.rs @@ -15,8 +15,8 @@ static X: Bar = Bar(1, 2); pub fn main() { match X { Bar(x, y) => { - assert!(x == 1); - assert!(y == 2); + assert_eq!(x, 1); + assert_eq!(y, 2); } } } diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs index 517ced302dd..134ee580425 100644 --- a/src/test/run-pass/const-vecs-and-slices.rs +++ b/src/test/run-pass/const-vecs-and-slices.rs @@ -14,7 +14,7 @@ static y : &'static [int] = &[1,2,3,4]; pub fn main() { io::println(fmt!("%?", x[1])); io::println(fmt!("%?", y[1])); - assert!(x[1] == 2); - assert!(x[3] == 4); - assert!(x[3] == y[3]); + assert_eq!(x[1], 2); + assert_eq!(x[3], 4); + assert_eq!(x[3], y[3]); } diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs index c0520cf737f..788c30562c1 100644 --- a/src/test/run-pass/consts-in-patterns.rs +++ b/src/test/run-pass/consts-in-patterns.rs @@ -18,5 +18,5 @@ pub fn main() { BAR => 2, _ => 3 }; - assert!(y == 2); + assert_eq!(y, 2); } diff --git a/src/test/run-pass/crateresolve1.rs b/src/test/run-pass/crateresolve1.rs index 1ddb955cee7..737a60470ad 100644 --- a/src/test/run-pass/crateresolve1.rs +++ b/src/test/run-pass/crateresolve1.rs @@ -16,5 +16,5 @@ extern mod crateresolve1(vers = "0.2"); pub fn main() { - assert!(crateresolve1::f() == 20); + assert_eq!(crateresolve1::f(), 20); } diff --git a/src/test/run-pass/crateresolve6.rs b/src/test/run-pass/crateresolve6.rs index 0263af55105..883f48656bc 100644 --- a/src/test/run-pass/crateresolve6.rs +++ b/src/test/run-pass/crateresolve6.rs @@ -18,6 +18,6 @@ extern mod cr6_1 (name = "crateresolve_calories", vers = "0.1", calories="100"); extern mod cr6_2 (name = "crateresolve_calories", vers = "0.1", calories="200"); pub fn main() { - assert!(cr6_1::f() == 100); - assert!(cr6_2::f() == 200); + assert_eq!(cr6_1::f(), 100); + assert_eq!(cr6_2::f(), 200); } diff --git a/src/test/run-pass/crateresolve7.rs b/src/test/run-pass/crateresolve7.rs index b54b5a0983f..86fc72aa489 100644 --- a/src/test/run-pass/crateresolve7.rs +++ b/src/test/run-pass/crateresolve7.rs @@ -16,6 +16,6 @@ extern mod crateresolve7x; pub fn main() { - assert!(crateresolve7x::a::f() == 100); - assert!(crateresolve7x::b::f() == 200); + assert_eq!(crateresolve7x::a::f(), 100); + assert_eq!(crateresolve7x::b::f(), 200); } diff --git a/src/test/run-pass/deriving-via-extension-c-enum.rs b/src/test/run-pass/deriving-via-extension-c-enum.rs index 81c4ce013f2..3c4fb6c8c81 100644 --- a/src/test/run-pass/deriving-via-extension-c-enum.rs +++ b/src/test/run-pass/deriving-via-extension-c-enum.rs @@ -18,7 +18,7 @@ enum Foo { pub fn main() { let a = Bar; let b = Bar; - assert!(a == b); + assert_eq!(a, b); assert!(!(a != b)); assert!(a.eq(&b)); assert!(!a.ne(&b)); diff --git a/src/test/run-pass/deriving-via-extension-enum.rs b/src/test/run-pass/deriving-via-extension-enum.rs index fac0d402a38..4044c58dc57 100644 --- a/src/test/run-pass/deriving-via-extension-enum.rs +++ b/src/test/run-pass/deriving-via-extension-enum.rs @@ -17,7 +17,7 @@ enum Foo { pub fn main() { let a = Bar(1, 2); let b = Bar(1, 2); - assert!(a == b); + assert_eq!(a, b); assert!(!(a != b)); assert!(a.eq(&b)); assert!(!a.ne(&b)); diff --git a/src/test/run-pass/deriving-via-extension-struct-empty.rs b/src/test/run-pass/deriving-via-extension-struct-empty.rs index 00b0c14369e..8f6a3197986 100644 --- a/src/test/run-pass/deriving-via-extension-struct-empty.rs +++ b/src/test/run-pass/deriving-via-extension-struct-empty.rs @@ -12,6 +12,6 @@ struct Foo; pub fn main() { - assert!(Foo == Foo); + assert_eq!(Foo, Foo); assert!(!(Foo != Foo)); } \ No newline at end of file diff --git a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs index 4ef8fb6b5d9..5189136c486 100644 --- a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs +++ b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs @@ -6,6 +6,6 @@ enum S { pub fn main() { let x = X { x: 1, y: 2 }; - assert!(x == x); + assert_eq!(x, x); assert!(!(x != x)); } diff --git a/src/test/run-pass/deriving-via-extension-struct-tuple.rs b/src/test/run-pass/deriving-via-extension-struct-tuple.rs index 906d69dbf53..cc76751e27f 100644 --- a/src/test/run-pass/deriving-via-extension-struct-tuple.rs +++ b/src/test/run-pass/deriving-via-extension-struct-tuple.rs @@ -17,10 +17,10 @@ pub fn main() { let b = Foo(5, 7, ~"def"); assert!(a1 == a1); - assert!(a1 == a2); + assert!(a2 == a1); assert!(!(a1 == b)); assert!(a1 != b); assert!(!(a1 != a1)); - assert!(!(a1 != a2)); + assert!(!(a2 != a1)); } diff --git a/src/test/run-pass/deriving-via-extension-struct.rs b/src/test/run-pass/deriving-via-extension-struct.rs index c0e7ee36b16..44aca59aa9c 100644 --- a/src/test/run-pass/deriving-via-extension-struct.rs +++ b/src/test/run-pass/deriving-via-extension-struct.rs @@ -18,7 +18,7 @@ struct Foo { pub fn main() { let a = Foo { x: 1, y: 2, z: 3 }; let b = Foo { x: 1, y: 2, z: 3 }; - assert!(a == b); + assert_eq!(a, b); assert!(!(a != b)); assert!(a.eq(&b)); assert!(!a.ne(&b)); diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs index 85a89c62989..ecc30555162 100644 --- a/src/test/run-pass/deriving-via-extension-type-params.rs +++ b/src/test/run-pass/deriving-via-extension-type-params.rs @@ -21,7 +21,7 @@ struct Foo<T> { pub fn main() { let a = Foo { x: 1, y: 2.0, z: 3 }; let b = Foo { x: 1, y: 2.0, z: 3 }; - assert!(a == b); + assert_eq!(a, b); assert!(!(a != b)); assert!(a.eq(&b)); assert!(!a.ne(&b)); diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs index bf1d6e3c060..3aeaef01e18 100644 --- a/src/test/run-pass/div-mod.rs +++ b/src/test/run-pass/div-mod.rs @@ -15,14 +15,14 @@ pub fn main() { let x: int = 15; let y: int = 5; - assert!((x / 5 == 3)); - assert!((x / 4 == 3)); - assert!((x / 3 == 5)); - assert!((x / y == 3)); - assert!((15 / y == 3)); - assert!((x % 5 == 0)); - assert!((x % 4 == 3)); - assert!((x % 3 == 0)); - assert!((x % y == 0)); - assert!((15 % y == 0)); + assert_eq!(x / 5, 3); + assert_eq!(x / 4, 3); + assert_eq!(x / 3, 5); + assert_eq!(x / y, 3); + assert_eq!(15 / y, 3); + assert_eq!(x % 5, 0); + assert_eq!(x % 4, 3); + assert_eq!(x % 3, 0); + assert_eq!(x % y, 0); + assert_eq!(15 % y, 0); } diff --git a/src/test/run-pass/do2.rs b/src/test/run-pass/do2.rs index ee1321e9d00..684a2c108eb 100644 --- a/src/test/run-pass/do2.rs +++ b/src/test/run-pass/do2.rs @@ -11,5 +11,5 @@ fn f(f: @fn(int) -> int) -> int { f(10) } pub fn main() { - assert!(do f() |i| { i } == 10); + assert_eq!(do f() |i| { i }, 10); } diff --git a/src/test/run-pass/do3.rs b/src/test/run-pass/do3.rs index 7cbf49a3486..b0d49fd2bdd 100644 --- a/src/test/run-pass/do3.rs +++ b/src/test/run-pass/do3.rs @@ -11,5 +11,5 @@ fn f(f: @fn(int) -> int) -> int { f(10) } pub fn main() { - assert!(do f |i| { i } == 10); + assert_eq!(do f |i| { i }, 10); } diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs index f1b89f2bb1d..a8822e9a3fc 100644 --- a/src/test/run-pass/empty-tag.rs +++ b/src/test/run-pass/empty-tag.rs @@ -18,7 +18,7 @@ impl cmp::Eq for chan { } fn wrapper3(i: chan) { - assert!(i == chan_t); + assert_eq!(i, chan_t); } pub fn main() { diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs index 27a1b951413..a851141322f 100644 --- a/src/test/run-pass/estr-slice.rs +++ b/src/test/run-pass/estr-slice.rs @@ -17,11 +17,11 @@ pub fn main() { debug!(x); debug!(y); - assert!(x[0] == 'h' as u8); - assert!(x[4] == 'o' as u8); + assert_eq!(x[0], 'h' as u8); + assert_eq!(x[4], 'o' as u8); let z : &str = &"thing"; - assert!(v == x); + assert_eq!(v, x); assert!(x != z); let a = &"aaaa"; diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs index 5e23fd0f751..a096a845673 100644 --- a/src/test/run-pass/estr-uniq.rs +++ b/src/test/run-pass/estr-uniq.rs @@ -13,6 +13,6 @@ pub fn main() { let _y : ~str = ~"there"; let mut z = ~"thing"; z = x; - assert!(z[0] == ('h' as u8)); - assert!(z[4] == ('o' as u8)); + assert_eq!(z[0], ('h' as u8)); + assert_eq!(z[4], ('o' as u8)); } diff --git a/src/test/run-pass/evec-internal-boxes.rs b/src/test/run-pass/evec-internal-boxes.rs index 7b51b803136..64c8a4caf80 100644 --- a/src/test/run-pass/evec-internal-boxes.rs +++ b/src/test/run-pass/evec-internal-boxes.rs @@ -13,6 +13,6 @@ pub fn main() { let _y : [@int, ..5] = [@1,@2,@3,@4,@5]; let mut z = [@1,@2,@3,@4,@5]; z = x; - assert!(*z[0] == 1); - assert!(*z[4] == 5); + assert_eq!(*z[0], 1); + assert_eq!(*z[4], 5); } diff --git a/src/test/run-pass/evec-internal.rs b/src/test/run-pass/evec-internal.rs index 39a4397f84e..6c3dfb2cb3d 100644 --- a/src/test/run-pass/evec-internal.rs +++ b/src/test/run-pass/evec-internal.rs @@ -18,8 +18,8 @@ pub fn main() { let _y : [int, ..5] = [1,2,3,4,5]; let mut z = [1,2,3,4,5]; z = x; - assert!(z[0] == 1); - assert!(z[4] == 5); + assert_eq!(z[0], 1); + assert_eq!(z[4], 5); let a : [int, ..5] = [1,1,1,1,1]; let b : [int, ..5] = [2,2,2,2,2]; diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs index 28bac56b05e..194560ab127 100644 --- a/src/test/run-pass/evec-slice.rs +++ b/src/test/run-pass/evec-slice.rs @@ -12,8 +12,8 @@ pub fn main() { let x : &[int] = &[1,2,3,4,5]; let mut z = &[1,2,3,4,5]; z = x; - assert!(z[0] == 1); - assert!(z[4] == 5); + assert_eq!(z[0], 1); + assert_eq!(z[4], 5); let a : &[int] = &[1,1,1,1,1]; let b : &[int] = &[2,2,2,2,2]; diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index 486186e9fe0..2043a170aba 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -12,5 +12,5 @@ // exec-env:TEST_EXEC_ENV=22 pub fn main() { - assert!(os::getenv(~"TEST_EXEC_ENV") == Some(~"22")); + assert_eq!(os::getenv(~"TEST_EXEC_ENV"), Some(~"22")); } diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs index ac19592accf..ad8af0ce639 100644 --- a/src/test/run-pass/explicit-self-generic.rs +++ b/src/test/run-pass/explicit-self-generic.rs @@ -38,5 +38,5 @@ pub impl<K,V> HashMap<K,V> { pub fn main() { let mut m = ~linear_map::<(),()>(); - assert!(m.len() == 0); + assert_eq!(m.len(), 0); } diff --git a/src/test/run-pass/explicit-self-objects-box.rs b/src/test/run-pass/explicit-self-objects-box.rs index 12a1780e029..9010dd34ffe 100644 --- a/src/test/run-pass/explicit-self-objects-box.rs +++ b/src/test/run-pass/explicit-self-objects-box.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(@self) { - assert!(self.x == 3); + assert_eq!(self.x, 3); } } diff --git a/src/test/run-pass/explicit-self-objects-simple.rs b/src/test/run-pass/explicit-self-objects-simple.rs index 814365a8354..6092c386dbb 100644 --- a/src/test/run-pass/explicit-self-objects-simple.rs +++ b/src/test/run-pass/explicit-self-objects-simple.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(&self) { - assert!(self.x == 3); + assert_eq!(self.x, 3); } } diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs index dadf53fb9bc..69ca98eb018 100644 --- a/src/test/run-pass/explicit-self-objects-uniq.rs +++ b/src/test/run-pass/explicit-self-objects-uniq.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(~self) { - assert!(self.x == 3); + assert_eq!(self.x, 3); } } diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index 7e46bf22c4d..6ae99f64cf0 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -68,13 +68,13 @@ impl Nus for thing { fn f(&self) {} } pub fn main() { let x = @thing(A {a: @10}); - assert!(x.foo() == 10); - assert!(x.quux() == 10); + assert_eq!(x.foo(), 10); + assert_eq!(x.quux(), 10); let y = ~thing(A {a: @10}); - assert!((copy y).bar() == 10); - assert!(y.quux() == 10); + assert_eq!((copy y).bar(), 10); + assert_eq!(y.quux(), 10); let z = thing(A {a: @11}); - assert!(z.spam() == 11); + assert_eq!(z.spam(), 11); } diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs index 2e65bb86655..84a78637187 100644 --- a/src/test/run-pass/expr-alt-box.rs +++ b/src/test/run-pass/expr-alt-box.rs @@ -16,13 +16,13 @@ // Tests for match as expressions resulting in boxed types fn test_box() { let res = match true { true => { @100 } _ => fail!("wat") }; - assert!((*res == 100)); + assert_eq!(*res, 100); } fn test_str() { let res = match true { true => { ~"happy" }, _ => fail!("not happy at all") }; - assert!((res == ~"happy")); + assert_eq!(res, ~"happy"); } pub fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/expr-alt-fail.rs b/src/test/run-pass/expr-alt-fail.rs index 4391856230f..3e1b96763e1 100644 --- a/src/test/run-pass/expr-alt-fail.rs +++ b/src/test/run-pass/expr-alt-fail.rs @@ -10,12 +10,12 @@ fn test_simple() { let r = match true { true => { true } false => { fail!() } }; - assert!((r == true)); + assert_eq!(r, true); } fn test_box() { let r = match true { true => { ~[10] } false => { fail!() } }; - assert!((r[0] == 10)); + assert_eq!(r[0], 10); } pub fn main() { test_simple(); test_box(); } diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs index a8cacca4fe8..57483d96e8b 100644 --- a/src/test/run-pass/expr-alt-struct.rs +++ b/src/test/run-pass/expr-alt-struct.rs @@ -18,7 +18,7 @@ struct R { i: int } fn test_rec() { let rs = match true { true => R {i: 100}, _ => fail!() }; - assert!((rs.i == 100)); + assert_eq!(rs.i, 100); } enum mood { happy, sad, } @@ -32,7 +32,7 @@ impl cmp::Eq for mood { fn test_tag() { let rs = match true { true => { happy } false => { sad } }; - assert!((rs == happy)); + assert_eq!(rs, happy); } pub fn main() { test_rec(); test_tag(); } diff --git a/src/test/run-pass/expr-alt-unique.rs b/src/test/run-pass/expr-alt-unique.rs index dd20840db57..cdd4e45877a 100644 --- a/src/test/run-pass/expr-alt-unique.rs +++ b/src/test/run-pass/expr-alt-unique.rs @@ -16,7 +16,7 @@ // Tests for match as expressions resulting in boxed types fn test_box() { let res = match true { true => { ~100 }, _ => fail!() }; - assert!((*res == 100)); + assert_eq!(*res, 100); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs index 0a75d9074c6..cfb764e85f8 100644 --- a/src/test/run-pass/expr-block-slot.rs +++ b/src/test/run-pass/expr-block-slot.rs @@ -15,7 +15,7 @@ struct V { v: int } pub fn main() { let a = { let b = A {a: 3}; b }; - assert!((a.a == 3)); + assert_eq!(a.a, 3); let c = { let d = V {v: 3}; d }; - assert!((c.v == 3)); + assert_eq!(c.v, 3); } diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs index ee5d41fdd32..e43377c71fe 100644 --- a/src/test/run-pass/expr-block.rs +++ b/src/test/run-pass/expr-block.rs @@ -22,7 +22,7 @@ fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); } fn test_filled_with_stuff() { let rs = { let mut a = 0; while a < 10 { a += 1; } a }; - assert!((rs == 10)); + assert_eq!(rs, 10); } pub fn main() { test_basic(); test_rec(); test_filled_with_stuff(); } diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs index 7dc0f8246bf..96dab798c83 100644 --- a/src/test/run-pass/expr-copy.rs +++ b/src/test/run-pass/expr-copy.rs @@ -19,9 +19,9 @@ struct A { a: int } pub fn main() { let mut x = A {a: 10}; f(&mut x); - assert!(x.a == 100); + assert_eq!(x.a, 100); x.a = 20; let mut y = copy x; f(&mut y); - assert!(x.a == 20); + assert_eq!(x.a, 20); } diff --git a/src/test/run-pass/expr-elseif-ref.rs b/src/test/run-pass/expr-elseif-ref.rs index 831ddfde445..b13f7ceba4b 100644 --- a/src/test/run-pass/expr-elseif-ref.rs +++ b/src/test/run-pass/expr-elseif-ref.rs @@ -13,5 +13,5 @@ pub fn main() { let y: @uint = @10u; let x = if false { y } else if true { y } else { y }; - assert!((*y == 10u)); + assert_eq!(*y, 10u); } diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs index b7ea721464e..e4eae9c4c39 100644 --- a/src/test/run-pass/expr-fn.rs +++ b/src/test/run-pass/expr-fn.rs @@ -10,32 +10,32 @@ fn test_int() { fn f() -> int { 10 } - assert!((f() == 10)); + assert_eq!(f(), 10); } fn test_vec() { fn f() -> ~[int] { ~[10, 11] } - assert!((f()[1] == 11)); + assert_eq!(f()[1], 11); } fn test_generic() { fn f<T:Copy>(t: T) -> T { t } - assert!((f(10) == 10)); + assert_eq!(f(10), 10); } fn test_alt() { fn f() -> int { match true { false => { 10 } true => { 20 } } } - assert!((f() == 20)); + assert_eq!(f(), 20); } fn test_if() { fn f() -> int { if true { 10 } else { 20 } } - assert!((f() == 10)); + assert_eq!(f(), 10); } fn test_block() { fn f() -> int { { 10 } } - assert!((f() == 10)); + assert_eq!(f(), 10); } fn test_ret() { @@ -43,14 +43,14 @@ fn test_ret() { return 10 // no semi } - assert!((f() == 10)); + assert_eq!(f(), 10); } // From issue #372 fn test_372() { fn f() -> int { let x = { 3 }; x } - assert!((f() == 3)); + assert_eq!(f(), 3); } fn test_nil() { () } diff --git a/src/test/run-pass/expr-if-box.rs b/src/test/run-pass/expr-if-box.rs index 004137d065c..e560da224ff 100644 --- a/src/test/run-pass/expr-if-box.rs +++ b/src/test/run-pass/expr-if-box.rs @@ -16,12 +16,12 @@ // Tests for if as expressions returning boxed types fn test_box() { let rs = if true { @100 } else { @101 }; - assert!((*rs == 100)); + assert_eq!(*rs, 100); } fn test_str() { let rs = if true { ~"happy" } else { ~"sad" }; - assert!((rs == ~"happy")); + assert_eq!(rs, ~"happy"); } pub fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/expr-if-fail.rs b/src/test/run-pass/expr-if-fail.rs index 7e2e0badb36..f79b7198b50 100644 --- a/src/test/run-pass/expr-if-fail.rs +++ b/src/test/run-pass/expr-if-fail.rs @@ -12,12 +12,12 @@ fn test_if_fail() { let x = if false { fail!() } else { 10 }; assert!((x == 10)) fn test_else_fail() { let x = if true { 10 } else { fail!() }; - assert!((x == 10)); + assert_eq!(x, 10); } fn test_elseif_fail() { let x = if false { 0 } else if false { fail!() } else { 10 }; - assert!((x == 10)); + assert_eq!(x, 10); } pub fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); } diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index b2bbfcaf9a5..13479bb80dc 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -19,7 +19,7 @@ struct I { i: int } fn test_rec() { let rs = if true { I {i: 100} } else { I {i: 101} }; - assert!((rs.i == 100)); + assert_eq!(rs.i, 100); } enum mood { happy, sad, } @@ -33,7 +33,7 @@ impl cmp::Eq for mood { fn test_tag() { let rs = if true { happy } else { sad }; - assert!((rs == happy)); + assert_eq!(rs, happy); } pub fn main() { test_rec(); test_tag(); } diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs index 9f90ff32f83..22714619271 100644 --- a/src/test/run-pass/expr-if-unique.rs +++ b/src/test/run-pass/expr-if-unique.rs @@ -16,7 +16,7 @@ // Tests for if as expressions returning boxed types fn test_box() { let rs = if true { ~100 } else { ~101 }; - assert!((*rs == 100)); + assert_eq!(*rs, 100); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index eef0924f487..409fec5656c 100644 --- a/src/test/run-pass/exterior.rs +++ b/src/test/run-pass/exterior.rs @@ -19,8 +19,8 @@ fn f(p: @mut Point) { assert!((p.z == 12)); p.z = 13; assert!((p.z == 13)); } pub fn main() { let a: Point = Point {x: 10, y: 11, z: 12}; let b: @mut Point = @mut copy a; - assert!((b.z == 12)); + assert_eq!(b.z, 12); f(b); - assert!((a.z == 12)); - assert!((b.z == 13)); + assert_eq!(a.z, 12); + assert_eq!(b.z, 13); } diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs index c29eb2613ad..b8cdfcb0c4c 100644 --- a/src/test/run-pass/extern-call-deep.rs +++ b/src/test/run-pass/extern-call-deep.rs @@ -33,5 +33,5 @@ fn count(n: uint) -> uint { pub fn main() { let result = count(1000u); debug!("result = %?", result); - assert!(result == 1000u); + assert_eq!(result, 1000u); } diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs index 4e807f0f169..eb7ab055b07 100644 --- a/src/test/run-pass/extern-call-deep2.rs +++ b/src/test/run-pass/extern-call-deep2.rs @@ -36,6 +36,6 @@ pub fn main() { do task::spawn { let result = count(1000u); debug!("result = %?", result); - assert!(result == 1000u); + assert_eq!(result, 1000u); }; } diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index eafdd3c5e99..4111f9eb00e 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -40,6 +40,6 @@ pub fn main() { do task::spawn { let result = count(12u); debug!("result = %?", result); - assert!(result == 2048u); + assert_eq!(result, 2048u); }; } diff --git a/src/test/run-pass/extern-call.rs b/src/test/run-pass/extern-call.rs index 37e531eaa8e..ec335cf8a82 100644 --- a/src/test/run-pass/extern-call.rs +++ b/src/test/run-pass/extern-call.rs @@ -33,5 +33,5 @@ fn fact(n: uint) -> uint { pub fn main() { let result = fact(10u); debug!("result = %?", result); - assert!(result == 3628800u); + assert_eq!(result, 3628800u); } diff --git a/src/test/run-pass/extern-crosscrate.rs b/src/test/run-pass/extern-crosscrate.rs index de7dd7e4c8c..eb21e199549 100644 --- a/src/test/run-pass/extern-crosscrate.rs +++ b/src/test/run-pass/extern-crosscrate.rs @@ -23,5 +23,5 @@ fn fact(n: uint) -> uint { pub fn main() { let result = fact(10u); debug!("result = %?", result); - assert!(result == 3628800u); + assert_eq!(result, 3628800u); } diff --git a/src/test/run-pass/extern-pass-TwoU16s.rs b/src/test/run-pass/extern-pass-TwoU16s.rs index ec65cbb5670..1ff4cd0053b 100644 --- a/src/test/run-pass/extern-pass-TwoU16s.rs +++ b/src/test/run-pass/extern-pass-TwoU16s.rs @@ -26,6 +26,6 @@ pub fn main() { unsafe { let x = TwoU16s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU16s(x); - assert!(x == y); + assert_eq!(x, y); } } diff --git a/src/test/run-pass/extern-pass-TwoU32s.rs b/src/test/run-pass/extern-pass-TwoU32s.rs index 6ac5967c54f..362fb6b5b22 100644 --- a/src/test/run-pass/extern-pass-TwoU32s.rs +++ b/src/test/run-pass/extern-pass-TwoU32s.rs @@ -24,6 +24,6 @@ pub fn main() { unsafe { let x = TwoU32s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU32s(x); - assert!(x == y); + assert_eq!(x, y); } } diff --git a/src/test/run-pass/extern-pass-TwoU64s-ref.rs b/src/test/run-pass/extern-pass-TwoU64s-ref.rs index 19b99eaccc9..6479714e004 100644 --- a/src/test/run-pass/extern-pass-TwoU64s-ref.rs +++ b/src/test/run-pass/extern-pass-TwoU64s-ref.rs @@ -23,6 +23,6 @@ pub fn main() { unsafe { let x = TwoU64s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU64s(x); - assert!(x == y); + assert_eq!(x, y); } } diff --git a/src/test/run-pass/extern-pass-TwoU64s.rs b/src/test/run-pass/extern-pass-TwoU64s.rs index cd6226b61c9..246012d6532 100644 --- a/src/test/run-pass/extern-pass-TwoU64s.rs +++ b/src/test/run-pass/extern-pass-TwoU64s.rs @@ -28,6 +28,6 @@ pub fn main() { unsafe { let x = TwoU64s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU64s(x); - assert!(x == y); + assert_eq!(x, y); } } diff --git a/src/test/run-pass/extern-pass-TwoU8s.rs b/src/test/run-pass/extern-pass-TwoU8s.rs index 7d08b436908..01052bd0084 100644 --- a/src/test/run-pass/extern-pass-TwoU8s.rs +++ b/src/test/run-pass/extern-pass-TwoU8s.rs @@ -26,6 +26,6 @@ pub fn main() { unsafe { let x = TwoU8s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU8s(x); - assert!(x == y); + assert_eq!(x, y); } } diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs index 645396e5a98..37e27959043 100644 --- a/src/test/run-pass/extern-pass-char.rs +++ b/src/test/run-pass/extern-pass-char.rs @@ -16,6 +16,6 @@ pub extern { pub fn main() { unsafe { - assert!(22_u8 == rust_dbg_extern_identity_u8(22_u8)); + assert_eq!(22_u8, rust_dbg_extern_identity_u8(22_u8)); } } diff --git a/src/test/run-pass/extern-pass-double.rs b/src/test/run-pass/extern-pass-double.rs index 3a6dd26a9dc..2812068d69d 100644 --- a/src/test/run-pass/extern-pass-double.rs +++ b/src/test/run-pass/extern-pass-double.rs @@ -14,6 +14,6 @@ pub extern { pub fn main() { unsafe { - assert!(22.0_f64 == rust_dbg_extern_identity_double(22.0_f64)); + assert_eq!(22.0_f64, rust_dbg_extern_identity_double(22.0_f64)); } } diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs index 19c4d6e1539..4f2633f680f 100644 --- a/src/test/run-pass/extern-pass-u32.rs +++ b/src/test/run-pass/extern-pass-u32.rs @@ -16,6 +16,6 @@ pub extern { pub fn main() { unsafe { - assert!(22_u32 == rust_dbg_extern_identity_u32(22_u32)); + assert_eq!(22_u32, rust_dbg_extern_identity_u32(22_u32)); } } diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs index cce66999922..2215a3d95fc 100644 --- a/src/test/run-pass/extern-pass-u64.rs +++ b/src/test/run-pass/extern-pass-u64.rs @@ -16,6 +16,6 @@ pub extern { pub fn main() { unsafe { - assert!(22_u64 == rust_dbg_extern_identity_u64(22_u64)); + assert_eq!(22_u64, rust_dbg_extern_identity_u64(22_u64)); } } diff --git a/src/test/run-pass/extern-return-TwoU16s.rs b/src/test/run-pass/extern-return-TwoU16s.rs index f87b27e1f62..3a345099bad 100644 --- a/src/test/run-pass/extern-return-TwoU16s.rs +++ b/src/test/run-pass/extern-return-TwoU16s.rs @@ -22,7 +22,7 @@ pub extern { pub fn main() { unsafe { let y = rust_dbg_extern_return_TwoU16s(); - assert!(y.one == 10); - assert!(y.two == 20); + assert_eq!(y.one, 10); + assert_eq!(y.two, 20); } } diff --git a/src/test/run-pass/extern-return-TwoU32s.rs b/src/test/run-pass/extern-return-TwoU32s.rs index 9e374687855..788754bfb00 100644 --- a/src/test/run-pass/extern-return-TwoU32s.rs +++ b/src/test/run-pass/extern-return-TwoU32s.rs @@ -19,7 +19,7 @@ pub extern { pub fn main() { unsafe { let y = rust_dbg_extern_return_TwoU32s(); - assert!(y.one == 10); - assert!(y.two == 20); + assert_eq!(y.one, 10); + assert_eq!(y.two, 20); } } diff --git a/src/test/run-pass/extern-return-TwoU64s.rs b/src/test/run-pass/extern-return-TwoU64s.rs index 250d3b8f562..9243c285901 100644 --- a/src/test/run-pass/extern-return-TwoU64s.rs +++ b/src/test/run-pass/extern-return-TwoU64s.rs @@ -19,7 +19,7 @@ pub extern { pub fn main() { unsafe { let y = rust_dbg_extern_return_TwoU64s(); - assert!(y.one == 10); - assert!(y.two == 20); + assert_eq!(y.one, 10); + assert_eq!(y.two, 20); } } diff --git a/src/test/run-pass/extern-return-TwoU8s.rs b/src/test/run-pass/extern-return-TwoU8s.rs index 008e153769a..c1f897e79b0 100644 --- a/src/test/run-pass/extern-return-TwoU8s.rs +++ b/src/test/run-pass/extern-return-TwoU8s.rs @@ -22,7 +22,7 @@ pub extern { pub fn main() { unsafe { let y = rust_dbg_extern_return_TwoU8s(); - assert!(y.one == 10); - assert!(y.two == 20); + assert_eq!(y.one, 10); + assert_eq!(y.two, 20); } } diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs index 0b640c8c623..1add9d44d9a 100644 --- a/src/test/run-pass/extern-stress.rs +++ b/src/test/run-pass/extern-stress.rs @@ -36,7 +36,7 @@ fn count(n: uint) -> uint { pub fn main() { for old_iter::repeat(100u) { do task::spawn { - assert!(count(5u) == 16u); + assert_eq!(count(5u), 16u); }; } } diff --git a/src/test/run-pass/extern-take-value.rs b/src/test/run-pass/extern-take-value.rs index c3815cf2a67..542686c9099 100644 --- a/src/test/run-pass/extern-take-value.rs +++ b/src/test/run-pass/extern-take-value.rs @@ -20,6 +20,6 @@ pub fn main() { let b: *u8 = f; let c: *u8 = g; - assert!(a == b); + assert_eq!(a, b); assert!(a != c); } diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index bde3f5dd52f..ae2d497418c 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -35,7 +35,7 @@ pub fn main() { do task::spawn { let result = count(5u); debug!("result = %?", result); - assert!(result == 16u); + assert_eq!(result, 16u); }; } } diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index ec82db8644c..cbcf9a6bef4 100644 --- a/src/test/run-pass/fact.rs +++ b/src/test/run-pass/fact.rs @@ -32,7 +32,7 @@ fn f(x: int) -> int { } pub fn main() { - assert!((f(5) == 120)); + assert_eq!(f(5), 120); // debug!("all done"); } diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs index 76b2309085a..4c28151224c 100644 --- a/src/test/run-pass/fixed-point-bind-box.rs +++ b/src/test/run-pass/fixed-point-bind-box.rs @@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int { pub fn main() { let fact = fix(fact_); - assert!((fact(5) == 120)); - assert!((fact(2) == 2)); + assert_eq!(fact(5), 120); + assert_eq!(fact(2), 2); } diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs index 83060baac51..53f9c723a47 100644 --- a/src/test/run-pass/fixed-point-bind-unique.rs +++ b/src/test/run-pass/fixed-point-bind-unique.rs @@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int { pub fn main() { let fact = fix(fact_); - assert!((fact(5) == 120)); - assert!((fact(2) == 2)); + assert_eq!(fact(5), 120); + assert_eq!(fact(2), 2); } diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs index 7ee3f5173b0..ead8e5ea104 100644 --- a/src/test/run-pass/fixed_length_copy.rs +++ b/src/test/run-pass/fixed_length_copy.rs @@ -15,6 +15,6 @@ pub fn main() { let arr = [1,2,3]; let arr2 = arr; - assert!((arr[1] == 2)); - assert!((arr2[2] == 3)); + assert_eq!(arr[1], 2); + assert_eq!(arr2[2], 3); } diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index b3ced135a4f..eef898a05ed 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -14,5 +14,5 @@ pub fn main() { let arr = [1,2,3]; let struc = Struc {a: 13u8, b: arr, c: 42}; let s = sys::log_str(&struc); - assert!((s == ~"{a: 13, b: [1, 2, 3], c: 42}")); + assert_eq!(s, ~"{a: 13, b: [1, 2, 3], c: 42}"); } diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs index 08523de3ccd..de3ce4d8149 100644 --- a/src/test/run-pass/float-nan.rs +++ b/src/test/run-pass/float-nan.rs @@ -19,7 +19,7 @@ pub fn main() { assert!((nan).is_NaN()); let inf = infinity::<float>(); - assert!(-inf == neg_infinity::<float>()); + assert_eq!(-inf, neg_infinity::<float>()); assert!( nan != nan); assert!( nan != -nan); @@ -36,17 +36,17 @@ pub fn main() { assert!( inf != nan); assert!(-inf != nan); - assert!(!( nan == nan)); + assert!(!( nan == nan)); assert!(!( nan == -nan)); - assert!(!( nan == 1.)); - assert!(!( nan == 0.)); - assert!(!( nan == inf)); + assert!(!( nan == 1.)); + assert!(!( nan == 0.)); + assert!(!( nan == inf)); assert!(!( nan == -inf)); - assert!(!( 1. == nan)); - assert!(!( 0. == nan)); - assert!(!( inf == nan)); - assert!(!(-inf == nan)); - assert!(!(-nan == nan)); + assert!(!( 1. == nan)); + assert!(!( 0. == nan)); + assert!(!( inf == nan)); + assert!(!(-inf == nan)); + assert!(!(-nan == nan)); assert!(!(-nan == -nan)); assert!(!( nan > nan)); diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs index d84c4930aa2..713d863029c 100644 --- a/src/test/run-pass/float2.rs +++ b/src/test/run-pass/float2.rs @@ -22,13 +22,13 @@ pub fn main() { let i = 1.0E7f64; let j = 3.1e+9; let k = 3.2e-10; - assert!((a == b)); + assert_eq!(a, b); assert!((c < b)); - assert!((c == d)); + assert_eq!(c, d); assert!((e < g)); assert!((f < h)); - assert!((g == 1000000.0f32)); - assert!((h == i)); + assert_eq!(g, 1000000.0f32); + assert_eq!(h, i); assert!((j > k)); assert!((k < a)); } diff --git a/src/test/run-pass/fn-assign-managed-to-bare-1.rs b/src/test/run-pass/fn-assign-managed-to-bare-1.rs index 3a6d4486678..dece77595bc 100644 --- a/src/test/run-pass/fn-assign-managed-to-bare-1.rs +++ b/src/test/run-pass/fn-assign-managed-to-bare-1.rs @@ -14,7 +14,7 @@ fn add(n: int) -> @fn(int) -> int { } pub fn main() { - assert!(add(3)(4) == 7); + assert_eq!(add(3)(4), 7); let add3 : &fn(int)->int = add(3); - assert!(add3(4) == 7); + assert_eq!(add3(4), 7); } diff --git a/src/test/run-pass/fn-assign-managed-to-bare-2.rs b/src/test/run-pass/fn-assign-managed-to-bare-2.rs index c7b7770d81f..f8daacfa233 100644 --- a/src/test/run-pass/fn-assign-managed-to-bare-2.rs +++ b/src/test/run-pass/fn-assign-managed-to-bare-2.rs @@ -15,14 +15,14 @@ fn add(n: int) -> @fn(int) -> int { pub fn main() { - assert!(add(3)(4) == 7); + assert_eq!(add(3)(4), 7); let add1 : @fn(int)->int = add(1); - assert!(add1(6) == 7); + assert_eq!(add1(6), 7); let add2 : &(@fn(int)->int) = &add(2); - assert!((*add2)(5) == 7); + assert_eq!((*add2)(5), 7); let add3 : &fn(int)->int = add(3); - assert!(add3(4) == 7); + assert_eq!(add3(4), 7); } diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs index 7ad7d24df59..7c8fbd2989f 100644 --- a/src/test/run-pass/fn-bare-assign.rs +++ b/src/test/run-pass/fn-bare-assign.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(i: int, called: &mut bool) { - assert!(i == 10); + assert_eq!(i, 10); *called = true; } @@ -21,5 +21,5 @@ pub fn main() { let mut called = false; let h = f; g(h, &mut called); - assert!(called == true); + assert_eq!(called, true); } diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs index b78bd488bc6..4f0f451a08c 100644 --- a/src/test/run-pass/fn-bare-spawn.rs +++ b/src/test/run-pass/fn-bare-spawn.rs @@ -15,7 +15,7 @@ fn spawn<T:Owned>(val: T, f: extern fn(T)) { } fn f(i: int) { - assert!(i == 100); + assert_eq!(i, 100); } pub fn main() { diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs index f3949a0f43b..450e2a70aab 100644 --- a/src/test/run-pass/fn-pattern-expected-type.rs +++ b/src/test/run-pass/fn-pattern-expected-type.rs @@ -10,8 +10,8 @@ pub fn main() { let f: &fn((int,int)) = |(x, y)| { - assert!(x == 1); - assert!(y == 2); + assert_eq!(x, 1); + assert_eq!(y, 2); }; f((1, 2)); } diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs index 4c5084d9f1e..bbcb7d58923 100644 --- a/src/test/run-pass/for-destruct.rs +++ b/src/test/run-pass/for-destruct.rs @@ -12,6 +12,6 @@ struct Pair { x: int, y: int } pub fn main() { for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| { - assert!((elt.x + elt.y == 30)); + assert_eq!(elt.x + elt.y, 30); } } diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs index b180e502023..6987e2cf97d 100644 --- a/src/test/run-pass/foreach-nested.rs +++ b/src/test/run-pass/foreach-nested.rs @@ -20,8 +20,8 @@ pub fn main() { do two |i| { do two |j| { a[p] = 10 * i + j; p += 1; } } - assert!((a[0] == 0)); - assert!((a[1] == 1)); - assert!((a[2] == 10)); - assert!((a[3] == 11)); + assert_eq!(a[0], 0); + assert_eq!(a[1], 1); + assert_eq!(a[2], 10); + assert_eq!(a[3], 11); } diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs index 421ee7ff2b0..d52842b4101 100644 --- a/src/test/run-pass/foreach-put-structured.rs +++ b/src/test/run-pass/foreach-put-structured.rs @@ -23,9 +23,9 @@ pub fn main() { let (_0, _1) = p; debug!(_0); debug!(_1); - assert!((_0 + 10 == i)); + assert_eq!(_0 + 10, i); i += 1; j = _1; }; - assert!((j == 45)); + assert_eq!(j, 45); } diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs index 99848ddfc7b..c3120c44c37 100644 --- a/src/test/run-pass/foreach-simple-outer-slot.rs +++ b/src/test/run-pass/foreach-simple-outer-slot.rs @@ -17,7 +17,7 @@ pub fn main() { do first_ten |i| { debug!("main"); debug!(i); sum = sum + i; } debug!("sum"); debug!(sum); - assert!((sum == 45)); + assert_eq!(sum, 45); } fn first_ten(it: &fn(int)) { diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs index 08cb8db5131..3f61fca8726 100644 --- a/src/test/run-pass/foreign-call-no-runtime.rs +++ b/src/test/run-pass/foreign-call-no-runtime.rs @@ -19,6 +19,6 @@ pub fn main() { extern fn callback(data: libc::uintptr_t) { unsafe { let data: *int = cast::transmute(data); - assert!(*data == 100); + assert_eq!(*data, 100); } } diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs index 429e78b9c21..3b00b329feb 100644 --- a/src/test/run-pass/foreign-fn-linkname.rs +++ b/src/test/run-pass/foreign-fn-linkname.rs @@ -29,5 +29,5 @@ fn strlen(str: ~str) -> uint { pub fn main() { let len = strlen(~"Rust"); - assert!((len == 4u)); + assert_eq!(len, 4u); } diff --git a/src/test/run-pass/foreign-lib-path.rs b/src/test/run-pass/foreign-lib-path.rs index 61fc709d949..bfa1e79a26f 100644 --- a/src/test/run-pass/foreign-lib-path.rs +++ b/src/test/run-pass/foreign-lib-path.rs @@ -22,5 +22,5 @@ mod WHATGOESHERE { } pub fn main() { - assert!(IDONTKNOW() == 0x_BAD_DOOD_u32); + assert_eq!(IDONTKNOW(), 0x_BAD_DOOD_u32); } diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs index c2baab090db..52e6a4649a8 100644 --- a/src/test/run-pass/fun-call-variants.rs +++ b/src/test/run-pass/fun-call-variants.rs @@ -17,5 +17,5 @@ pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound - assert!((a == b)); + assert_eq!(a, b); } diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs index db39850e74e..738752924c3 100644 --- a/src/test/run-pass/fun-indirect-call.rs +++ b/src/test/run-pass/fun-indirect-call.rs @@ -17,5 +17,5 @@ fn f() -> int { return 42; } pub fn main() { let g: extern fn() -> int = f; let i: int = g(); - assert!((i == 42)); + assert_eq!(i, 42); } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index e5aa54534db..bce65161921 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -16,5 +16,5 @@ pub fn main() { let expected = @100; let actual = id::<@int>(expected); debug!(*actual); - assert!((*expected == *actual)); + assert_eq!(*expected, *actual); } diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 5eb91b31740..ad271186639 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -16,5 +16,5 @@ pub fn main() { let expected = ~100; let actual = id::<~int>(expected.clone()); debug!(*actual); - assert!((*expected == *actual)); + assert_eq!(*expected, *actual); } diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 05062564595..7248e577069 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -16,5 +16,5 @@ struct Box<T> {x: T, y: T, z: T} pub fn main() { let x: @Box<int> = box::<int>(Box{x: 1, y: 2, z: 3}); - assert!((x.y == 2)); + assert_eq!(x.y, 2); } diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index 747acca903b..9e266a3f208 100644 --- a/src/test/run-pass/generic-derived-type.rs +++ b/src/test/run-pass/generic-derived-type.rs @@ -24,6 +24,6 @@ pub fn main() { let b = f::<int>(10); debug!(b.a); debug!(b.b); - assert!((b.a == 10)); - assert!((b.b == 10)); + assert_eq!(b.a, 10); + assert_eq!(b.b, 10); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index 7708ffad367..79ee544d495 100644 --- a/src/test/run-pass/generic-exterior-box.rs +++ b/src/test/run-pass/generic-exterior-box.rs @@ -17,5 +17,5 @@ fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: @t}; } pub fn main() { let foo: int = 17; let rbfoo: Recbox<int> = reclift::<int>(foo); - assert!((*rbfoo.x == foo)); + assert_eq!(*rbfoo.x, foo); } diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index 693b83f1102..cc94fca6804 100644 --- a/src/test/run-pass/generic-exterior-unique.rs +++ b/src/test/run-pass/generic-exterior-unique.rs @@ -15,5 +15,5 @@ fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; } pub fn main() { let foo: int = 17; let rbfoo: Recbox<int> = reclift::<int>(foo); - assert!((*rbfoo.x == foo)); + assert_eq!(*rbfoo.x, foo); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index 8108e15ee14..bcacccee820 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -25,13 +25,13 @@ pub fn main() { let mut q: Triple = Triple {x: 68, y: 69, z: 70}; y = id::<int>(x); debug!(y); - assert!((x == y)); + assert_eq!(x, y); b = id::<char>(a); debug!(b); - assert!((a == b)); + assert_eq!(a, b); q = id::<Triple>(p); x = p.z; y = q.z; debug!(y); - assert!((x == y)); + assert_eq!(x, y); } diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs index 54ae2c58e42..1e532caaf04 100644 --- a/src/test/run-pass/generic-object.rs +++ b/src/test/run-pass/generic-object.rs @@ -25,5 +25,5 @@ impl Foo<int> for S { pub fn main() { let x = @S { x: 1 }; let y = x as @Foo<int>; - assert!(y.get() == 1); + assert_eq!(y.get(), 1); } diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs index 42f19e86fe8..eced9a70742 100644 --- a/src/test/run-pass/generic-tag-values.rs +++ b/src/test/run-pass/generic-tag-values.rs @@ -24,8 +24,8 @@ pub fn main() { some(t) => { debug!(t.x); debug!(t.y); - assert!((t.x == 17)); - assert!((t.y == 42)); + assert_eq!(t.x, 17); + assert_eq!(t.y, 42); } } } diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index 212e044dd14..485b9a78488 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -12,6 +12,6 @@ fn get_third<T:Copy>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; } pub fn main() { debug!(get_third((1, 2, 3))); - assert!((get_third((1, 2, 3)) == 3)); - assert!((get_third((5u8, 6u8, 7u8)) == 7u8)); + assert_eq!(get_third((1, 2, 3)), 3); + assert_eq!(get_third((5u8, 6u8, 7u8)), 7u8); } diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs index 8f9208ea917..0ff7cedc6c5 100644 --- a/src/test/run-pass/generic-type.rs +++ b/src/test/run-pass/generic-type.rs @@ -14,6 +14,6 @@ struct Pair<T> {x: T, y: T} pub fn main() { let x: Pair<int> = Pair {x: 10, y: 12}; - assert!((x.x == 10)); - assert!((x.y == 12)); + assert_eq!(x.x, 10); + assert_eq!(x.y, 12); } diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 064e2f54628..8a4fc94135b 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -14,5 +14,5 @@ fn box<T:Copy>(x: Triple<T>) -> ~Triple<T> { return ~x; } pub fn main() { let x: ~Triple<int> = box::<int>(Triple{x: 1, y: 2, z: 3}); - assert!((x.y == 2)); + assert_eq!(x.y, 2); } diff --git a/src/test/run-pass/guards-not-exhaustive.rs b/src/test/run-pass/guards-not-exhaustive.rs index 8f5b288b755..4d30fbe1559 100644 --- a/src/test/run-pass/guards-not-exhaustive.rs +++ b/src/test/run-pass/guards-not-exhaustive.rs @@ -9,5 +9,5 @@ fn xyzzy(q: Q) -> uint { pub fn main() { - assert!(xyzzy(R(Some(5))) == 0); + assert_eq!(xyzzy(R(Some(5))), 0); } diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs index 8654e4a2a4b..86bff013eef 100644 --- a/src/test/run-pass/guards.rs +++ b/src/test/run-pass/guards.rs @@ -13,7 +13,7 @@ struct Pair { x: int, y: int } pub fn main() { let a = match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } }; - assert!((a == 2)); + assert_eq!(a, 2); let b = match Pair {x: 10, y: 20} { @@ -21,5 +21,5 @@ pub fn main() { Pair {x: x, y: y} if x == 10 && y == 20 => { 2 } Pair {x: x, y: y} => { 3 } }; - assert!((b == 2)); + assert_eq!(b, 2); } diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs index 9708e04058b..799910a6a5f 100644 --- a/src/test/run-pass/i8-incr.rs +++ b/src/test/run-pass/i8-incr.rs @@ -17,5 +17,5 @@ pub fn main() { let y: i8 = -12i8; x = x + 1i8; x = x - 1i8; - assert!((x == y)); + assert_eq!(x, y); } diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs index a29b1ff0c69..de25ec42c29 100644 --- a/src/test/run-pass/import-glob-crate.rs +++ b/src/test/run-pass/import-glob-crate.rs @@ -17,5 +17,5 @@ use core::vec::*; pub fn main() { let mut v = from_elem(0u, 0); v = vec::append(v, ~[4, 2]); - assert!((reversed(v) == ~[2, 4])); + assert_eq!(reversed(v), ~[2, 4]); } diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs index e9287f35622..447ee2c890c 100644 --- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs +++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs @@ -14,19 +14,19 @@ pub fn main() { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - assert!(x_message == ~"lots"); + assert_eq!(x_message, ~"lots"); let y = 2i; let y_message = match y { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - assert!(y_message == ~"lots"); + assert_eq!(y_message, ~"lots"); let z = 1u64; let z_message = match z { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - assert!(z_message == ~"not many"); + assert_eq!(z_message, ~"not many"); } diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs index 98919e49a1a..5e10419da6e 100644 --- a/src/test/run-pass/init-res-into-things.rs +++ b/src/test/run-pass/init-res-into-things.rs @@ -37,7 +37,7 @@ fn test_box() { { let a = @r(i); } - assert!(*i == 1); + assert_eq!(*i, 1); } fn test_rec() { @@ -45,7 +45,7 @@ fn test_rec() { { let a = Box {x: r(i)}; } - assert!(*i == 1); + assert_eq!(*i, 1); } fn test_tag() { @@ -57,7 +57,7 @@ fn test_tag() { { let a = t0(r(i)); } - assert!(*i == 1); + assert_eq!(*i, 1); } fn test_tup() { @@ -65,7 +65,7 @@ fn test_tup() { { let a = (r(i), 0); } - assert!(*i == 1); + assert_eq!(*i, 1); } fn test_unique() { @@ -73,7 +73,7 @@ fn test_unique() { { let a = ~r(i); } - assert!(*i == 1); + assert_eq!(*i, 1); } fn test_box_rec() { @@ -83,7 +83,7 @@ fn test_box_rec() { x: r(i) }; } - assert!(*i == 1); + assert_eq!(*i, 1); } pub fn main() { diff --git a/src/test/run-pass/int-conversion-coherence.rs b/src/test/run-pass/int-conversion-coherence.rs index ef2a84da219..7ef4f6ed22c 100644 --- a/src/test/run-pass/int-conversion-coherence.rs +++ b/src/test/run-pass/int-conversion-coherence.rs @@ -21,5 +21,5 @@ impl foo of plus for uint { fn plus() -> int { self as int + 20 } } impl foo of plus for int { fn plus() -> int { self + 10 } } pub fn main() { - assert!(10.plus() == 20); + assert_eq!(10.plus(), 20); } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index 9d30c738605..b985ed0f6cb 100644 --- a/src/test/run-pass/integral-indexing.rs +++ b/src/test/run-pass/integral-indexing.rs @@ -15,16 +15,16 @@ pub fn main() { let v: ~[int] = ~[0, 1, 2, 3, 4, 5]; let s: ~str = ~"abcdef"; - assert!((v[3u] == 3)); - assert!((v[3u8] == 3)); - assert!((v[3i8] == 3)); - assert!((v[3u32] == 3)); - assert!((v[3i32] == 3)); + assert_eq!(v[3u], 3); + assert_eq!(v[3u8], 3); + assert_eq!(v[3i8], 3); + assert_eq!(v[3u32], 3); + assert_eq!(v[3i32], 3); debug!(v[3u8]); - assert!((s[3u] == 'd' as u8)); - assert!((s[3u8] == 'd' as u8)); - assert!((s[3i8] == 'd' as u8)); - assert!((s[3u32] == 'd' as u8)); - assert!((s[3i32] == 'd' as u8)); + assert_eq!(s[3u], 'd' as u8); + assert_eq!(s[3u8], 'd' as u8); + assert_eq!(s[3i8], 'd' as u8); + assert_eq!(s[3u32], 'd' as u8); + assert_eq!(s[3i32], 'd' as u8); debug!(s[3u8]); } diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs index cce3d8066ec..7a54b87404e 100644 --- a/src/test/run-pass/intrinsic-alignment.rs +++ b/src/test/run-pass/intrinsic-alignment.rs @@ -26,8 +26,8 @@ mod m { #[cfg(target_arch = "x86")] pub fn main() { unsafe { - assert!(::rusti::pref_align_of::<u64>() == 8u); - assert!(::rusti::min_align_of::<u64>() == 4u); + assert_eq!(::rusti::pref_align_of::<u64>(), 8u); + assert_eq!(::rusti::min_align_of::<u64>(), 4u); } } @@ -35,8 +35,8 @@ mod m { #[cfg(target_arch = "x86_64")] pub fn main() { unsafe { - assert!(::rusti::pref_align_of::<u64>() == 8u); - assert!(::rusti::min_align_of::<u64>() == 8u); + assert_eq!(::rusti::pref_align_of::<u64>(), 8u); + assert_eq!(::rusti::min_align_of::<u64>(), 8u); } } } @@ -47,8 +47,8 @@ mod m { #[cfg(target_arch = "x86")] pub fn main() { unsafe { - assert!(::rusti::pref_align_of::<u64>() == 8u); - assert!(::rusti::min_align_of::<u64>() == 8u); + assert_eq!(::rusti::pref_align_of::<u64>(), 8u); + assert_eq!(::rusti::min_align_of::<u64>(), 8u); } } } @@ -59,8 +59,8 @@ mod m { #[cfg(target_arch = "arm")] pub fn main() { unsafe { - assert!(::rusti::pref_align_of::<u64>() == 8u); - assert!(::rusti::min_align_of::<u64>() == 4u); + assert_eq!(::rusti::pref_align_of::<u64>(), 8u); + assert_eq!(::rusti::min_align_of::<u64>(), 4u); } } } diff --git a/src/test/run-pass/intrinsic-atomics-cc.rs b/src/test/run-pass/intrinsic-atomics-cc.rs index da0c7e759f5..ad285e9a85f 100644 --- a/src/test/run-pass/intrinsic-atomics-cc.rs +++ b/src/test/run-pass/intrinsic-atomics-cc.rs @@ -18,6 +18,6 @@ pub fn main() { unsafe { let mut x = 1; atomic_xchg(&mut x, 5); - assert!(x == 5); + assert_eq!(x, 5); } } diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs index 4105e6003b5..e5ab980cc8d 100644 --- a/src/test/run-pass/intrinsic-atomics.rs +++ b/src/test/run-pass/intrinsic-atomics.rs @@ -39,41 +39,41 @@ pub fn main() { unsafe { let mut x = ~1; - assert!(rusti::atomic_load(x) == 1); + assert_eq!(rusti::atomic_load(x), 1); *x = 5; - assert!(rusti::atomic_load_acq(x) == 5); + assert_eq!(rusti::atomic_load_acq(x), 5); rusti::atomic_store(x,3); - assert!(*x == 3); + assert_eq!(*x, 3); rusti::atomic_store_rel(x,1); - assert!(*x == 1); + assert_eq!(*x, 1); - assert!(rusti::atomic_cxchg(x, 1, 2) == 1); - assert!(*x == 2); + assert_eq!(rusti::atomic_cxchg(x, 1, 2), 1); + assert_eq!(*x, 2); - assert!(rusti::atomic_cxchg_acq(x, 1, 3) == 2); - assert!(*x == 2); + assert_eq!(rusti::atomic_cxchg_acq(x, 1, 3), 2); + assert_eq!(*x, 2); - assert!(rusti::atomic_cxchg_rel(x, 2, 1) == 2); - assert!(*x == 1); + assert_eq!(rusti::atomic_cxchg_rel(x, 2, 1), 2); + assert_eq!(*x, 1); - assert!(rusti::atomic_xchg(x, 0) == 1); - assert!(*x == 0); + assert_eq!(rusti::atomic_xchg(x, 0), 1); + assert_eq!(*x, 0); - assert!(rusti::atomic_xchg_acq(x, 1) == 0); - assert!(*x == 1); + assert_eq!(rusti::atomic_xchg_acq(x, 1), 0); + assert_eq!(*x, 1); - assert!(rusti::atomic_xchg_rel(x, 0) == 1); - assert!(*x == 0); + assert_eq!(rusti::atomic_xchg_rel(x, 0), 1); + assert_eq!(*x, 0); - assert!(rusti::atomic_xadd(x, 1) == 0); - assert!(rusti::atomic_xadd_acq(x, 1) == 1); - assert!(rusti::atomic_xadd_rel(x, 1) == 2); - assert!(*x == 3); + assert_eq!(rusti::atomic_xadd(x, 1), 0); + assert_eq!(rusti::atomic_xadd_acq(x, 1), 1); + assert_eq!(rusti::atomic_xadd_rel(x, 1), 2); + assert_eq!(*x, 3); - assert!(rusti::atomic_xsub(x, 1) == 3); - assert!(rusti::atomic_xsub_acq(x, 1) == 2); - assert!(rusti::atomic_xsub_rel(x, 1) == 1); - assert!(*x == 0); + assert_eq!(rusti::atomic_xsub(x, 1), 3); + assert_eq!(rusti::atomic_xsub_acq(x, 1), 2); + assert_eq!(rusti::atomic_xsub_rel(x, 1), 1); + assert_eq!(*x, 0); } } diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs index 9f683d20898..1dbb46c271e 100644 --- a/src/test/run-pass/intrinsic-move-val.rs +++ b/src/test/run-pass/intrinsic-move-val.rs @@ -21,6 +21,6 @@ pub fn main() { let mut x = @1; let mut y = @2; rusti::move_val(&mut y, x); - assert!(*y == 1); + assert_eq!(*y, 1); } } diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs index 1a0d97a5c5b..e4d84808673 100644 --- a/src/test/run-pass/intrinsics-integer.rs +++ b/src/test/run-pass/intrinsics-integer.rs @@ -40,83 +40,83 @@ pub fn main() { unsafe { use rusti::*; - assert!((ctpop8(0i8) == 0i8)); - assert!((ctpop16(0i16) == 0i16)); - assert!((ctpop32(0i32) == 0i32)); - assert!((ctpop64(0i64) == 0i64)); - - assert!((ctpop8(1i8) == 1i8)); - assert!((ctpop16(1i16) == 1i16)); - assert!((ctpop32(1i32) == 1i32)); - assert!((ctpop64(1i64) == 1i64)); - - assert!((ctpop8(10i8) == 2i8)); - assert!((ctpop16(10i16) == 2i16)); - assert!((ctpop32(10i32) == 2i32)); - assert!((ctpop64(10i64) == 2i64)); - - assert!((ctpop8(100i8) == 3i8)); - assert!((ctpop16(100i16) == 3i16)); - assert!((ctpop32(100i32) == 3i32)); - assert!((ctpop64(100i64) == 3i64)); - - assert!((ctpop8(-1i8) == 8i8)); - assert!((ctpop16(-1i16) == 16i16)); - assert!((ctpop32(-1i32) == 32i32)); - assert!((ctpop64(-1i64) == 64i64)); - - assert!((ctlz8(0i8) == 8i8)); - assert!((ctlz16(0i16) == 16i16)); - assert!((ctlz32(0i32) == 32i32)); - assert!((ctlz64(0i64) == 64i64)); - - assert!((ctlz8(1i8) == 7i8)); - assert!((ctlz16(1i16) == 15i16)); - assert!((ctlz32(1i32) == 31i32)); - assert!((ctlz64(1i64) == 63i64)); - - assert!((ctlz8(10i8) == 4i8)); - assert!((ctlz16(10i16) == 12i16)); - assert!((ctlz32(10i32) == 28i32)); - assert!((ctlz64(10i64) == 60i64)); - - assert!((ctlz8(100i8) == 1i8)); - assert!((ctlz16(100i16) == 9i16)); - assert!((ctlz32(100i32) == 25i32)); - assert!((ctlz64(100i64) == 57i64)); - - assert!((cttz8(-1i8) == 0i8)); - assert!((cttz16(-1i16) == 0i16)); - assert!((cttz32(-1i32) == 0i32)); - assert!((cttz64(-1i64) == 0i64)); - - assert!((cttz8(0i8) == 8i8)); - assert!((cttz16(0i16) == 16i16)); - assert!((cttz32(0i32) == 32i32)); - assert!((cttz64(0i64) == 64i64)); - - assert!((cttz8(1i8) == 0i8)); - assert!((cttz16(1i16) == 0i16)); - assert!((cttz32(1i32) == 0i32)); - assert!((cttz64(1i64) == 0i64)); - - assert!((cttz8(10i8) == 1i8)); - assert!((cttz16(10i16) == 1i16)); - assert!((cttz32(10i32) == 1i32)); - assert!((cttz64(10i64) == 1i64)); - - assert!((cttz8(100i8) == 2i8)); - assert!((cttz16(100i16) == 2i16)); - assert!((cttz32(100i32) == 2i32)); - assert!((cttz64(100i64) == 2i64)); - - assert!((cttz8(-1i8) == 0i8)); - assert!((cttz16(-1i16) == 0i16)); - assert!((cttz32(-1i32) == 0i32)); - assert!((cttz64(-1i64) == 0i64)); - - assert!((bswap16(0x0A0Bi16) == 0x0B0Ai16)); - assert!((bswap32(0x0ABBCC0Di32) == 0x0DCCBB0Ai32)); - assert!((bswap64(0x0122334455667708i64) == 0x0877665544332201i64)); + assert_eq!(ctpop8(0i8), 0i8); + assert_eq!(ctpop16(0i16), 0i16); + assert_eq!(ctpop32(0i32), 0i32); + assert_eq!(ctpop64(0i64), 0i64); + + assert_eq!(ctpop8(1i8), 1i8); + assert_eq!(ctpop16(1i16), 1i16); + assert_eq!(ctpop32(1i32), 1i32); + assert_eq!(ctpop64(1i64), 1i64); + + assert_eq!(ctpop8(10i8), 2i8); + assert_eq!(ctpop16(10i16), 2i16); + assert_eq!(ctpop32(10i32), 2i32); + assert_eq!(ctpop64(10i64), 2i64); + + assert_eq!(ctpop8(100i8), 3i8); + assert_eq!(ctpop16(100i16), 3i16); + assert_eq!(ctpop32(100i32), 3i32); + assert_eq!(ctpop64(100i64), 3i64); + + assert_eq!(ctpop8(-1i8), 8i8); + assert_eq!(ctpop16(-1i16), 16i16); + assert_eq!(ctpop32(-1i32), 32i32); + assert_eq!(ctpop64(-1i64), 64i64); + + assert_eq!(ctlz8(0i8), 8i8); + assert_eq!(ctlz16(0i16), 16i16); + assert_eq!(ctlz32(0i32), 32i32); + assert_eq!(ctlz64(0i64), 64i64); + + assert_eq!(ctlz8(1i8), 7i8); + assert_eq!(ctlz16(1i16), 15i16); + assert_eq!(ctlz32(1i32), 31i32); + assert_eq!(ctlz64(1i64), 63i64); + + assert_eq!(ctlz8(10i8), 4i8); + assert_eq!(ctlz16(10i16), 12i16); + assert_eq!(ctlz32(10i32), 28i32); + assert_eq!(ctlz64(10i64), 60i64); + + assert_eq!(ctlz8(100i8), 1i8); + assert_eq!(ctlz16(100i16), 9i16); + assert_eq!(ctlz32(100i32), 25i32); + assert_eq!(ctlz64(100i64), 57i64); + + assert_eq!(cttz8(-1i8), 0i8); + assert_eq!(cttz16(-1i16), 0i16); + assert_eq!(cttz32(-1i32), 0i32); + assert_eq!(cttz64(-1i64), 0i64); + + assert_eq!(cttz8(0i8), 8i8); + assert_eq!(cttz16(0i16), 16i16); + assert_eq!(cttz32(0i32), 32i32); + assert_eq!(cttz64(0i64), 64i64); + + assert_eq!(cttz8(1i8), 0i8); + assert_eq!(cttz16(1i16), 0i16); + assert_eq!(cttz32(1i32), 0i32); + assert_eq!(cttz64(1i64), 0i64); + + assert_eq!(cttz8(10i8), 1i8); + assert_eq!(cttz16(10i16), 1i16); + assert_eq!(cttz32(10i32), 1i32); + assert_eq!(cttz64(10i64), 1i64); + + assert_eq!(cttz8(100i8), 2i8); + assert_eq!(cttz16(100i16), 2i16); + assert_eq!(cttz32(100i32), 2i32); + assert_eq!(cttz64(100i64), 2i64); + + assert_eq!(cttz8(-1i8), 0i8); + assert_eq!(cttz16(-1i16), 0i16); + assert_eq!(cttz32(-1i32), 0i32); + assert_eq!(cttz64(-1i64), 0i64); + + assert_eq!(bswap16(0x0A0Bi16), 0x0B0Ai16); + assert_eq!(bswap32(0x0ABBCC0Di32), 0x0DCCBB0Ai32); + assert_eq!(bswap64(0x0122334455667708i64), 0x0877665544332201i64); } } diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs index cd15dfa2a0d..22c88c874f0 100644 --- a/src/test/run-pass/issue-1112.rs +++ b/src/test/run-pass/issue-1112.rs @@ -35,10 +35,10 @@ pub fn main() { } fn bar<T>(x: X<T>) { - assert!(x.b == 9u8); - assert!(x.c == true); - assert!(x.d == 10u8); - assert!(x.e == 11u16); - assert!(x.f == 12u8); - assert!(x.g == 13u8); + assert_eq!(x.b, 9u8); + assert_eq!(x.c, true); + assert_eq!(x.d, 10u8); + assert_eq!(x.e, 11u16); + assert_eq!(x.f, 12u8); + assert_eq!(x.g, 13u8); } diff --git a/src/test/run-pass/issue-1458.rs b/src/test/run-pass/issue-1458.rs index 0677c9dea74..e22f38287ad 100644 --- a/src/test/run-pass/issue-1458.rs +++ b/src/test/run-pass/issue-1458.rs @@ -18,5 +18,5 @@ fn ret_plus_one() -> extern fn(&fn() -> int) -> int { pub fn main() { let z = do (ret_plus_one()) || { 2 }; - assert!(z == 3); + assert_eq!(z, 3); } diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs index c8937a2a628..4f3d0dbe133 100644 --- a/src/test/run-pass/issue-1701.rs +++ b/src/test/run-pass/issue-1701.rs @@ -24,8 +24,8 @@ fn noise(a: animal) -> Option<~str> { } pub fn main() { - assert!(noise(cat(tabby)) == Some(~"meow")); - assert!(noise(dog(pug)) == Some(~"woof")); - assert!(noise(rabbit(~"Hilbert", upright)) == None); - assert!(noise(tiger) == Some(~"roar")); + assert_eq!(noise(cat(tabby)), Some(~"meow")); + assert_eq!(noise(dog(pug)), Some(~"woof")); + assert_eq!(noise(rabbit(~"Hilbert", upright)), None); + assert_eq!(noise(tiger), Some(~"roar")); } diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs index d63e01ec396..8e4309e08e4 100644 --- a/src/test/run-pass/issue-2214.rs +++ b/src/test/run-pass/issue-2214.rs @@ -44,5 +44,5 @@ mod m { pub fn main() { let mut y: int = 5; let x: &mut int = &mut y; - assert!((lgamma(1.0 as c_double, x) == 0.0 as c_double)); + assert_eq!(lgamma(1.0 as c_double, x), 0.0 as c_double); } diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs index c3a2a4c0b7e..0914c81c3ff 100644 --- a/src/test/run-pass/issue-2216.rs +++ b/src/test/run-pass/issue-2216.rs @@ -28,5 +28,5 @@ pub fn main() { } error!("%?", x); - assert!((x == 42)); + assert_eq!(x, 42); } diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs index 29fa357ba1a..548f0689796 100644 --- a/src/test/run-pass/issue-2428.rs +++ b/src/test/run-pass/issue-2428.rs @@ -16,5 +16,5 @@ pub fn main() { Bar = quux } - assert!((Bar as int == quux)); + assert_eq!(Bar as int, quux); } diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index e46d2a923a8..55be1056eca 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -111,7 +111,7 @@ pub mod pipes { return Some(payload.unwrap()) } terminated => { - assert!(old_state == terminated); + assert_eq!(old_state, terminated); return None; } } diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs index b9efb441ae7..3ca8d49eb86 100644 --- a/src/test/run-pass/issue-2748-b.rs +++ b/src/test/run-pass/issue-2748-b.rs @@ -14,6 +14,6 @@ pub fn main() { let x = &[1,2,3]; let y = x; let z = thing(x); - assert!((z[2] == x[2])); - assert!((z[1] == y[1])); + assert_eq!(z[2], x[2]); + assert_eq!(z[1], y[1]); } diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs index bd075555df1..780ea2dc2c9 100644 --- a/src/test/run-pass/issue-2895.rs +++ b/src/test/run-pass/issue-2895.rs @@ -22,13 +22,13 @@ impl Drop for Kitty { #[cfg(target_arch = "x86_64")] pub fn main() { - assert!((sys::size_of::<Cat>() == 8 as uint)); - assert!((sys::size_of::<Kitty>() == 16 as uint)); + assert_eq!(sys::size_of::<Cat>(), 8 as uint); + assert_eq!(sys::size_of::<Kitty>(), 16 as uint); } #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] pub fn main() { - assert!((sys::size_of::<Cat>() == 4 as uint)); - assert!((sys::size_of::<Kitty>() == 8 as uint)); + assert_eq!(sys::size_of::<Cat>(), 4 as uint); + assert_eq!(sys::size_of::<Kitty>(), 8 as uint); } diff --git a/src/test/run-pass/issue-2936.rs b/src/test/run-pass/issue-2936.rs index b989be0c182..183eb6e079f 100644 --- a/src/test/run-pass/issue-2936.rs +++ b/src/test/run-pass/issue-2936.rs @@ -34,5 +34,5 @@ fn cbar(x: int) -> cbar { pub fn main() { let x: int = foo::<int, cbar>(cbar(5)); - assert!(x == 5); + assert_eq!(x, 5); } diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs index fb5df6d50e0..5aaa3e595e1 100644 --- a/src/test/run-pass/issue-2989.rs +++ b/src/test/run-pass/issue-2989.rs @@ -41,5 +41,5 @@ pub fn main() { io::println(fmt!("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint)); } - assert!(bools == bools2); + assert_eq!(bools, bools2); } diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs index aa0625aa110..c4c2c2b7da8 100644 --- a/src/test/run-pass/issue-3091.rs +++ b/src/test/run-pass/issue-3091.rs @@ -11,5 +11,5 @@ pub fn main() { let x = 1; let y = 1; - assert!(&x == &y); + assert_eq!(&x, &y); } diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs index 02e61fc7ce2..360df325919 100644 --- a/src/test/run-pass/issue-3211.rs +++ b/src/test/run-pass/issue-3211.rs @@ -3,6 +3,6 @@ pub fn main() { for 4096.times { x += 1; } - assert!(x == 4096); + assert_eq!(x, 4096); io::println(fmt!("x = %u", x)); } diff --git a/src/test/run-pass/issue-3683.rs b/src/test/run-pass/issue-3683.rs index bdb191488b9..0072439935b 100644 --- a/src/test/run-pass/issue-3683.rs +++ b/src/test/run-pass/issue-3683.rs @@ -24,5 +24,5 @@ impl Foo for int { } pub fn main() { - assert!((3.b() == 5)); + assert_eq!(3.b(), 5); } diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs index 57962911538..b91ec5711cf 100644 --- a/src/test/run-pass/issue-3979-generics.rs +++ b/src/test/run-pass/issue-3979-generics.rs @@ -37,5 +37,5 @@ impl Movable<int, int> for Point; pub fn main() { let p = Point{ x: 1, y: 2}; p.translate(3); - assert!(p.X() == 4); + assert_eq!(p.X(), 4); } diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs index 5ecf80f4812..4bde414c4ac 100644 --- a/src/test/run-pass/issue-3979-xcrate.rs +++ b/src/test/run-pass/issue-3979-xcrate.rs @@ -29,5 +29,5 @@ impl Movable for Point; pub fn main() { let mut p = Point{ x: 1, y: 2}; p.translate(3); - assert!(p.X() == 4); + assert_eq!(p.X(), 4); } diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs index 2303c52be58..beffea1dbf3 100644 --- a/src/test/run-pass/issue-3979.rs +++ b/src/test/run-pass/issue-3979.rs @@ -40,5 +40,5 @@ impl Movable for Point; pub fn main() { let mut p = Point{ x: 1, y: 2}; p.translate(3); - assert!(p.X() == 4); + assert_eq!(p.X(), 4); } diff --git a/src/test/run-pass/issue-4241.rs b/src/test/run-pass/issue-4241.rs index e5905e7a5be..5503441771c 100644 --- a/src/test/run-pass/issue-4241.rs +++ b/src/test/run-pass/issue-4241.rs @@ -28,13 +28,13 @@ priv fn parse_data(len: uint, io: @io::Reader) -> Result { let res = if (len > 0) { let bytes = io.read_bytes(len as uint); - assert!(bytes.len() == len); + assert_eq!(bytes.len(), len); Data(bytes) } else { Data(~[]) }; - assert!(io.read_char() == '\r'); - assert!(io.read_char() == '\n'); + assert_eq!(io.read_char(), '\r'); + assert_eq!(io.read_char(), '\n'); return res; } diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs index e509cb828f8..73faa9845e7 100644 --- a/src/test/run-pass/issue-4401.rs +++ b/src/test/run-pass/issue-4401.rs @@ -3,6 +3,6 @@ pub fn main() { for 999_999.times() { count += 1; } - assert!(count == 999_999); + assert_eq!(count, 999_999); io::println(fmt!("%u", count)); } diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index 68abeef15de..e1ec65bc10f 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -12,7 +12,7 @@ pub fn main() { let (port, chan) = comm::stream::<&'static str>(); do task::spawn { - assert!(port.recv() == "hello, world"); + assert_eq!(port.recv(), "hello, world"); } chan.send("hello, world"); diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs index 70d7df3f787..20bb8ea965b 100644 --- a/src/test/run-pass/issue-979.rs +++ b/src/test/run-pass/issue-979.rs @@ -33,5 +33,5 @@ pub fn main() { let p = Some(r(b)); } - assert!(*b == 1); + assert_eq!(*b, 1); } diff --git a/src/test/run-pass/issue2378c.rs b/src/test/run-pass/issue2378c.rs index 98e60c56476..ade192618dc 100644 --- a/src/test/run-pass/issue2378c.rs +++ b/src/test/run-pass/issue2378c.rs @@ -20,5 +20,5 @@ use issue2378b::{two_maybes}; pub fn main() { let x = two_maybes{a: just(3), b: just(5)}; - assert!(x[0u] == (3, 5)); + assert_eq!(x[0u], (3, 5)); } diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs index 2f641993467..a82b2639449 100644 --- a/src/test/run-pass/istr.rs +++ b/src/test/run-pass/istr.rs @@ -12,7 +12,7 @@ fn test_stack_assign() { let s: ~str = ~"a"; debug!(s.clone()); let t: ~str = ~"a"; - assert!((s == t)); + assert!(s == t); let u: ~str = ~"b"; assert!((s != u)); } @@ -22,7 +22,7 @@ fn test_heap_lit() { ~"a big string"; } fn test_heap_assign() { let s: ~str = ~"a big ol' string"; let t: ~str = ~"a big ol' string"; - assert!((s == t)); + assert!(s == t); let u: ~str = ~"a bad ol' string"; assert!((s != u)); } @@ -30,34 +30,34 @@ fn test_heap_assign() { fn test_heap_log() { let s = ~"a big ol' string"; debug!(s); } fn test_stack_add() { - assert!((~"a" + ~"b" == ~"ab")); + assert_eq!(~"a" + ~"b", ~"ab"); let s: ~str = ~"a"; - assert!((s + s == ~"aa")); - assert!((~"" + ~"" == ~"")); + assert_eq!(s + s, ~"aa"); + assert_eq!(~"" + ~"", ~""); } fn test_stack_heap_add() { assert!((~"a" + ~"bracadabra" == ~"abracadabra")); } fn test_heap_add() { - assert!((~"this should" + ~" totally work" == ~"this should totally work")); + assert_eq!(~"this should" + ~" totally work", ~"this should totally work"); } fn test_append() { let mut s = ~""; s += ~"a"; - assert!((s == ~"a")); + assert_eq!(s, ~"a"); let mut s = ~"a"; s += ~"b"; debug!(s.clone()); - assert!((s == ~"ab")); + assert_eq!(s, ~"ab"); let mut s = ~"c"; s += ~"offee"; - assert!((s == ~"coffee")); + assert!(s == ~"coffee"); s += ~"&tea"; - assert!((s == ~"coffee&tea")); + assert!(s == ~"coffee&tea"); } pub fn main() { diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs index fe10ecdcf95..5d5db170efe 100644 --- a/src/test/run-pass/iter-contains.rs +++ b/src/test/run-pass/iter-contains.rs @@ -9,12 +9,12 @@ // except according to those terms. pub fn main() { - assert!([].contains(&22u) == false); - assert!([1u, 3u].contains(&22u) == false); - assert!([22u, 1u, 3u].contains(&22u) == true); - assert!([1u, 22u, 3u].contains(&22u) == true); - assert!([1u, 3u, 22u].contains(&22u) == true); - assert!(old_iter::contains(&None::<uint>, &22u) == false); - assert!(old_iter::contains(&Some(1u), &22u) == false); - assert!(old_iter::contains(&Some(22u), &22u) == true); + assert_eq!([].contains(&22u), false); + assert_eq!([1u, 3u].contains(&22u), false); + assert_eq!([22u, 1u, 3u].contains(&22u), true); + assert_eq!([1u, 22u, 3u].contains(&22u), true); + assert_eq!([1u, 3u, 22u].contains(&22u), true); + assert_eq!(old_iter::contains(&None::<uint>, &22u), false); + assert_eq!(old_iter::contains(&Some(1u), &22u), false); + assert_eq!(old_iter::contains(&Some(22u), &22u), true); } diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs index 8e061775c2b..3f717195fbc 100644 --- a/src/test/run-pass/iter-count.rs +++ b/src/test/run-pass/iter-count.rs @@ -9,11 +9,11 @@ // except according to those terms. pub fn main() { - assert!([].count(&22u) == 0u); - assert!([1u, 3u].count(&22u) == 0u); - assert!([22u, 1u, 3u].count(&22u) == 1u); - assert!([22u, 1u, 22u].count(&22u) == 2u); - assert!(old_iter::count(&None::<uint>, &22u) == 0u); - assert!(old_iter::count(&Some(1u), &22u) == 0u); - assert!(old_iter::count(&Some(22u), &22u) == 1u); + assert_eq!([].count(&22u), 0u); + assert_eq!([1u, 3u].count(&22u), 0u); + assert_eq!([22u, 1u, 3u].count(&22u), 1u); + assert_eq!([22u, 1u, 22u].count(&22u), 2u); + assert_eq!(old_iter::count(&None::<uint>, &22u), 0u); + assert_eq!(old_iter::count(&Some(1u), &22u), 0u); + assert_eq!(old_iter::count(&Some(22u), &22u), 1u); } diff --git a/src/test/run-pass/iter-eachi.rs b/src/test/run-pass/iter-eachi.rs index 03130a6632c..781f02230c0 100644 --- a/src/test/run-pass/iter-eachi.rs +++ b/src/test/run-pass/iter-eachi.rs @@ -11,17 +11,17 @@ pub fn main() { let mut c = 0u; for [1u, 2u, 3u, 4u, 5u].eachi |i, v| { - assert!((i + 1u) == *v); + assert_eq!((i + 1u), *v); c += 1u; } - assert!(c == 5u); + assert_eq!(c, 5u); for old_iter::eachi(&None::<uint>) |i, v| { fail!(); } let mut c = 0u; for old_iter::eachi(&Some(1u)) |i, v| { - assert!((i + 1u) == *v); + assert_eq!((i + 1u), *v); c += 1u; } - assert!(c == 1u); + assert_eq!(c, 1u); } diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs index a9cdec9a0b7..0bb7cd1c4dd 100644 --- a/src/test/run-pass/iter-filter-to-vec.rs +++ b/src/test/run-pass/iter-filter-to-vec.rs @@ -11,9 +11,9 @@ fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { - assert!([1, 3].filter_to_vec(is_even) == ~[]); - assert!([1, 2, 3].filter_to_vec(is_even) == ~[2]); - assert!(old_iter::filter_to_vec(&None::<uint>, is_even) == ~[]); - assert!(old_iter::filter_to_vec(&Some(1u), is_even) == ~[]); - assert!(old_iter::filter_to_vec(&Some(2u), is_even) == ~[2]); + assert_eq!([1, 3].filter_to_vec(is_even), ~[]); + assert_eq!([1, 2, 3].filter_to_vec(is_even), ~[2]); + assert_eq!(old_iter::filter_to_vec(&None::<uint>, is_even), ~[]); + assert_eq!(old_iter::filter_to_vec(&Some(1u), is_even), ~[]); + assert_eq!(old_iter::filter_to_vec(&Some(2u), is_even), ~[2]); } diff --git a/src/test/run-pass/iter-flat-map-to-vec.rs b/src/test/run-pass/iter-flat-map-to-vec.rs index d9a7791527e..af23905fe76 100644 --- a/src/test/run-pass/iter-flat-map-to-vec.rs +++ b/src/test/run-pass/iter-flat-map-to-vec.rs @@ -15,15 +15,15 @@ fn incd_if_even(x: &uint) -> Option<uint> { } pub fn main() { - assert!((~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u]); - assert!((~[]).flat_map_to_vec(repeat) == ~[]); - assert!(old_iter::flat_map_to_vec(&None::<uint>, repeat) == ~[]); - assert!(old_iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u]); - assert!(old_iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u]); + assert_eq!((~[1u, 3u]).flat_map_to_vec(repeat), ~[1u, 1u, 3u, 3u]); + assert_eq!((~[]).flat_map_to_vec(repeat), ~[]); + assert_eq!(old_iter::flat_map_to_vec(&None::<uint>, repeat), ~[]); + assert_eq!(old_iter::flat_map_to_vec(&Some(1u), repeat), ~[1u, 1u]); + assert_eq!(old_iter::flat_map_to_vec(&Some(2u), repeat), ~[2u, 2u]); - assert!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u]); - assert!((~[]).flat_map_to_vec(incd_if_even) == ~[]); - assert!(old_iter::flat_map_to_vec(&None::<uint>, incd_if_even) == ~[]); - assert!(old_iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[]); - assert!(old_iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u]); + assert_eq!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even), ~[3u]); + assert_eq!((~[]).flat_map_to_vec(incd_if_even), ~[]); + assert_eq!(old_iter::flat_map_to_vec(&None::<uint>, incd_if_even), ~[]); + assert_eq!(old_iter::flat_map_to_vec(&Some(1u), incd_if_even), ~[]); + assert_eq!(old_iter::flat_map_to_vec(&Some(2u), incd_if_even), ~[3u]); } diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs index b299cf83225..f40abe0c56c 100644 --- a/src/test/run-pass/iter-foldl.rs +++ b/src/test/run-pass/iter-foldl.rs @@ -11,9 +11,9 @@ fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) } pub fn main() { - assert!([1u, 3u].foldl(20f, add) == 24f); - assert!([].foldl(20f, add) == 20f); - assert!(old_iter::foldl(&None::<uint>, 20f, add) == 20f); - assert!(old_iter::foldl(&Some(1u), 20f, add) == 21f); - assert!(old_iter::foldl(&Some(2u), 20f, add) == 22f); + assert_eq!([1u, 3u].foldl(20f, add), 24f); + assert_eq!([].foldl(20f, add), 20f); + assert_eq!(old_iter::foldl(&None::<uint>, 20f, add), 20f); + assert_eq!(old_iter::foldl(&Some(1u), 20f, add), 21f); + assert_eq!(old_iter::foldl(&Some(2u), 20f, add), 22f); } diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs index 4e9976e4eb9..e9fd68d10f1 100644 --- a/src/test/run-pass/iter-map-to-vec.rs +++ b/src/test/run-pass/iter-map-to-vec.rs @@ -11,9 +11,9 @@ fn inc(x: &uint) -> uint { *x + 1 } pub fn main() { - assert!([1, 3].map_to_vec(inc) == ~[2, 4]); - assert!([1, 2, 3].map_to_vec(inc) == ~[2, 3, 4]); - assert!(old_iter::map_to_vec(&None::<uint>, inc) == ~[]); - assert!(old_iter::map_to_vec(&Some(1u), inc) == ~[2]); - assert!(old_iter::map_to_vec(&Some(2u), inc) == ~[3]); + assert_eq!([1, 3].map_to_vec(inc), ~[2, 4]); + assert_eq!([1, 2, 3].map_to_vec(inc), ~[2, 3, 4]); + assert_eq!(old_iter::map_to_vec(&None::<uint>, inc), ~[]); + assert_eq!(old_iter::map_to_vec(&Some(1u), inc), ~[2]); + assert_eq!(old_iter::map_to_vec(&Some(2u), inc), ~[3]); } diff --git a/src/test/run-pass/iter-min-max.rs b/src/test/run-pass/iter-min-max.rs index 5f427861e79..6ce24aedf13 100644 --- a/src/test/run-pass/iter-min-max.rs +++ b/src/test/run-pass/iter-min-max.rs @@ -11,11 +11,11 @@ fn is_even(x: uint) -> bool { (x % 2u) == 0u } pub fn main() { - assert!([1u, 3u].min() == 1u); - assert!([3u, 1u].min() == 1u); - assert!(old_iter::min(&Some(1u)) == 1u); + assert_eq!([1u, 3u].min(), 1u); + assert_eq!([3u, 1u].min(), 1u); + assert_eq!(old_iter::min(&Some(1u)), 1u); - assert!([1u, 3u].max() == 3u); - assert!([3u, 1u].max() == 3u); - assert!(old_iter::max(&Some(3u)) == 3u); + assert_eq!([1u, 3u].max(), 3u); + assert_eq!([3u, 1u].max(), 3u); + assert_eq!(old_iter::max(&Some(3u)), 3u); } diff --git a/src/test/run-pass/iter-to-vec.rs b/src/test/run-pass/iter-to-vec.rs index d7fdcdbe4e0..b7f2ac77074 100644 --- a/src/test/run-pass/iter-to-vec.rs +++ b/src/test/run-pass/iter-to-vec.rs @@ -9,10 +9,10 @@ // except according to those terms. pub fn main() { - assert!([1u, 3u].to_vec() == ~[1u, 3u]); + assert_eq!([1u, 3u].to_vec(), ~[1u, 3u]); let e: ~[uint] = ~[]; - assert!(e.to_vec() == ~[]); - assert!(old_iter::to_vec(&None::<uint>) == ~[]); - assert!(old_iter::to_vec(&Some(1u)) == ~[1u]); - assert!(old_iter::to_vec(&Some(2u)) == ~[2u]); + assert_eq!(e.to_vec(), ~[]); + assert_eq!(old_iter::to_vec(&None::<uint>), ~[]); + assert_eq!(old_iter::to_vec(&Some(1u)), ~[1u]); + assert_eq!(old_iter::to_vec(&Some(2u)), ~[2u]); } diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs index bd58ae65651..80168daf62d 100644 --- a/src/test/run-pass/ivec-add.rs +++ b/src/test/run-pass/ivec-add.rs @@ -14,10 +14,10 @@ fn double_int(a: int) -> ~[int] { return ~[a] + ~[a]; } pub fn main() { let mut d = double(1); - assert!((d[0] == 1)); - assert!((d[1] == 1)); + assert_eq!(d[0], 1); + assert_eq!(d[1], 1); d = double_int(1); - assert!((d[0] == 1)); - assert!((d[1] == 1)); + assert_eq!(d[0], 1); + assert_eq!(d[1], 1); } diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs index 3fb554dc450..35b5e077e7a 100644 --- a/src/test/run-pass/kindck-owned-trait-contains-1.rs +++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs @@ -22,5 +22,5 @@ fn repeater<A:Copy>(v: @A) -> @repeat<A> { pub fn main() { let x = &3; let y = repeater(@x); - assert!(*x == *(y.get())); + assert_eq!(*x, *(y.get())); } diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs index 442e79bde77..75c3008af8e 100644 --- a/src/test/run-pass/last-use-in-cap-clause.rs +++ b/src/test/run-pass/last-use-in-cap-clause.rs @@ -20,5 +20,5 @@ fn foo() -> @fn() -> int { } pub fn main() { - assert!(foo()() == 22); + assert_eq!(foo()(), 22); } diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs index 1a1e4816a36..74febe6ff7d 100644 --- a/src/test/run-pass/lazy-and-or.rs +++ b/src/test/run-pass/lazy-and-or.rs @@ -17,6 +17,6 @@ pub fn main() { assert!((x)); let mut y: int = 10; debug!(x || incr(&mut y)); - assert!((y == 10)); + assert_eq!(y, 10); if true && x { assert!((true)); } else { assert!((false)); } } diff --git a/src/test/run-pass/let-destruct-fresh-mem.rs b/src/test/run-pass/let-destruct-fresh-mem.rs index ae6118d063e..500502320df 100644 --- a/src/test/run-pass/let-destruct-fresh-mem.rs +++ b/src/test/run-pass/let-destruct-fresh-mem.rs @@ -16,8 +16,8 @@ pub fn main() { let mut X {x: x, y: @A {a: a}} = u; x = 100; a = 100; - assert!((x == 100)); - assert!((a == 100)); - assert!((u.x == 10)); - assert!((u.y.a == 20)); + assert_eq!(x, 100); + assert_eq!(a, 100); + assert_eq!(u.x, 10); + assert_eq!(u.y.a, 20); } diff --git a/src/test/run-pass/let-destruct.rs b/src/test/run-pass/let-destruct.rs index 6e2ce508928..aab19b31397 100644 --- a/src/test/run-pass/let-destruct.rs +++ b/src/test/run-pass/let-destruct.rs @@ -14,5 +14,5 @@ struct X { x: xx, y: int } pub fn main() { let @X {x: xx(x), y: y} = @X{x: xx(10), y: 20}; - assert!((x + y == 30)); + assert_eq!(x + y, 30); } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index f2fb63cfc9e..c9f768d7606 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -15,7 +15,7 @@ pub fn main() { let mut y = 0; for x.each |i| { debug!(*i); y += *i; } debug!(y); - assert!((y == 6)); + assert_eq!(y, 6); let s = ~"hello there"; let mut i: int = 0; for str::each(s) |c| { @@ -30,5 +30,5 @@ pub fn main() { debug!(i); debug!(c); } - assert!((i == 11)); + assert_eq!(i, 11); } diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs index 44e1292d9b1..2cddc510422 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs @@ -19,7 +19,7 @@ enum foo { } fn check_log<T>(exp: ~str, v: T) { - assert!(exp == fmt!("%?", v)); + assert_eq!(exp, fmt!("%?", v)); } pub fn main() { diff --git a/src/test/run-pass/log-knows-the-names-of-variants.rs b/src/test/run-pass/log-knows-the-names-of-variants.rs index 641d6155e23..7a0d763f7e0 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants.rs @@ -19,8 +19,8 @@ enum bar { } pub fn main() { - assert!(~"a(22)" == fmt!("%?", a(22u))); - assert!(~"b(~\"hi\")" == fmt!("%?", b(~"hi"))); - assert!(~"c" == fmt!("%?", c)); - assert!(~"d" == fmt!("%?", d)); + assert_eq!(~"a(22)", fmt!("%?", a(22u))); + assert_eq!(~"b(~\"hi\")", fmt!("%?", b(~"hi"))); + assert_eq!(~"c", fmt!("%?", c)); + assert_eq!(~"d", fmt!("%?", d)); } diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs index e321789a2b1..d45602d9ed1 100644 --- a/src/test/run-pass/log-str.rs +++ b/src/test/run-pass/log-str.rs @@ -10,8 +10,8 @@ pub fn main() { let act = sys::log_str(&~[1, 2, 3]); - assert!(~"~[1, 2, 3]" == act); + assert_eq!(~"~[1, 2, 3]", act); let act = fmt!("%?/%6?", ~[1, 2, 3], ~"hi"); - assert!(act == ~"~[1, 2, 3]/ ~\"hi\""); + assert_eq!(act, ~"~[1, 2, 3]/ ~\"hi\""); } diff --git a/src/test/run-pass/loop-break-cont.rs b/src/test/run-pass/loop-break-cont.rs index 4a4da79367f..64d2b3d0b21 100644 --- a/src/test/run-pass/loop-break-cont.rs +++ b/src/test/run-pass/loop-break-cont.rs @@ -17,7 +17,7 @@ pub fn main() { break; } } - assert!((i == 10u)); + assert_eq!(i, 10u); let mut is_even = false; loop { if i == 21u { diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs index a3caf1e4800..07be3bd6c81 100644 --- a/src/test/run-pass/loop-scope.rs +++ b/src/test/run-pass/loop-scope.rs @@ -12,5 +12,5 @@ pub fn main() { let x = ~[10, 20, 30]; let mut sum = 0; for x.each |x| { sum += *x; } - assert!((sum == 60)); + assert_eq!(sum, 60); } diff --git a/src/test/run-pass/macro-path.rs b/src/test/run-pass/macro-path.rs index a3bd03c80bc..4aa15879434 100644 --- a/src/test/run-pass/macro-path.rs +++ b/src/test/run-pass/macro-path.rs @@ -20,5 +20,5 @@ macro_rules! foo { } pub fn main() { - assert!(foo!(m::t) == 10); + assert_eq!(foo!(m::t), 10); } diff --git a/src/test/run-pass/macro-stmt.rs b/src/test/run-pass/macro-stmt.rs index d9417ee0a19..66f16bc9f2e 100644 --- a/src/test/run-pass/macro-stmt.rs +++ b/src/test/run-pass/macro-stmt.rs @@ -27,16 +27,16 @@ pub fn main() { ); mylet!(y, 8*2); - assert!((y == 16)); + assert_eq!(y, 16); myfn!(mult, (a,b), { a*b } ); - assert!((mult(2, add(4,4)) == 16)); + assert_eq!(mult(2, add(4,4)), 16); macro_rules! actually_an_expr_macro ( () => ( 16 ) ) - assert!({ actually_an_expr_macro!() } == 16); + assert_eq!({ actually_an_expr_macro!() }, 16); } diff --git a/src/test/run-pass/mod-inside-fn.rs b/src/test/run-pass/mod-inside-fn.rs index e4bc850644e..388d2e4905f 100644 --- a/src/test/run-pass/mod-inside-fn.rs +++ b/src/test/run-pass/mod-inside-fn.rs @@ -17,5 +17,5 @@ fn f() -> int { } pub fn main() { - assert!(f() == 720); + assert_eq!(f(), 720); } diff --git a/src/test/run-pass/mod-merge-hack.rs b/src/test/run-pass/mod-merge-hack.rs index 10f661b4f8d..fdef8c5b541 100644 --- a/src/test/run-pass/mod-merge-hack.rs +++ b/src/test/run-pass/mod-merge-hack.rs @@ -14,6 +14,6 @@ mod myint32; pub fn main() { - assert!(myint32::bits == 32); - assert!(myint32::min(10, 20) == 10); + assert_eq!(myint32::bits, 32); + assert_eq!(myint32::min(10, 20), 10); } diff --git a/src/test/run-pass/mod_dir_path.rs b/src/test/run-pass/mod_dir_path.rs index f0cc4aa52d6..a356a0ab07e 100644 --- a/src/test/run-pass/mod_dir_path.rs +++ b/src/test/run-pass/mod_dir_path.rs @@ -17,5 +17,5 @@ mod mod_dir_simple { } pub fn main() { - assert!(mod_dir_simple::syrup::foo() == 10); + assert_eq!(mod_dir_simple::syrup::foo(), 10); } diff --git a/src/test/run-pass/mod_dir_path2.rs b/src/test/run-pass/mod_dir_path2.rs index 2635084a072..6119e9631e8 100644 --- a/src/test/run-pass/mod_dir_path2.rs +++ b/src/test/run-pass/mod_dir_path2.rs @@ -18,5 +18,5 @@ mod pancakes { } pub fn main() { - assert!(pancakes::syrup::foo() == 10); + assert_eq!(pancakes::syrup::foo(), 10); } diff --git a/src/test/run-pass/mod_dir_path3.rs b/src/test/run-pass/mod_dir_path3.rs index 0971120eb6f..00282658508 100644 --- a/src/test/run-pass/mod_dir_path3.rs +++ b/src/test/run-pass/mod_dir_path3.rs @@ -17,5 +17,5 @@ mod pancakes { } pub fn main() { - assert!(pancakes::test::foo() == 10); + assert_eq!(pancakes::test::foo(), 10); } diff --git a/src/test/run-pass/mod_dir_path_multi.rs b/src/test/run-pass/mod_dir_path_multi.rs index c6ab45d1b3a..4766d330a4e 100644 --- a/src/test/run-pass/mod_dir_path_multi.rs +++ b/src/test/run-pass/mod_dir_path_multi.rs @@ -22,6 +22,6 @@ mod gravy { } pub fn main() { - assert!(biscuits::test::foo() == 10); - assert!(gravy::test::foo() == 10); + assert_eq!(biscuits::test::foo(), 10); + assert_eq!(gravy::test::foo(), 10); } diff --git a/src/test/run-pass/mod_dir_recursive.rs b/src/test/run-pass/mod_dir_recursive.rs index 5392671651d..a39d41414ff 100644 --- a/src/test/run-pass/mod_dir_recursive.rs +++ b/src/test/run-pass/mod_dir_recursive.rs @@ -20,5 +20,5 @@ mod mod_dir_simple { } pub fn main() { - assert!(mod_dir_simple::load_another_mod::test::foo() == 10); + assert_eq!(mod_dir_simple::load_another_mod::test::foo(), 10); } diff --git a/src/test/run-pass/mod_dir_simple.rs b/src/test/run-pass/mod_dir_simple.rs index 382911d4979..fbc522f07b2 100644 --- a/src/test/run-pass/mod_dir_simple.rs +++ b/src/test/run-pass/mod_dir_simple.rs @@ -16,5 +16,5 @@ mod mod_dir_simple { } pub fn main() { - assert!(mod_dir_simple::test::foo() == 10); + assert_eq!(mod_dir_simple::test::foo(), 10); } diff --git a/src/test/run-pass/mod_file.rs b/src/test/run-pass/mod_file.rs index a03dc044011..b2dd9311615 100644 --- a/src/test/run-pass/mod_file.rs +++ b/src/test/run-pass/mod_file.rs @@ -15,5 +15,5 @@ mod mod_file_aux; pub fn main() { - assert!(mod_file_aux::foo() == 10); + assert_eq!(mod_file_aux::foo(), 10); } diff --git a/src/test/run-pass/mod_file_with_path_attr.rs b/src/test/run-pass/mod_file_with_path_attr.rs index ecd4fd73a06..8455b662efa 100644 --- a/src/test/run-pass/mod_file_with_path_attr.rs +++ b/src/test/run-pass/mod_file_with_path_attr.rs @@ -16,5 +16,5 @@ mod m; pub fn main() { - assert!(m::foo() == 10); + assert_eq!(m::foo(), 10); } diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 303d5bc1b41..6803eb1c6d7 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -40,8 +40,8 @@ fn transform(x: Option<int>) -> Option<~str> { } pub fn main() { - assert!(transform(Some(10)) == Some(~"11")); - assert!(transform(None) == None); + assert_eq!(transform(Some(10)), Some(~"11")); + assert_eq!(transform(None), None); assert!((~[~"hi"]) .bind(|x| ~[x.clone(), *x + ~"!"] ) .bind(|x| ~[x.clone(), *x + ~"?"] ) == diff --git a/src/test/run-pass/monomorphize-trait-in-fn-at.rs b/src/test/run-pass/monomorphize-trait-in-fn-at.rs index 61d9456296e..8e36b1138bd 100644 --- a/src/test/run-pass/monomorphize-trait-in-fn-at.rs +++ b/src/test/run-pass/monomorphize-trait-in-fn-at.rs @@ -26,5 +26,5 @@ impl ty_ops for () { pub fn main() { let fn_env: @fn() -> uint = || mk_nil(()); - assert!(fn_env() == 22u); + assert_eq!(fn_env(), 22u); } diff --git a/src/test/run-pass/morestack3.rs b/src/test/run-pass/morestack3.rs index 07edf0d2e1c..a21b13743fe 100644 --- a/src/test/run-pass/morestack3.rs +++ b/src/test/run-pass/morestack3.rs @@ -21,15 +21,15 @@ fn getbig(a0: int, a8: int, a9: int) -> int { - assert!(a0 + 1 == a1); - assert!(a1 + 1 == a2); - assert!(a2 + 1 == a3); - assert!(a3 + 1 == a4); - assert!(a4 + 1 == a5); - assert!(a5 + 1 == a6); - assert!(a6 + 1 == a7); - assert!(a7 + 1 == a8); - assert!(a8 + 1 == a9); + assert_eq!(a0 + 1, a1); + assert_eq!(a1 + 1, a2); + assert_eq!(a2 + 1, a3); + assert_eq!(a3 + 1, a4); + assert_eq!(a4 + 1, a5); + assert_eq!(a5 + 1, a6); + assert_eq!(a6 + 1, a7); + assert_eq!(a7 + 1, a8); + assert_eq!(a8 + 1, a9); if a0 != 0 { let j = getbig(a0 - 1, a1 - 1, @@ -41,7 +41,7 @@ fn getbig(a0: int, a7 - 1, a8 - 1, a9 - 1); - assert!(j == a0 - 1); + assert_eq!(j, a0 - 1); } return a0; } diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs index 47902363db7..9194fc830e0 100644 --- a/src/test/run-pass/move-1-unique.rs +++ b/src/test/run-pass/move-1-unique.rs @@ -19,8 +19,8 @@ fn test(x: bool, foo: ~Triple) -> int { pub fn main() { let x = ~Triple{x: 1, y: 2, z: 3}; - assert!((test(true, copy x) == 2)); - assert!((test(true, copy x) == 2)); - assert!((test(true, copy x) == 2)); - assert!((test(false, x) == 5)); + assert_eq!(test(true, copy x), 2); + assert_eq!(test(true, copy x), 2); + assert_eq!(test(true, copy x), 2); + assert_eq!(test(false, x), 5); } diff --git a/src/test/run-pass/move-1.rs b/src/test/run-pass/move-1.rs index 04354d74159..5d3b25ebd7e 100644 --- a/src/test/run-pass/move-1.rs +++ b/src/test/run-pass/move-1.rs @@ -19,8 +19,8 @@ fn test(x: bool, foo: @Triple) -> int { pub fn main() { let x = @Triple {x: 1, y: 2, z: 3}; - assert!((test(true, x) == 2)); - assert!((test(true, x) == 2)); - assert!((test(true, x) == 2)); - assert!((test(false, x) == 5)); + assert_eq!(test(true, x), 2); + assert_eq!(test(true, x), 2); + assert_eq!(test(true, x), 2); + assert_eq!(test(false, x), 5); } diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs index 36c9c787b75..dcd4cc9a7ea 100644 --- a/src/test/run-pass/move-3-unique.rs +++ b/src/test/run-pass/move-3-unique.rs @@ -22,7 +22,7 @@ fn test(x: bool, foo: ~Triple) -> int { pub fn main() { let x = ~Triple{x: 1, y: 2, z: 3}; for uint::range(0u, 10000u) |_i| { - assert!((test(true, copy x) == 2)); + assert_eq!(test(true, copy x), 2); } - assert!((test(false, x) == 5)); + assert_eq!(test(false, x), 5); } diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs index f2b6b2f9980..42955b94721 100644 --- a/src/test/run-pass/move-3.rs +++ b/src/test/run-pass/move-3.rs @@ -22,7 +22,7 @@ fn test(x: bool, foo: @Triple) -> int { pub fn main() { let x = @Triple{x: 1, y: 2, z: 3}; for uint::range(0u, 10000u) |i| { - assert!((test(true, x) == 2)); + assert_eq!(test(true, x), 2); } - assert!((test(false, x) == 5)); + assert_eq!(test(false, x), 5); } diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs index fe544e54742..cd88b679361 100644 --- a/src/test/run-pass/move-4.rs +++ b/src/test/run-pass/move-4.rs @@ -24,5 +24,5 @@ fn test(foo: @Triple) -> @Triple { pub fn main() { let x = @Triple{a: 1, b: 2, c: 3}; let y = test(x); - assert!((y.c == 3)); + assert_eq!(y.c, 3); } diff --git a/src/test/run-pass/move-scalar.rs b/src/test/run-pass/move-scalar.rs index 6a8091d7b77..845cb8ab601 100644 --- a/src/test/run-pass/move-scalar.rs +++ b/src/test/run-pass/move-scalar.rs @@ -13,5 +13,5 @@ pub fn main() { let y: int = 42; let mut x: int; x = y; - assert!((x == 42)); + assert_eq!(x, 42); } diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs index 20813bb4a03..0fa89ba0f04 100644 --- a/src/test/run-pass/mut-function-arguments.rs +++ b/src/test/run-pass/mut-function-arguments.rs @@ -10,7 +10,7 @@ fn f(mut y: ~int) { *y = 5; - assert!(*y == 5); + assert_eq!(*y, 5); } fn g() { diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index c4caf716df2..aef857f36ee 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -11,7 +11,7 @@ fn test1() { let mut ints = [0, ..32]; ints[0] += 1; - assert!(ints[0] == 1); + assert_eq!(ints[0], 1); } fn test2() { diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index c6bf07536b1..42c623ec41c 100644 --- a/src/test/run-pass/mutable-alias-vec.rs +++ b/src/test/run-pass/mutable-alias-vec.rs @@ -22,5 +22,5 @@ pub fn main() { grow(&mut v); let len = vec::len::<int>(v); debug!(len); - assert!((len == 3 as uint)); + assert_eq!(len, 3 as uint); } diff --git a/src/test/run-pass/nested-class.rs b/src/test/run-pass/nested-class.rs index 83820f87d50..3bf4b53c184 100644 --- a/src/test/run-pass/nested-class.rs +++ b/src/test/run-pass/nested-class.rs @@ -26,6 +26,6 @@ pub fn main() { // fn b(x:int) -> int { fail!(); } let z = b(42); - assert!((z.i == 42)); - assert!((z.do_stuff() == 37)); + assert_eq!(z.i, 42); + assert_eq!(z.do_stuff(), 37); } diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs index 6c56e39d2d3..bd9e4bdfd87 100644 --- a/src/test/run-pass/nested-patterns.rs +++ b/src/test/run-pass/nested-patterns.rs @@ -20,8 +20,8 @@ pub fn main() { } let mut x@B {b, _} = B {a: 10, b: C {c: 20}}; x.b.c = 30; - assert!(b.c == 20); + assert_eq!(b.c, 20); let mut y@D {d, _} = D {a: 10, d: C {c: 20}}; y.d.c = 30; - assert!(d.c == 20); + assert_eq!(d.c, 20); } diff --git a/src/test/run-pass/newlambdas.rs b/src/test/run-pass/newlambdas.rs index 1fb98d54adc..c6536c68a83 100644 --- a/src/test/run-pass/newlambdas.rs +++ b/src/test/run-pass/newlambdas.rs @@ -19,11 +19,11 @@ fn ff() -> @fn(int) -> int { } pub fn main() { - assert!(f(10, |a| a) == 10); + assert_eq!(f(10, |a| a), 10); g(||()); - assert!(do f(10) |a| { a } == 10); + assert_eq!(do f(10) |a| { a }, 10); do g() { } let _x: @fn() -> int = || 10; let _y: @fn(int) -> int = |a| a; - assert!(ff()(10) == 11); + assert_eq!(ff()(10), 11); } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 6b1b97cfd5f..f88c71bdf39 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -16,7 +16,7 @@ fn myvec_elt<X:Copy>(mv: myvec<X>) -> X { return mv[0]; } pub fn main() { let mv = myvec(~[1, 2, 3]); - assert!((myvec_deref(copy mv)[1] == 2)); - assert!((myvec_elt(copy mv) == 1)); - assert!((mv[2] == 3)); + assert_eq!(myvec_deref(copy mv)[1], 2); + assert_eq!(myvec_elt(copy mv), 1); + assert_eq!(mv[2], 3); } diff --git a/src/test/run-pass/newtype.rs b/src/test/run-pass/newtype.rs index ad2c502f20e..6d36357ccfa 100644 --- a/src/test/run-pass/newtype.rs +++ b/src/test/run-pass/newtype.rs @@ -17,5 +17,5 @@ fn compute(i: mytype) -> int { return i.val + 20; } pub fn main() { let myval = mytype(Mytype{compute: compute, val: 30}); io::println(fmt!("%d", compute(myval))); - assert!(((myval.compute)(myval) == 50)); + assert_eq!((myval.compute)(myval), 50); } diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs index 6a76f9d1646..58ac4fc576d 100644 --- a/src/test/run-pass/non-boolean-pure-fns.rs +++ b/src/test/run-pass/non-boolean-pure-fns.rs @@ -30,5 +30,5 @@ fn safe_head<T:Copy>(ls: @List<T>) -> T { pub fn main() { let mylist = @Cons(@1u, @Nil); assert!((nonempty_list(mylist))); - assert!((*safe_head(mylist) == 1u)); + assert_eq!(*safe_head(mylist), 1u); } diff --git a/src/test/run-pass/non-legacy-modes.rs b/src/test/run-pass/non-legacy-modes.rs index 69feae49157..642686e06e5 100644 --- a/src/test/run-pass/non-legacy-modes.rs +++ b/src/test/run-pass/non-legacy-modes.rs @@ -17,7 +17,7 @@ fn apply<T>(x: T, f: &fn(T)) { } fn check_int(x: int) { - assert!(x == 22); + assert_eq!(x, 22); } fn check_struct(x: X) { diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs index 246fc4e304d..1e8ddc2905e 100644 --- a/src/test/run-pass/nullable-pointer-size.rs +++ b/src/test/run-pass/nullable-pointer-size.rs @@ -15,13 +15,13 @@ struct S<T>(int, T); macro_rules! check_option { ($T:ty) => { - assert!(sys::size_of::<Option<$T>>() == sys::size_of::<$T>()); + assert_eq!(sys::size_of::<Option<$T>>(), sys::size_of::<$T>()); } } macro_rules! check_fancy { ($T:ty) => { - assert!(sys::size_of::<E<$T>>() == sys::size_of::<S<$T>>()); + assert_eq!(sys::size_of::<E<$T>>(), sys::size_of::<S<$T>>()); } } diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs index 6a92c1c993c..8e932c4b14b 100644 --- a/src/test/run-pass/nullary-or-pattern.rs +++ b/src/test/run-pass/nullary-or-pattern.rs @@ -15,6 +15,6 @@ fn or_alt(q: blah) -> int { } pub fn main() { - assert!((or_alt(a) == 42)); - assert!((or_alt(b) == 42)); + assert_eq!(or_alt(a), 42); + assert_eq!(or_alt(b), 42); } diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index 719f1015684..7092f819015 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -17,26 +17,26 @@ pub fn main() { // ints // num - assert!(15i.add(&6) == 21); - assert!(15i8.add(&6i8) == 21i8); - assert!(15i16.add(&6i16) == 21i16); - assert!(15i32.add(&6i32) == 21i32); - assert!(15i64.add(&6i64) == 21i64); + assert_eq!(15i.add(&6), 21); + assert_eq!(15i8.add(&6i8), 21i8); + assert_eq!(15i16.add(&6i16), 21i16); + assert_eq!(15i32.add(&6i32), 21i32); + assert_eq!(15i64.add(&6i64), 21i64); // uints // num - assert!(15u.add(&6u) == 21u); - assert!(15u8.add(&6u8) == 21u8); - assert!(15u16.add(&6u16) == 21u16); - assert!(15u32.add(&6u32) == 21u32); - assert!(15u64.add(&6u64) == 21u64); + assert_eq!(15u.add(&6u), 21u); + assert_eq!(15u8.add(&6u8), 21u8); + assert_eq!(15u16.add(&6u16), 21u16); + assert_eq!(15u32.add(&6u32), 21u32); + assert_eq!(15u64.add(&6u64), 21u64); // times 15u.times(|| false); // floats // num - assert!(10f.to_int() == 10); - assert!(10f32.to_int() == 10); - assert!(10f64.to_int() == 10); + assert_eq!(10f.to_int(), 10); + assert_eq!(10f32.to_int(), 10); + assert_eq!(10f64.to_int(), 10); } diff --git a/src/test/run-pass/one-tuple.rs b/src/test/run-pass/one-tuple.rs index eb32e7cda1a..8377a45a1d8 100644 --- a/src/test/run-pass/one-tuple.rs +++ b/src/test/run-pass/one-tuple.rs @@ -13,11 +13,11 @@ pub fn main() { match ('c',) { (x,) => { - assert!(x == 'c'); + assert_eq!(x, 'c'); } } // test the 1-tuple type too let x: (char,) = ('d',); let (y,) = x; - assert!(y == 'd'); + assert_eq!(y, 'd'); } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index 004aa864f99..652ac24d35d 100644 --- a/src/test/run-pass/opeq.rs +++ b/src/test/run-pass/opeq.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x: int = 1; x *= 2; debug!(x); - assert!((x == 2)); + assert_eq!(x, 2); x += 3; debug!(x); - assert!((x == 5)); + assert_eq!(x, 5); x *= x; debug!(x); - assert!((x == 25)); + assert_eq!(x, 25); x /= 5; debug!(x); - assert!((x == 5)); + assert_eq!(x, 5); } diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index 8c26dfa1fac..b54e3188dae 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -56,14 +56,14 @@ pub fn main() { let mut p = Point {x: 10, y: 20}; p += Point {x: 101, y: 102}; p = p - Point {x: 100, y: 100}; - assert!(p + Point {x: 5, y: 5} == Point {x: 16, y: 27}); - assert!(-p == Point {x: -11, y: -22}); - assert!(p[true] == 11); - assert!(p[false] == 22); + assert_eq!(p + Point {x: 5, y: 5}, Point {x: 16, y: 27}); + assert_eq!(-p, Point {x: -11, y: -22}); + assert_eq!(p[true], 11); + assert_eq!(p[false], 22); let q = !p; - assert!(q.x == !(p.x)); - assert!(q.y == !(p.y)); + assert_eq!(q.x, !(p.x)); + assert_eq!(q.y, !(p.y)); // Issue #1733 let result: ~fn(int) = |_|(); diff --git a/src/test/run-pass/option-unwrap.rs b/src/test/run-pass/option-unwrap.rs index 8698d1f39a8..ea8a6f236cd 100644 --- a/src/test/run-pass/option-unwrap.rs +++ b/src/test/run-pass/option-unwrap.rs @@ -38,5 +38,5 @@ pub fn main() { let c = unwrap(b); } - assert!(*x == 0); + assert_eq!(*x, 0); } diff --git a/src/test/run-pass/option_addition.rs b/src/test/run-pass/option_addition.rs index 10b8c92e7d6..07996cb439d 100644 --- a/src/test/run-pass/option_addition.rs +++ b/src/test/run-pass/option_addition.rs @@ -22,9 +22,9 @@ pub fn main() { None => (), Some(foo) => fail!("expected None, but found %?", foo) } - assert!(foo == somefoo.get()); - assert!(bar == somebar.get()); - assert!(foobar == somefoobar.get()); + assert_eq!(foo, somefoo.get()); + assert_eq!(bar, somebar.get()); + assert_eq!(foobar, somefoobar.get()); } fn optint(in: int) -> Option<int> { diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs index 93d51ab7e8b..a014257fb1c 100644 --- a/src/test/run-pass/or-pattern.rs +++ b/src/test/run-pass/or-pattern.rs @@ -15,7 +15,7 @@ fn or_alt(q: blah) -> int { } pub fn main() { - assert!((or_alt(c) == 0)); - assert!((or_alt(a(10, 100, 0u)) == 110)); - assert!((or_alt(b(20, 200)) == 220)); + assert_eq!(or_alt(c), 0); + assert_eq!(or_alt(a(10, 100, 0u)), 110); + assert_eq!(or_alt(b(20, 200)), 220); } diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs index 63d9ec17ccb..a2630c39803 100644 --- a/src/test/run-pass/pattern-bound-var-in-for-each.rs +++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs @@ -18,7 +18,7 @@ fn foo(src: uint) { Some(src_id) => { for uint::range(0u, 10u) |i| { let yyy = src_id; - assert!((yyy == 0u)); + assert_eq!(yyy, 0u); } } _ => { } diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index 8782f6f6ebd..7e0a59f57fc 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -66,7 +66,7 @@ pub fn main() { error!("selecting"); let (i, _, _) = select(~[left, right]); error!("selected"); - assert!(i == 0); + assert_eq!(i, 0); error!("waiting for pipes"); let stream::send(x, _) = recv(p); @@ -78,7 +78,7 @@ pub fn main() { let (i, m, _) = select(~[left, right]); error!("selected %?", i); if m.is_some() { - assert!(i == 1); + assert_eq!(i, 1); } }); diff --git a/src/test/run-pass/placement-new-arena.rs b/src/test/run-pass/placement-new-arena.rs index 166435cbc3d..ac5bc4f62d9 100644 --- a/src/test/run-pass/placement-new-arena.rs +++ b/src/test/run-pass/placement-new-arena.rs @@ -18,5 +18,5 @@ pub fn main() { let p = &mut arena; let x = p.alloc(|| 4u); io::print(fmt!("%u", *x)); - assert!(*x == 4u); + assert_eq!(*x, 4u); } diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs index 75f933ac769..44a56333a78 100644 --- a/src/test/run-pass/private-class-field.rs +++ b/src/test/run-pass/private-class-field.rs @@ -27,5 +27,5 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); - assert!((nyan.meow_count() == 52u)); + assert_eq!(nyan.meow_count(), 52u); } diff --git a/src/test/run-pass/propagate-expected-type-through-block.rs b/src/test/run-pass/propagate-expected-type-through-block.rs index aeeae0da9e3..f8f824cd596 100644 --- a/src/test/run-pass/propagate-expected-type-through-block.rs +++ b/src/test/run-pass/propagate-expected-type-through-block.rs @@ -8,5 +8,5 @@ pub fn main() { let y = y.clone(); |x| *x + *y }; - assert!(foo(@22) == 25); + assert_eq!(foo(@22), 25); } diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs index 04f86fdad01..fbd7d851fa3 100644 --- a/src/test/run-pass/rcvr-borrowed-to-region.rs +++ b/src/test/run-pass/rcvr-borrowed-to-region.rs @@ -26,26 +26,26 @@ pub fn main() { /* let x = @mut 6; let y = x.get(); - assert!(y == 6); + assert_eq!(y, 6); */ let x = @6; let y = x.get(); debug!("y=%d", y); - assert!(y == 6); + assert_eq!(y, 6); let mut x = ~6; let y = x.get(); debug!("y=%d", y); - assert!(y == 6); + assert_eq!(y, 6); let x = ~6; let y = x.get(); debug!("y=%d", y); - assert!(y == 6); + assert_eq!(y, 6); let x = &6; let y = x.get(); debug!("y=%d", y); - assert!(y == 6); + assert_eq!(y, 6); } diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs index 483a2ee25e5..188dca2f039 100644 --- a/src/test/run-pass/rcvr-borrowed-to-slice.rs +++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs @@ -27,15 +27,15 @@ pub fn main() { let x = ~[1, 2, 3]; let y = call_sum(x); debug!("y==%d", y); - assert!(y == 6); + assert_eq!(y, 6); let mut x = ~[1, 2, 3]; let y = x.sum(); debug!("y==%d", y); - assert!(y == 6); + assert_eq!(y, 6); let x = ~[1, 2, 3]; let y = x.sum(); debug!("y==%d", y); - assert!(y == 6); + assert_eq!(y, 6); } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index ff72eab7df1..202f6a4ac64 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -56,12 +56,12 @@ pub fn main() { debug!("y = %s", y); // per clang/gcc the alignment of `inner` is 4 on x86. - assert!(rusti::min_align_of::<Inner>() == m::align()); + assert_eq!(rusti::min_align_of::<Inner>(), m::align()); // per clang/gcc the size of `outer` should be 12 // because `inner`s alignment was 4. - assert!(sys::size_of::<Outer>() == m::size()); + assert_eq!(sys::size_of::<Outer>(), m::size()); - assert!(y == ~"{c8: 22, t: {c64: 44}}"); + assert_eq!(y, ~"{c8: 22, t: {c64: 44}}"); } } diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 0fad3e1f511..49092c26c95 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -78,12 +78,12 @@ pub fn main() { debug!("y = %s", y); // per clang/gcc the alignment of `Inner` is 4 on x86. - assert!(rusti::min_align_of::<Inner>() == m::m::align()); + assert_eq!(rusti::min_align_of::<Inner>(), m::m::align()); // per clang/gcc the size of `Outer` should be 12 // because `Inner`s alignment was 4. - assert!(sys::size_of::<Outer>() == m::m::size()); + assert_eq!(sys::size_of::<Outer>(), m::m::size()); - assert!(y == ~"{c8: 22, t: {c64: 44}}"); + assert_eq!(y, ~"{c8: 22, t: {c64: 44}}"); } } diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs index c352c06247b..4e029be8f76 100644 --- a/src/test/run-pass/rec-extend.rs +++ b/src/test/run-pass/rec-extend.rs @@ -18,10 +18,10 @@ pub fn main() { let origin: Point = Point {x: 0, y: 0}; let right: Point = Point {x: origin.x + 10,.. origin}; let up: Point = Point {y: origin.y + 10,.. origin}; - assert!((origin.x == 0)); - assert!((origin.y == 0)); - assert!((right.x == 10)); - assert!((right.y == 0)); - assert!((up.x == 0)); - assert!((up.y == 10)); + assert_eq!(origin.x, 0); + assert_eq!(origin.y, 0); + assert_eq!(right.x, 10); + assert_eq!(right.y, 0); + assert_eq!(up.x, 0); + assert_eq!(up.y, 10); } diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs index 46fb619fd80..fb5c5f3ce01 100644 --- a/src/test/run-pass/rec-tup.rs +++ b/src/test/run-pass/rec-tup.rs @@ -17,21 +17,21 @@ fn fst(r: rect) -> Point { let (fst, _) = r; return fst; } fn snd(r: rect) -> Point { let (_, snd) = r; return snd; } fn f(r: rect, x1: int, y1: int, x2: int, y2: int) { - assert!((fst(r).x == x1)); - assert!((fst(r).y == y1)); - assert!((snd(r).x == x2)); - assert!((snd(r).y == y2)); + assert_eq!(fst(r).x, x1); + assert_eq!(fst(r).y, y1); + assert_eq!(snd(r).x, x2); + assert_eq!(snd(r).y, y2); } pub fn main() { let r: rect = (Point {x: 10, y: 20}, Point {x: 11, y: 22}); - assert!((fst(r).x == 10)); - assert!((fst(r).y == 20)); - assert!((snd(r).x == 11)); - assert!((snd(r).y == 22)); + assert_eq!(fst(r).x, 10); + assert_eq!(fst(r).y, 20); + assert_eq!(snd(r).x, 11); + assert_eq!(snd(r).y, 22); let r2 = r; let x: int = fst(r2).x; - assert!((x == 10)); + assert_eq!(x, 10); f(r, 10, 20, 11, 22); f(r2, 10, 20, 11, 22); } diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs index 9d9322f7f3d..fa3fa01dd4d 100644 --- a/src/test/run-pass/rec.rs +++ b/src/test/run-pass/rec.rs @@ -15,21 +15,21 @@ struct Rect {x: int, y: int, w: int, h: int} fn f(r: Rect, x: int, y: int, w: int, h: int) { - assert!((r.x == x)); - assert!((r.y == y)); - assert!((r.w == w)); - assert!((r.h == h)); + assert_eq!(r.x, x); + assert_eq!(r.y, y); + assert_eq!(r.w, w); + assert_eq!(r.h, h); } pub fn main() { let r: Rect = Rect {x: 10, y: 20, w: 100, h: 200}; - assert!((r.x == 10)); - assert!((r.y == 20)); - assert!((r.w == 100)); - assert!((r.h == 200)); + assert_eq!(r.x, 10); + assert_eq!(r.y, 20); + assert_eq!(r.w, 100); + assert_eq!(r.h, 200); let r2: Rect = r; let x: int = r2.x; - assert!((x == 10)); + assert_eq!(x, 10); f(r, 10, 20, 100, 200); f(r2, 10, 20, 100, 200); } diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs index 0019f1dc23b..b13a955404c 100644 --- a/src/test/run-pass/record-pat.rs +++ b/src/test/run-pass/record-pat.rs @@ -20,6 +20,6 @@ fn m(in: t3) -> int { } pub fn main() { - assert!((m(c(T2 {x: a(10), y: 5}, 4u)) == 10)); - assert!((m(c(T2 {x: b(10u), y: 5}, 4u)) == 19)); + assert_eq!(m(c(T2 {x: a(10), y: 5}, 4u)), 10); + assert_eq!(m(c(T2 {x: b(10u), y: 5}, 4u)), 19); } diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs index dd33f7f1e30..ac2fc2eda23 100644 --- a/src/test/run-pass/region-dependent-addr-of.rs +++ b/src/test/run-pass/region-dependent-addr-of.rs @@ -90,29 +90,29 @@ pub fn main() { v6: Some(C { f: 31 })}}; let p = get_v1(&a); - assert!(*p == a.value.v1); + assert_eq!(*p, a.value.v1); let p = get_v2(&a, 1); - assert!(*p == a.value.v2[1]); + assert_eq!(*p, a.value.v2[1]); let p = get_v3(&a, 1); - assert!(*p == a.value.v3[1]); + assert_eq!(*p, a.value.v3[1]); let p = get_v4(&a, 1); - assert!(*p == a.value.v4.f); + assert_eq!(*p, a.value.v4.f); let p = get_v5(&a, 1); - assert!(*p == a.value.v5.f); + assert_eq!(*p, a.value.v5.f); let p = get_v6_a(&a, 1); - assert!(*p == a.value.v6.get().f); + assert_eq!(*p, a.value.v6.get().f); let p = get_v6_b(&a, 1); - assert!(*p == a.value.v6.get().f); + assert_eq!(*p, a.value.v6.get().f); let p = get_v6_c(&a, 1); - assert!(*p == a.value.v6.get().f); + assert_eq!(*p, a.value.v6.get().f); let p = get_v5_ref(&a, 1); - assert!(*p == a.value.v5.f); + assert_eq!(*p, a.value.v5.f); } diff --git a/src/test/run-pass/region-return-interior-of-option.rs b/src/test/run-pass/region-return-interior-of-option.rs index 8bb069990ee..aa4630717db 100644 --- a/src/test/run-pass/region-return-interior-of-option.rs +++ b/src/test/run-pass/region-return-interior-of-option.rs @@ -20,13 +20,13 @@ pub fn main() { { let y = get(&x); - assert!(*y == 23); + assert_eq!(*y, 23); } x = Some(24); { let y = get(&x); - assert!(*y == 24); + assert_eq!(*y, 24); } } diff --git a/src/test/run-pass/regions-appearance-constraint.rs b/src/test/run-pass/regions-appearance-constraint.rs index cfe721612e1..e587fa15f5c 100644 --- a/src/test/run-pass/regions-appearance-constraint.rs +++ b/src/test/run-pass/regions-appearance-constraint.rs @@ -25,7 +25,7 @@ fn testfn(cond: bool) { x = @5; y = @6; - assert!(*a == exp); + assert_eq!(*a, exp); } pub fn main() { diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs index f12c80c2e88..a8637fc8ab7 100644 --- a/src/test/run-pass/regions-borrow-at.rs +++ b/src/test/run-pass/regions-borrow-at.rs @@ -16,5 +16,5 @@ pub fn main() { let p = @22u; let r = foo(p); debug!("r=%u", r); - assert!(r == 22u); + assert_eq!(r, 22u); } diff --git a/src/test/run-pass/regions-borrow-estr-uniq.rs b/src/test/run-pass/regions-borrow-estr-uniq.rs index 18082e85751..b7d9b9f8fa9 100644 --- a/src/test/run-pass/regions-borrow-estr-uniq.rs +++ b/src/test/run-pass/regions-borrow-estr-uniq.rs @@ -15,9 +15,9 @@ fn foo(x: &str) -> u8 { pub fn main() { let p = ~"hello"; let r = foo(p); - assert!(r == 'h' as u8); + assert_eq!(r, 'h' as u8); let p = ~"hello"; let r = foo(p); - assert!(r == 'h' as u8); + assert_eq!(r, 'h' as u8); } diff --git a/src/test/run-pass/regions-borrow-evec-at.rs b/src/test/run-pass/regions-borrow-evec-at.rs index 3247f9df30d..a018dad64b3 100644 --- a/src/test/run-pass/regions-borrow-evec-at.rs +++ b/src/test/run-pass/regions-borrow-evec-at.rs @@ -17,5 +17,5 @@ fn foo(x: &[uint]) -> uint { pub fn main() { let p = @[22u]; let r = foo(p); - assert!(r == 22u); + assert_eq!(r, 22u); } diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs index 557b66735c0..129a299bcd4 100644 --- a/src/test/run-pass/regions-borrow-evec-fixed.rs +++ b/src/test/run-pass/regions-borrow-evec-fixed.rs @@ -16,5 +16,5 @@ fn foo(x: &[int]) -> int { pub fn main() { let p = [1,2,3,4,5]; - assert!(foo(p) == 1); + assert_eq!(foo(p), 1); } diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs index 80ea1bb452d..914c51eaa70 100644 --- a/src/test/run-pass/regions-borrow-evec-uniq.rs +++ b/src/test/run-pass/regions-borrow-evec-uniq.rs @@ -15,9 +15,9 @@ fn foo(x: &[int]) -> int { pub fn main() { let p = ~[1,2,3,4,5]; let r = foo(p); - assert!(r == 1); + assert_eq!(r, 1); let p = ~[5,4,3,2,1]; let r = foo(p); - assert!(r == 5); + assert_eq!(r, 5); } diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs index e59352667c2..10037d9dfe4 100644 --- a/src/test/run-pass/regions-borrow-uniq.rs +++ b/src/test/run-pass/regions-borrow-uniq.rs @@ -15,5 +15,5 @@ fn foo(x: &uint) -> uint { pub fn main() { let p = ~3u; let r = foo(p); - assert!(r == 3u); + assert_eq!(r, 3u); } diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs index 2e9ff88f96e..0b962731ecf 100644 --- a/src/test/run-pass/regions-copy-closure.rs +++ b/src/test/run-pass/regions-copy-closure.rs @@ -19,7 +19,7 @@ fn box_it<'r>(x: &'r fn()) -> closure_box<'r> { pub fn main() { let mut i = 3; let cl_box = box_it(|| i += 1); - assert!(i == 3); + assert_eq!(i, 3); (cl_box.cl)(); - assert!(i == 4); + assert_eq!(i, 4); } diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index 22b98726fb1..986071ec535 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -13,5 +13,5 @@ fn bar(x: &uint) -> uint { *x } pub fn main() { let p = @3u; - assert!(bar(foo(p)) == 3); + assert_eq!(bar(foo(p)), 3); } diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index 73535f52043..db4a51bbf22 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -14,7 +14,7 @@ pub fn main() { let x = @3; loop { let y = borrow(x); - assert!(*x == *y); + assert_eq!(*x, *y); break; } } diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index 61b9000aea3..6bd3fa5a73b 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -17,5 +17,5 @@ fn x_coord<'r>(p: &'r Point) -> &'r int { pub fn main() { let p = @Point {x: 3, y: 4}; let xc = x_coord(p); - assert!(*xc == 3); + assert_eq!(*xc, 3); } diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs index 2772660ff83..42be3b5b975 100644 --- a/src/test/run-pass/regions-infer-call-2.rs +++ b/src/test/run-pass/regions-infer-call-2.rs @@ -19,5 +19,5 @@ fn has_one<'a>(x: &'a int) -> int { } pub fn main() { - assert!(has_one(&2) == 22); + assert_eq!(has_one(&2), 22); } diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs index 39dec6c8133..fdb7485efc3 100644 --- a/src/test/run-pass/regions-infer-call.rs +++ b/src/test/run-pass/regions-infer-call.rs @@ -15,5 +15,5 @@ fn has_two<'a,'b>(x: &'a int, y: &'b int) -> int { } pub fn main() { - assert!(has_two(&20, &2) == 22); + assert_eq!(has_two(&20, &2), 22); } diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs index 46581e4f3d0..f07105cebed 100644 --- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs +++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs @@ -24,5 +24,5 @@ fn with(bi: &boxed_int) -> int { pub fn main() { let g = 21; let foo = boxed_int { f: &g }; - assert!(with(&foo) == 22); + assert_eq!(with(&foo), 22); } diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs index 8a8147e42d9..ea32cf866a0 100644 --- a/src/test/run-pass/regions-params.rs +++ b/src/test/run-pass/regions-params.rs @@ -23,5 +23,5 @@ fn parameterized(x: &uint) -> uint { pub fn main() { let x = 3u; - assert!(parameterized(&x) == 3u); + assert_eq!(parameterized(&x), 3u); } diff --git a/src/test/run-pass/regions-trait.rs b/src/test/run-pass/regions-trait.rs index a2ed9da67f2..b5b13efa634 100644 --- a/src/test/run-pass/regions-trait.rs +++ b/src/test/run-pass/regions-trait.rs @@ -30,5 +30,5 @@ pub fn main() { let ctxt = Ctxt { v: 22 }; let hc = HasCtxt { c: &ctxt }; - assert!(get_v(@hc as @get_ctxt) == 22); + assert_eq!(get_v(@hc as @get_ctxt), 22); } diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs index 68ec3fc4d42..edd692196ec 100644 --- a/src/test/run-pass/resource-assign-is-not-copy.rs +++ b/src/test/run-pass/resource-assign-is-not-copy.rs @@ -36,5 +36,5 @@ pub fn main() { let (c, _d) = b; debug!(c); } - assert!(*i == 1); + assert_eq!(*i, 1); } diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs index 1fcf677a0b3..b69248e3277 100644 --- a/src/test/run-pass/resource-destruct.rs +++ b/src/test/run-pass/resource-destruct.rs @@ -35,5 +35,5 @@ pub fn main() { let my_total = @@mut 10; { let pt = shrinky_pointer(my_total); assert!((pt.look_at() == 10)); } error!("my_total = %d", **my_total); - assert!((**my_total == 9)); + assert_eq!(**my_total, 9); } diff --git a/src/test/run-pass/resource-generic.rs b/src/test/run-pass/resource-generic.rs index 8a1835d6585..41eafb0293a 100644 --- a/src/test/run-pass/resource-generic.rs +++ b/src/test/run-pass/resource-generic.rs @@ -36,5 +36,5 @@ pub fn main() { fn dec_box(i: @mut int) { *i -= 1; } { let _i = finish(Arg{val: box, fin: dec_box}); } - assert!((*box == 9)); + assert_eq!(*box, 9); } diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs index 1792a89d64f..f1b1267faa7 100644 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ b/src/test/run-pass/ret-break-cont-in-block.rs @@ -56,17 +56,17 @@ pub fn main() { last = *e; if *e == 5 { break; } if *e % 2 == 1 { loop; } - assert!(*e % 2 == 0); + assert_eq!(*e % 2, 0); }; - assert!(last == 5); + assert_eq!(last, 5); - assert!(find_pos(1, ~[0, 1, 2, 3]) == Some(1u)); - assert!(find_pos(1, ~[0, 4, 2, 3]) == None); - assert!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == Some(3u)); + assert_eq!(find_pos(1, ~[0, 1, 2, 3]), Some(1u)); + assert_eq!(find_pos(1, ~[0, 4, 2, 3]), None); + assert_eq!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]), Some(3u)); bail_deep(~[~[false, false], ~[true, true], ~[false, true]]); bail_deep(~[~[true]]); bail_deep(~[~[false, false, false]]); - assert!(ret_deep() == ~"hi"); + assert_eq!(ret_deep(), ~"hi"); } diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs index e7dd240eb18..17c5994634f 100644 --- a/src/test/run-pass/rt-sched-1.rs +++ b/src/test/run-pass/rt-sched-1.rs @@ -44,7 +44,7 @@ pub fn main() { let child_sched_id = rustrt::rust_get_sched_id(); error!("child_sched_id %?", child_sched_id); assert!(child_sched_id != parent_sched_id); - assert!(child_sched_id == new_sched_id); + assert_eq!(child_sched_id, new_sched_id); ch.send(()); } }; diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs index 8ccc6bb5efb..f7808f7f8ac 100644 --- a/src/test/run-pass/sendfn-is-a-block.rs +++ b/src/test/run-pass/sendfn-is-a-block.rs @@ -16,5 +16,5 @@ fn test(f: &fn(uint) -> uint) -> uint { pub fn main() { let y = test(|x| 4u * x); - assert!(y == 88u); + assert_eq!(y, 88u); } diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index 2a69b2ca017..9816849d808 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -20,7 +20,7 @@ fn test05() { let three = ~3; let fn_to_send: ~fn(int) = |n| { error!(*three + n); // will copy x into the closure - assert!((*three == 3)); + assert_eq!(*three, 3); }; let fn_to_send = Cell(fn_to_send); task::spawn(|| { diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 5fb52973600..86907bdf2a3 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -21,6 +21,6 @@ pub fn main() { assert!((~[1, 2, 3] <= ~[1, 2, 3])); assert!((~[1, 2, 3] <= ~[1, 2, 3, 3])); assert!((~[1, 2, 3, 4] > ~[1, 2, 3])); - assert!((~[1, 2, 3] == ~[1, 2, 3])); + assert_eq!(~[1, 2, 3], ~[1, 2, 3]); assert!((~[1, 2, 3] != ~[1, 1, 3])); } diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs index d839825a773..7b676f05c90 100644 --- a/src/test/run-pass/shift.rs +++ b/src/test/run-pass/shift.rs @@ -18,64 +18,64 @@ pub fn main() { } fn test_misc() { - assert!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64 == 32); + assert_eq!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64, 32); } fn test_expr() { let v10 = 10 as uint; let v4 = 4 as u8; let v2 = 2 as u8; - assert!((v10 >> v2 == v2 as uint)); - assert!((v10 << v4 == 160 as uint)); + assert_eq!(v10 >> v2, v2 as uint); + assert_eq!(v10 << v4, 160 as uint); let v10 = 10 as u8; let v4 = 4 as uint; let v2 = 2 as uint; - assert!((v10 >> v2 == v2 as u8)); - assert!((v10 << v4 == 160 as u8)); + assert_eq!(v10 >> v2, v2 as u8); + assert_eq!(v10 << v4, 160 as u8); let v10 = 10 as int; let v4 = 4 as i8; let v2 = 2 as i8; - assert!((v10 >> v2 == v2 as int)); - assert!((v10 << v4 == 160 as int)); + assert_eq!(v10 >> v2, v2 as int); + assert_eq!(v10 << v4, 160 as int); let v10 = 10 as i8; let v4 = 4 as int; let v2 = 2 as int; - assert!((v10 >> v2 == v2 as i8)); - assert!((v10 << v4 == 160 as i8)); + assert_eq!(v10 >> v2, v2 as i8); + assert_eq!(v10 << v4, 160 as i8); let v10 = 10 as uint; let v4 = 4 as int; let v2 = 2 as int; - assert!((v10 >> v2 == v2 as uint)); - assert!((v10 << v4 == 160 as uint)); + assert_eq!(v10 >> v2, v2 as uint); + assert_eq!(v10 << v4, 160 as uint); } fn test_const() { static r1_1: uint = 10u >> 2u8; static r2_1: uint = 10u << 4u8; - assert!(r1_1 == 2 as uint); - assert!(r2_1 == 160 as uint); + assert_eq!(r1_1, 2 as uint); + assert_eq!(r2_1, 160 as uint); static r1_2: u8 = 10u8 >> 2u; static r2_2: u8 = 10u8 << 4u; - assert!(r1_2 == 2 as u8); - assert!(r2_2 == 160 as u8); + assert_eq!(r1_2, 2 as u8); + assert_eq!(r2_2, 160 as u8); static r1_3: int = 10 >> 2i8; static r2_3: int = 10 << 4i8; - assert!(r1_3 == 2 as int); - assert!(r2_3 == 160 as int); + assert_eq!(r1_3, 2 as int); + assert_eq!(r2_3, 160 as int); static r1_4: i8 = 10i8 >> 2; static r2_4: i8 = 10i8 << 4; - assert!(r1_4 == 2 as i8); - assert!(r2_4 == 160 as i8); + assert_eq!(r1_4, 2 as i8); + assert_eq!(r2_4, 160 as i8); static r1_5: uint = 10u >> 2i8; static r2_5: uint = 10u << 4i8; - assert!(r1_5 == 2 as uint); - assert!(r2_5 == 160 as uint); + assert_eq!(r1_5, 2 as uint); + assert_eq!(r2_5, 160 as uint); } diff --git a/src/test/run-pass/signed-shift-const-eval.rs b/src/test/run-pass/signed-shift-const-eval.rs index 0d3ecae01fb..92c83c22085 100644 --- a/src/test/run-pass/signed-shift-const-eval.rs +++ b/src/test/run-pass/signed-shift-const-eval.rs @@ -10,5 +10,5 @@ enum test { thing = -5 >> 1u } pub fn main() { - assert!((thing as int == -3)); + assert_eq!(thing as int, -3); } diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index 7bc55d647df..eb1c082f2f2 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -19,7 +19,7 @@ use core::comm::*; type ctx = Chan<int>; fn iotask(cx: &ctx, ip: ~str) { - assert!((ip == ~"localhost")); + assert_eq!(ip, ~"localhost"); } pub fn main() { diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs index 642babb5a1e..cb35f0828f2 100644 --- a/src/test/run-pass/spawn2.rs +++ b/src/test/run-pass/spawn2.rs @@ -22,13 +22,13 @@ fn child(args: (int, int, int, int, int, int, int, int, int)) { error!(i7); error!(i8); error!(i9); - assert!((i1 == 10)); - assert!((i2 == 20)); - assert!((i3 == 30)); - assert!((i4 == 40)); - assert!((i5 == 50)); - assert!((i6 == 60)); - assert!((i7 == 70)); - assert!((i8 == 80)); - assert!((i9 == 90)); + assert_eq!(i1, 10); + assert_eq!(i2, 20); + assert_eq!(i3, 30); + assert_eq!(i4, 40); + assert_eq!(i5, 50); + assert_eq!(i6, 60); + assert_eq!(i7, 70); + assert_eq!(i8, 80); + assert_eq!(i9, 90); } diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs index 3731f41f8f8..9008e9452db 100644 --- a/src/test/run-pass/stable-addr-of.rs +++ b/src/test/run-pass/stable-addr-of.rs @@ -12,5 +12,5 @@ pub fn main() { let foo = 1; - assert!(ptr::to_unsafe_ptr(&foo) == ptr::to_unsafe_ptr(&foo)); + assert_eq!(ptr::to_unsafe_ptr(&foo), ptr::to_unsafe_ptr(&foo)); } diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs index 0967eaf0615..2e081f364e7 100644 --- a/src/test/run-pass/stat.rs +++ b/src/test/run-pass/stat.rs @@ -30,7 +30,7 @@ pub fn main() { } assert!(path.exists()); - assert!(path.get_size() == Some(1000)); + assert_eq!(path.get_size(), Some(1000)); os::remove_dir(&dir); } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index 3f4a956b3a4..e96ab30f037 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -54,13 +54,13 @@ impl<T> vec_utils<T> for ~[T] { } pub fn main() { - assert!(10u.plus() == 30); - assert!((~"hi").plus() == 200); + assert_eq!(10u.plus(), 30); + assert_eq!((~"hi").plus(), 200); - assert!((~[1]).length_().str() == ~"1"); - assert!((~[3, 4]).map_(|a| *a + 4 )[0] == 7); - assert!((~[3, 4]).map_::<uint>(|a| *a as uint + 4u )[0] == 7u); + assert_eq!((~[1]).length_().str(), ~"1"); + assert_eq!((~[3, 4]).map_(|a| *a + 4 )[0], 7); + assert_eq!((~[3, 4]).map_::<uint>(|a| *a as uint + 4u )[0], 7u); let mut x = 0u; 10u.multi(|_n| x += 2u ); - assert!(x == 20u); + assert_eq!(x, 20u); } diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs index e8bb9c485ea..d1fcc4659b9 100644 --- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs +++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs @@ -31,5 +31,5 @@ impl Deserializer for FromThinAir { pub fn main() { let d = FromThinAir { dummy: () }; let i: int = Deserializable::deserialize(&d); - assert!(i == 22); + assert_eq!(i, 22); } diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index e06d09c564c..3ae8768e41e 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -76,15 +76,15 @@ fn seq_range<BT:buildable<int>>(lo: uint, hi: uint) -> BT { pub fn main() { let v: @[int] = seq_range(0, 10); - assert!(v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + assert_eq!(v, @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); let v: @[int] = map(&[1,2,3], |&x| 1+x); - assert!(v == @[2, 3, 4]); + assert_eq!(v, @[2, 3, 4]); let v: ~[int] = map(&[1,2,3], |&x| 1+x); - assert!(v == ~[2, 3, 4]); + assert_eq!(v, ~[2, 3, 4]); - assert!(bool_like::select(true, 9, 14) == 9); + assert_eq!(bool_like::select(true, 9, 14), 9); assert!(!andand(true, false)); - assert!(andand(7, 12) == 12); - assert!(andand(0, 12) == 0); + assert_eq!(andand(7, 12), 12); + assert_eq!(andand(0, 12), 0); } diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs index aa4f65669ad..c5d3b58276e 100644 --- a/src/test/run-pass/static-method-xcrate.rs +++ b/src/test/run-pass/static-method-xcrate.rs @@ -17,7 +17,7 @@ use readMaybeRenamed = static_methods_crate::read::readMaybe; pub fn main() { let result: int = read(~"5"); - assert!(result == 5); - assert!(readMaybeRenamed(~"false") == Some(false)); - assert!(readMaybeRenamed(~"foo") == None::<bool>); + assert_eq!(result, 5); + assert_eq!(readMaybeRenamed(~"false"), Some(false)); + assert_eq!(readMaybeRenamed(~"foo"), None::<bool>); } diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs index 42d0f02d642..8cd7b78312b 100644 --- a/src/test/run-pass/static-methods-in-traits.rs +++ b/src/test/run-pass/static-methods-in-traits.rs @@ -29,6 +29,6 @@ mod a { pub fn main() { let x: int = a::Foo::foo(); let y: uint = a::Foo::foo(); - assert!(x == 3); - assert!(y == 5); + assert_eq!(x, 3); + assert_eq!(y, 5); } diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index 4332a184eda..d8cc8716e11 100644 --- a/src/test/run-pass/str-append.rs +++ b/src/test/run-pass/str-append.rs @@ -17,7 +17,7 @@ fn test1() { let mut s: ~str = ~"hello"; s += ~"world"; debug!(s.clone()); - assert!((s[9] == 'd' as u8)); + assert_eq!(s[9], 'd' as u8); } fn test2() { @@ -28,8 +28,8 @@ fn test2() { let b: ~str = ~"ABC" + ff + ~"ABC"; debug!(a.clone()); debug!(b.clone()); - assert!((a == ~"abcABCabc")); - assert!((b == ~"ABCabcABC")); + assert_eq!(a, ~"abcABCabc"); + assert_eq!(b, ~"ABCabcABC"); } pub fn main() { test1(); test2(); } diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs index 0d43329baae..402d2fbbe3f 100644 --- a/src/test/run-pass/str-concat.rs +++ b/src/test/run-pass/str-concat.rs @@ -17,5 +17,5 @@ pub fn main() { let b: ~str = ~"world"; let s: ~str = a + b; debug!(s.clone()); - assert!((s[9] == 'd' as u8)); + assert_eq!(s[9], 'd' as u8); } diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs index fe9721a92e0..6938b52eee8 100644 --- a/src/test/run-pass/str-growth.rs +++ b/src/test/run-pass/str-growth.rs @@ -13,12 +13,12 @@ pub fn main() { let mut s = ~"a"; s += ~"b"; - assert!((s[0] == 'a' as u8)); - assert!((s[1] == 'b' as u8)); + assert_eq!(s[0], 'a' as u8); + assert_eq!(s[1], 'b' as u8); s += ~"c"; s += ~"d"; - assert!((s[0] == 'a' as u8)); - assert!((s[1] == 'b' as u8)); - assert!((s[2] == 'c' as u8)); - assert!((s[3] == 'd' as u8)); + assert_eq!(s[0], 'a' as u8); + assert_eq!(s[1], 'b' as u8); + assert_eq!(s[2], 'c' as u8); + assert_eq!(s[3], 'd' as u8); } diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index 24d2438e868..84f63c0137e 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -14,5 +14,5 @@ pub fn main() { let s = ~"hello"; let c: u8 = s[4]; debug!(c); - assert!((c == 0x6f as u8)); + assert_eq!(c, 0x6f as u8); } diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs index ae400acdb8f..90a7583dec9 100644 --- a/src/test/run-pass/str-multiline.rs +++ b/src/test/run-pass/str-multiline.rs @@ -21,6 +21,6 @@ is a test"; is \ another \ test"; - assert!((a == ~"this is a test")); - assert!((b == ~"this is another test")); + assert_eq!(a, ~"this is a test"); + assert_eq!(b, ~"this is another test"); } diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index c19a2afbd41..8c15a8c6892 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -17,7 +17,7 @@ pub fn main() { let mut expected_len = 1u; while i > 0 { error!(str::len(a)); - assert!((str::len(a) == expected_len)); + assert_eq!(str::len(a), expected_len); a = a + a; // FIXME(#3387)---can't write a += a i -= 1; expected_len *= 2u; diff --git a/src/test/run-pass/struct-deref.rs b/src/test/run-pass/struct-deref.rs index a52a2851689..b1de9880d4b 100644 --- a/src/test/run-pass/struct-deref.rs +++ b/src/test/run-pass/struct-deref.rs @@ -12,5 +12,5 @@ struct Foo(int); pub fn main() { let x: Foo = Foo(2); - assert!(*x == 2); + assert_eq!(*x, 2); } diff --git a/src/test/run-pass/struct-destructuring-cross-crate.rs b/src/test/run-pass/struct-destructuring-cross-crate.rs index 55d25845971..23c508791be 100644 --- a/src/test/run-pass/struct-destructuring-cross-crate.rs +++ b/src/test/run-pass/struct-destructuring-cross-crate.rs @@ -16,6 +16,6 @@ extern mod struct_destructuring_cross_crate; pub fn main() { let x = struct_destructuring_cross_crate::S { x: 1, y: 2 }; let struct_destructuring_cross_crate::S { x: a, y: b } = x; - assert!(a == 1); - assert!(b == 2); + assert_eq!(a, 1); + assert_eq!(b, 2); } diff --git a/src/test/run-pass/struct-field-assignability.rs b/src/test/run-pass/struct-field-assignability.rs index 0aca1a3d05f..335e13caa14 100644 --- a/src/test/run-pass/struct-field-assignability.rs +++ b/src/test/run-pass/struct-field-assignability.rs @@ -4,5 +4,5 @@ struct Foo<'self> { pub fn main() { let f = Foo { x: @3 }; - assert!(*f.x == 3); + assert_eq!(*f.x, 3); } diff --git a/src/test/run-pass/struct-like-variant-match.rs b/src/test/run-pass/struct-like-variant-match.rs index 64a75ddab22..ef558de433f 100644 --- a/src/test/run-pass/struct-like-variant-match.rs +++ b/src/test/run-pass/struct-like-variant-match.rs @@ -22,12 +22,12 @@ enum Foo { fn f(x: &Foo) { match *x { Baz { x: x, y: y } => { - assert!(x == 1.0); - assert!(y == 2.0); + assert_eq!(x, 1.0); + assert_eq!(y, 2.0); } Bar { y: y, x: x } => { - assert!(x == 1); - assert!(y == 2); + assert_eq!(x, 1); + assert_eq!(y, 2); } } } diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs index 7ac74fd5217..552683992b6 100644 --- a/src/test/run-pass/struct-return.rs +++ b/src/test/run-pass/struct-return.rs @@ -32,10 +32,10 @@ fn test1() { error!("b: %x", qq.b as uint); error!("c: %x", qq.c as uint); error!("d: %x", qq.d as uint); - assert!(qq.a == q.c + 1u64); - assert!(qq.b == q.d - 1u64); - assert!(qq.c == q.a + 1u64); - assert!(qq.d == q.b - 1u64); + assert_eq!(qq.a, q.c + 1u64); + assert_eq!(qq.b, q.d - 1u64); + assert_eq!(qq.c, q.a + 1u64); + assert_eq!(qq.d, q.b - 1u64); } } @@ -49,9 +49,9 @@ fn test2() { error!("a: %f", ff.a as float); error!("b: %u", ff.b as uint); error!("c: %f", ff.c as float); - assert!(ff.a == f.c + 1.0f64); - assert!(ff.b == 0xff_u8); - assert!(ff.c == f.a - 1.0f64); + assert_eq!(ff.a, f.c + 1.0f64); + assert_eq!(ff.b, 0xff_u8); + assert_eq!(ff.c, f.a - 1.0f64); } } diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index 4a8d155c739..d03bc594bb4 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -22,7 +22,7 @@ impl cmp::Eq for foo { pub fn main() { let a = (1, 2, 3); let b = (1, 2, 3); - assert!((a == b)); + assert_eq!(a, b); assert!((a != (1, 2, 4))); assert!((a < (1, 2, 4))); assert!((a <= (1, 2, 4))); @@ -31,6 +31,6 @@ pub fn main() { let x = large; let y = small; assert!((x != y)); - assert!((x == large)); + assert_eq!(x, large); assert!((x != small)); } diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index 63b377b26d8..738460def92 100644 --- a/src/test/run-pass/swap-2.rs +++ b/src/test/run-pass/swap-2.rs @@ -13,10 +13,10 @@ use core::util; pub fn main() { let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6]; vec::swap(a, 2, 4); - assert!((a[2] == 4)); - assert!((a[4] == 2)); + assert_eq!(a[2], 4); + assert_eq!(a[4], 2); let mut n = 42; util::swap(&mut n, &mut a[0]); - assert!((a[0] == 42)); - assert!((n == 0)); + assert_eq!(a[0], 42); + assert_eq!(n, 0); } diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index a61feadfc94..936c71dc0f3 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -13,7 +13,7 @@ extern mod std; fn test(actual: ~str, expected: ~str) { debug!(actual.clone()); debug!(expected.clone()); - assert!((actual == expected)); + assert_eq!(actual, expected); } pub fn main() { @@ -250,13 +250,13 @@ fn part6() { fn percent() { let s = fmt!("ab%%cd"); - assert!((s == ~"ab%cd")); + assert_eq!(s, ~"ab%cd"); } fn more_floats() { - assert!(~"3.1416" == fmt!("%.4f", 3.14159)); - assert!(~"3" == fmt!("%.0f", 3.14159)); - assert!(~"99" == fmt!("%.0f", 98.5)); - assert!(~"7.0000" == fmt!("%.4f", 6.999999999)); - assert!(~"3.141590000" == fmt!("%.9f", 3.14159)); + assert_eq!(~"3.1416", fmt!("%.4f", 3.14159)); + assert_eq!(~"3", fmt!("%.0f", 3.14159)); + assert_eq!(~"99", fmt!("%.0f", 98.5)); + assert_eq!(~"7.0000", fmt!("%.4f", 6.999999999)); + assert_eq!(~"3.141590000", fmt!("%.9f", 3.14159)); } diff --git a/src/test/run-pass/syntax-extension-minor.rs b/src/test/run-pass/syntax-extension-minor.rs index ac0b63e98ca..497a55b7c78 100644 --- a/src/test/run-pass/syntax-extension-minor.rs +++ b/src/test/run-pass/syntax-extension-minor.rs @@ -11,7 +11,7 @@ pub fn main() { let asdf_fdsa = ~"<.<"; - assert!((concat_idents!(asd, f_f, dsa) == ~"<.<")); + assert_eq!(concat_idents!(asd, f_f, dsa), ~"<.<"); assert!(stringify!(use_mention_distinction) == ~"use_mention_distinction"); diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 7b52f52137e..eceba6cf7b1 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -20,11 +20,11 @@ pub mod m1 { macro_rules! indirect_line( () => ( line!() ) ) pub fn main() { - assert!((line!() == 23)); + assert_eq!(line!(), 23); //assert!((col!() == 11)); - assert!((indirect_line!() == 25)); + assert_eq!(indirect_line!(), 25); assert!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs"))); - assert!((stringify!((2*3) + 5).to_owned() == ~"( 2 * 3 ) + 5")); + assert_eq!(stringify!((2*3) + 5).to_owned(), ~"( 2 * 3 ) + 5"); assert!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned() == ~"victory robot 6"); diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs index dd78dff0d6e..a562b79e4fd 100644 --- a/src/test/run-pass/tag-disr-val-shape.rs +++ b/src/test/run-pass/tag-disr-val-shape.rs @@ -19,7 +19,7 @@ enum color { pub fn main() { let act = fmt!("%?", red); io::println(act); - assert!(~"red" == act); - assert!(~"green" == fmt!("%?", green)); - assert!(~"white" == fmt!("%?", white)); + assert_eq!(~"red", act); + assert_eq!(~"green", fmt!("%?", green)); + assert_eq!(~"white", fmt!("%?", white)); } diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index d4eadd366de..d1e26a9c50c 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -39,8 +39,8 @@ pub fn main() { fn test_color(color: color, val: int, name: ~str) { //assert!(unsafe::transmute(color) == val); - assert!(color as int == val); - assert!(color as float == val as float); + assert_eq!(color as int, val); + assert_eq!(color as float, val as float); assert!(get_color_alt(color) == name); assert!(get_color_if(color) == name); } diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index 6fc29fa32db..bd5575f6154 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -35,5 +35,5 @@ fn test05() { error!(value); value = po.recv(); error!(value); - assert!((value == 30)); + assert_eq!(value, 30); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 237c721129f..c9e8ae3ab79 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -19,9 +19,9 @@ fn test_rec() { ch.send(r0); let mut r1: R; r1 = po.recv(); - assert!((r1.val0 == 0)); - assert!((r1.val1 == 1u8)); - assert!((r1.val2 == '2')); + assert_eq!(r1.val0, 0); + assert_eq!(r1.val1, 1u8); + assert_eq!(r1.val2, '2'); } fn test_vec() { @@ -29,9 +29,9 @@ fn test_vec() { let v0: ~[int] = ~[0, 1, 2]; ch.send(v0); let v1 = po.recv(); - assert!((v1[0] == 0)); - assert!((v1[1] == 1)); - assert!((v1[2] == 2)); + assert_eq!(v1[0], 0); + assert_eq!(v1[1], 1); + assert_eq!(v1[2], 2); } fn test_str() { @@ -39,10 +39,10 @@ fn test_str() { let s0 = ~"test"; ch.send(s0); let s1 = po.recv(); - assert!((s1[0] == 't' as u8)); - assert!((s1[1] == 'e' as u8)); - assert!((s1[2] == 's' as u8)); - assert!((s1[3] == 't' as u8)); + assert_eq!(s1[0], 't' as u8); + assert_eq!(s1[1], 'e' as u8); + assert_eq!(s1[2], 's' as u8); + assert_eq!(s1[3], 't' as u8); } enum t { @@ -85,11 +85,11 @@ fn test_tag() { ch.send(tag3(10, 11u8, 'A')); let mut t1: t; t1 = po.recv(); - assert!((t1 == tag1)); + assert_eq!(t1, tag1); t1 = po.recv(); - assert!((t1 == tag2(10))); + assert_eq!(t1, tag2(10)); t1 = po.recv(); - assert!((t1 == tag3(10, 11u8, 'A'))); + assert_eq!(t1, tag3(10, 11u8, 'A')); } fn test_chan() { @@ -102,7 +102,7 @@ fn test_chan() { ch1.send(10); let mut i: int; i = po0.recv(); - assert!((i == 10)); + assert_eq!(i, 10); } pub fn main() { diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index fd700475988..1a3dc678d42 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -67,5 +67,5 @@ fn test00() { error!(sum); // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * // number_of_messages)); - assert!((sum == 480)); + assert_eq!(sum, 480); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index 3b606642571..a1afefed2ee 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -46,5 +46,5 @@ fn test00() { r = p.recv(); sum += r; debug!(r); - assert!((sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8)); + assert_eq!(sum, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8); } diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs index 7522a092872..b6a517a6f81 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -21,5 +21,5 @@ fn test00() { while i < number_of_messages { c.send(i + 0); i += 1; } i = 0; while i < number_of_messages { sum += p.recv(); i += 1; } - assert!((sum == number_of_messages * (number_of_messages - 1) / 2)); + assert_eq!(sum, number_of_messages * (number_of_messages - 1) / 2); } diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs index 67ef5fb1905..38fdc2dc33e 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -41,7 +41,7 @@ fn test00() { sum += r; i += 1; } - assert!((sum == 1998000)); + assert_eq!(sum, 1998000); // assert (sum == 4 * ((number_of_messages * // (number_of_messages - 1)) / 2)); diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 12f9a113dfc..227f8aadecd 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -55,5 +55,5 @@ fn test00() { i += 1; } - assert!((sum == number_of_messages * 4 * (number_of_messages * 4 - 1) / 2)); + assert_eq!(sum, number_of_messages * 4 * (number_of_messages * 4 - 1) / 2); } diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index 798e9d37b55..f1337736965 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -42,5 +42,5 @@ fn test00() { result.unwrap().recv(); - assert!((sum == number_of_messages * (number_of_messages - 1) / 2)); + assert_eq!(sum, number_of_messages * (number_of_messages - 1) / 2); } diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index bae3cbbf587..ec534a66500 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -19,5 +19,5 @@ pub fn main() { let (po, ch) = comm::stream(); ch.send(()); let n: () = po.recv(); - assert!((n == ())); + assert_eq!(n, ()); } diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index ba10bfb6704..f67cc0d51af 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -22,5 +22,5 @@ pub fn main() { }); let x_in_child = p.recv(); - assert!(x_in_parent == x_in_child); + assert_eq!(x_in_parent, x_in_child); } diff --git a/src/test/run-pass/trait-bounds.rs b/src/test/run-pass/trait-bounds.rs index 3bdd9aa5088..7ec6ffbd464 100644 --- a/src/test/run-pass/trait-bounds.rs +++ b/src/test/run-pass/trait-bounds.rs @@ -31,5 +31,5 @@ pub fn main() { let factory = (); let connection = factory.create(); let result = connection.read(); - assert!(result == 43); + assert_eq!(result, 43); } diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs index 303eaa13af8..f21ea06697d 100644 --- a/src/test/run-pass/trait-cast.rs +++ b/src/test/run-pass/trait-cast.rs @@ -55,7 +55,7 @@ pub fn main() { right: Some(t1), val: 2 as to_str }); let expected = ~"[2, some([1, none, none]), some([1, none, none])]"; - assert!(t2.to_str() == expected); - assert!(foo(t2 as to_str) == expected); + assert_eq!(t2.to_str(), expected); + assert_eq!(foo(t2 as to_str), expected); t1.left = Some(t2); // create cycle } diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs index a489f2b405f..dc0af7f7d54 100644 --- a/src/test/run-pass/trait-default-method-bound-subst.rs +++ b/src/test/run-pass/trait-default-method-bound-subst.rs @@ -21,5 +21,5 @@ fn f<T, U, V: A<T>>(i: V, j: T, k: U) -> (T, U) { } pub fn main () { - assert!(f(0, 1, 2) == (1, 2)); + assert_eq!(f(0, 1, 2), (1, 2)); } diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs index 4203f73236e..93cc752527b 100644 --- a/src/test/run-pass/trait-default-method-bound-subst2.rs +++ b/src/test/run-pass/trait-default-method-bound-subst2.rs @@ -21,5 +21,5 @@ fn f<T, V: A<T>>(i: V, j: T) -> T { } pub fn main () { - assert!(f(0, 2) == 2); + assert_eq!(f(0, 2), 2); } diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs index 11830e7e7d2..cb86736b79d 100644 --- a/src/test/run-pass/trait-default-method-bound-subst3.rs +++ b/src/test/run-pass/trait-default-method-bound-subst3.rs @@ -21,6 +21,6 @@ fn f<T, V: A>(i: V, j: T, k: T) -> (T, T) { } pub fn main () { - assert!(f(0, 1, 2) == (1, 2)); - assert!(f(0, 1u8, 2u8) == (1u8, 2u8)); + assert_eq!(f(0, 1, 2), (1, 2)); + assert_eq!(f(0, 1u8, 2u8), (1u8, 2u8)); } diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs index 285d31152e2..d386fd44b6b 100644 --- a/src/test/run-pass/trait-default-method-bound-subst4.rs +++ b/src/test/run-pass/trait-default-method-bound-subst4.rs @@ -21,6 +21,6 @@ fn f<T, V: A<T>>(i: V, j: uint) -> uint { } pub fn main () { - assert!(f::<float, int>(0, 2u) == 2u); - assert!(f::<uint, int>(0, 2u) == 2u); + assert_eq!(f::<float, int>(0, 2u), 2u); + assert_eq!(f::<uint, int>(0, 2u), 2u); } diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs index 756af0d63fd..ce2df508f70 100644 --- a/src/test/run-pass/trait-default-method-bound.rs +++ b/src/test/run-pass/trait-default-method-bound.rs @@ -17,7 +17,7 @@ trait A { impl A for int { } fn f<T:A>(i: T) { - assert!(i.g() == 10); + assert_eq!(i.g(), 10); } pub fn main () { diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index eacd51266ad..fedf6e25ec3 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -42,8 +42,8 @@ fn bar<U:to_str,T:map<U>>(x: T) -> ~[~str] { } pub fn main() { - assert!(foo(~[1]) == ~[~"hi"]); - assert!(bar::<int, ~[int]>(~[4, 5]) == ~[~"4", ~"5"]); - assert!(bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]); - assert!(bar::<(), ~[()]>(~[()]) == ~[~"()"]); + assert_eq!(foo(~[1]), ~[~"hi"]); + assert_eq!(bar::<int, ~[int]>(~[4, 5]), ~[~"4", ~"5"]); + assert_eq!(bar::<~str, ~[~str]>(~[~"x", ~"y"]), ~[~"x", ~"y"]); + assert_eq!(bar::<(), ~[()]>(~[()]), ~[~"()"]); } diff --git a/src/test/run-pass/trait-inheritance-auto-xc-2.rs b/src/test/run-pass/trait-inheritance-auto-xc-2.rs index 996f55d4019..3f8d5368884 100644 --- a/src/test/run-pass/trait-inheritance-auto-xc-2.rs +++ b/src/test/run-pass/trait-inheritance-auto-xc-2.rs @@ -21,9 +21,9 @@ pub trait Quux: Foo + Bar + Baz { } impl<T:Foo + Bar + Baz> Quux for T { } fn f<T:Quux>(a: &T) { - assert!(a.f() == 10); - assert!(a.g() == 20); - assert!(a.h() == 30); + assert_eq!(a.f(), 10); + assert_eq!(a.g(), 20); + assert_eq!(a.h(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-auto-xc.rs b/src/test/run-pass/trait-inheritance-auto-xc.rs index 3af8d606bf4..2e8883f0267 100644 --- a/src/test/run-pass/trait-inheritance-auto-xc.rs +++ b/src/test/run-pass/trait-inheritance-auto-xc.rs @@ -22,9 +22,9 @@ impl Bar for A { fn g(&self) -> int { 20 } } impl Baz for A { fn h(&self) -> int { 30 } } fn f<T:Quux>(a: &T) { - assert!(a.f() == 10); - assert!(a.g() == 20); - assert!(a.h() == 30); + assert_eq!(a.f(), 10); + assert_eq!(a.g(), 20); + assert_eq!(a.h(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-auto.rs b/src/test/run-pass/trait-inheritance-auto.rs index fb97dd5e774..c5a7720e3c3 100644 --- a/src/test/run-pass/trait-inheritance-auto.rs +++ b/src/test/run-pass/trait-inheritance-auto.rs @@ -25,9 +25,9 @@ impl Bar for A { fn g(&self) -> int { 20 } } impl Baz for A { fn h(&self) -> int { 30 } } fn f<T:Quux>(a: &T) { - assert!(a.f() == 10); - assert!(a.g() == 20); - assert!(a.h() == 30); + assert_eq!(a.f(), 10); + assert_eq!(a.g(), 20); + assert_eq!(a.h(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs index 805c9655d81..46258902f9c 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs @@ -23,5 +23,5 @@ fn gg<T:Bar>(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - assert!(gg(a) == 10); + assert_eq!(gg(a), 10); } diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs index 0b35fd90bbd..7b79ad42ed2 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs @@ -26,5 +26,5 @@ fn gg<T:Baz>(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - assert!(gg(a) == 10); + assert_eq!(gg(a), 10); } diff --git a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs index df9cc4fb8b6..68a31ba9dbe 100644 --- a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs +++ b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs @@ -35,6 +35,6 @@ pub fn main() { let a = &A { x: 3 }; let afoo = a as &Foo; let abar = a as &Bar; - assert!(afoo.f() == 10); - assert!(abar.g() == 20); + assert_eq!(afoo.f(), 10); + assert_eq!(abar.g(), 20); } diff --git a/src/test/run-pass/trait-inheritance-cast.rs b/src/test/run-pass/trait-inheritance-cast.rs index 75c121e10b0..1f69ba29b09 100644 --- a/src/test/run-pass/trait-inheritance-cast.rs +++ b/src/test/run-pass/trait-inheritance-cast.rs @@ -36,7 +36,7 @@ pub fn main() { let a = &A { x: 3 }; let afoo = a as &Foo; let abar = a as &Bar; - assert!(afoo.f() == 10); - assert!(abar.g() == 20); - assert!(abar.f() == 10); + assert_eq!(afoo.f(), 10); + assert_eq!(abar.g(), 20); + assert_eq!(abar.f(), 10); } diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs index 976c9a02439..eddec87472c 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs @@ -25,5 +25,5 @@ impl Bar for aux::A { pub fn main() { let a = &aux::A { x: 3 }; - assert!(a.g() == 10); + assert_eq!(a.g(), 10); } diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call.rs b/src/test/run-pass/trait-inheritance-cross-trait-call.rs index 20dac16b492..7b047b5cc80 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call.rs @@ -22,5 +22,5 @@ impl Bar for A { pub fn main() { let a = &A { x: 3 }; - assert!(a.g() == 10); + assert_eq!(a.g(), 10); } diff --git a/src/test/run-pass/trait-inheritance-diamond.rs b/src/test/run-pass/trait-inheritance-diamond.rs index abfbec6d358..253c10ac6f1 100644 --- a/src/test/run-pass/trait-inheritance-diamond.rs +++ b/src/test/run-pass/trait-inheritance-diamond.rs @@ -23,10 +23,10 @@ impl C for S { fn c(&self) -> int { 30 } } impl D for S { fn d(&self) -> int { 40 } } fn f<T:D>(x: &T) { - assert!(x.a() == 10); - assert!(x.b() == 20); - assert!(x.c() == 30); - assert!(x.d() == 40); + assert_eq!(x.a(), 10); + assert_eq!(x.b(), 20); + assert_eq!(x.c(), 30); + assert_eq!(x.d(), 40); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs index 5bd8f7f25ea..6cd3d624736 100644 --- a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs +++ b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs @@ -20,9 +20,9 @@ impl C for S { fn c(&self) -> int { 30 } } // Both B and C inherit from A fn f<T:B + C>(x: &T) { - assert!(x.a() == 10); - assert!(x.b() == 20); - assert!(x.c() == 30); + assert_eq!(x.a(), 10); + assert_eq!(x.b(), 20); + assert_eq!(x.c(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-multiple-params.rs b/src/test/run-pass/trait-inheritance-multiple-params.rs index e01860ba503..b5524c6dda6 100644 --- a/src/test/run-pass/trait-inheritance-multiple-params.rs +++ b/src/test/run-pass/trait-inheritance-multiple-params.rs @@ -20,11 +20,11 @@ impl C for S { fn c(&self) -> int { 30 } } // Multiple type params, multiple levels of inheritance fn f<X:A,Y:B,Z:C>(x: &X, y: &Y, z: &Z) { - assert!(x.a() == 10); - assert!(y.a() == 10); - assert!(y.b() == 20); - assert!(z.a() == 10); - assert!(z.c() == 30); + assert_eq!(x.a(), 10); + assert_eq!(y.a(), 10); + assert_eq!(y.b(), 20); + assert_eq!(z.a(), 10); + assert_eq!(z.c(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs index 3a1c3716df4..2e9b60303c6 100644 --- a/src/test/run-pass/trait-inheritance-overloading-simple.rs +++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs @@ -30,5 +30,5 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y, z) = (mi(3), mi(5), mi(3)); assert!(x != y); - assert!(x == z); + assert_eq!(x, z); } diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs index d89852e2b05..21f840ca8d3 100644 --- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs +++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs @@ -23,7 +23,7 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let (a, b, c) = f(x, y); - assert!(a == mi(8)); - assert!(b == mi(-2)); - assert!(c == mi(15)); + assert_eq!(a, mi(8)); + assert_eq!(b, mi(-2)); + assert_eq!(c, mi(15)); } diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index e58ec24f1b7..82c9091147d 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -42,7 +42,7 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let (a, b, c) = f(x, y); - assert!(a == mi(8)); - assert!(b == mi(-2)); - assert!(c == mi(15)); + assert_eq!(a, mi(8)); + assert_eq!(b, mi(-2)); + assert_eq!(c, mi(15)); } diff --git a/src/test/run-pass/trait-inheritance-simple.rs b/src/test/run-pass/trait-inheritance-simple.rs index 2da1f02779e..113efa663af 100644 --- a/src/test/run-pass/trait-inheritance-simple.rs +++ b/src/test/run-pass/trait-inheritance-simple.rs @@ -26,6 +26,6 @@ fn gg<T:Bar>(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - assert!(ff(a) == 10); - assert!(gg(a) == 20); + assert_eq!(ff(a), 10); + assert_eq!(gg(a), 20); } diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs index 3b87387d4d6..08543b236f3 100644 --- a/src/test/run-pass/trait-inheritance-static.rs +++ b/src/test/run-pass/trait-inheritance-static.rs @@ -30,5 +30,5 @@ fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) } pub fn main() { let v: S = greater_than_one(); - assert!(v.v == 1); + assert_eq!(v.v, 1); } diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs index 2718949db07..95131176ce7 100644 --- a/src/test/run-pass/trait-inheritance-static2.rs +++ b/src/test/run-pass/trait-inheritance-static2.rs @@ -34,5 +34,5 @@ fn greater_than_one<T:NumExt>() -> T { MyNum::from_int(1) } pub fn main() { let v: S = greater_than_one(); - assert!(v.v == 1); + assert_eq!(v.v, 1); } diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs index 5d1741a45f3..214505172a5 100644 --- a/src/test/run-pass/trait-inheritance-subst2.rs +++ b/src/test/run-pass/trait-inheritance-subst2.rs @@ -41,5 +41,5 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let z = f(x, y); - assert!(z.val == 13); + assert_eq!(z.val, 13); } diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs index 81f119612d9..3cdedd884a4 100644 --- a/src/test/run-pass/trait-inheritance-visibility.rs +++ b/src/test/run-pass/trait-inheritance-visibility.rs @@ -20,7 +20,7 @@ impl<T:traits::Foo> Quux for T { } // Foo is not in scope but because Quux is we can still access // Foo's methods on a Quux bound typaram fn f<T:Quux>(x: &T) { - assert!(x.f() == 10); + assert_eq!(x.f(), 10); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs index adb7ab018d6..6046da41217 100644 --- a/src/test/run-pass/trait-inheritance2.rs +++ b/src/test/run-pass/trait-inheritance2.rs @@ -22,9 +22,9 @@ impl Baz for A { fn h(&self) -> int { 30 } } impl Quux for A; fn f<T:Quux + Foo + Bar + Baz>(a: &T) { - assert!(a.f() == 10); - assert!(a.g() == 20); - assert!(a.h() == 30); + assert_eq!(a.f(), 10); + assert_eq!(a.g(), 20); + assert_eq!(a.h(), 30); } pub fn main() { diff --git a/src/test/run-pass/trait-region-pointer-simple.rs b/src/test/run-pass/trait-region-pointer-simple.rs index a2742828a1b..7162420dbc3 100644 --- a/src/test/run-pass/trait-region-pointer-simple.rs +++ b/src/test/run-pass/trait-region-pointer-simple.rs @@ -26,5 +26,5 @@ impl Foo for A { pub fn main() { let a = A { x: 3 }; let b = (&a) as &Foo; - assert!(b.f() == 3); + assert_eq!(b.f(), 3); } diff --git a/src/test/run-pass/trait_with_static_methods_cross_crate.rs b/src/test/run-pass/trait_with_static_methods_cross_crate.rs index 1af86294680..20dcbf3267b 100644 --- a/src/test/run-pass/trait_with_static_methods_cross_crate.rs +++ b/src/test/run-pass/trait_with_static_methods_cross_crate.rs @@ -15,5 +15,5 @@ extern mod mod_trait_with_static_methods_lib; use mod_trait_with_static_methods_lib::Foo; pub fn main() { - assert!(42 == Foo::foo()); + assert_eq!(42, Foo::foo()); } diff --git a/src/test/run-pass/traits-default-method-macro.rs b/src/test/run-pass/traits-default-method-macro.rs index 7f106f71f8e..b25f345b9de 100644 --- a/src/test/run-pass/traits-default-method-macro.rs +++ b/src/test/run-pass/traits-default-method-macro.rs @@ -25,5 +25,5 @@ impl Foo for Baz { pub fn main() { let q = Quux; - assert!(q.bar() == ~"test"); + assert_eq!(q.bar(), ~"test"); } diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs index c1a34a326a6..795ed1d0f8a 100644 --- a/src/test/run-pass/tup.rs +++ b/src/test/run-pass/tup.rs @@ -13,15 +13,15 @@ type point = (int, int); fn f(p: point, x: int, y: int) { let (a, b) = p; - assert!((a == x)); - assert!((b == y)); + assert_eq!(a, x); + assert_eq!(b, y); } pub fn main() { let p: point = (10, 20); let (a, b) = p; - assert!((a == 10)); - assert!((b == 20)); + assert_eq!(a, 10); + assert_eq!(b, 20); let p2: point = p; f(p, 10, 20); f(p2, 10, 20); diff --git a/src/test/run-pass/tuple-struct-destructuring.rs b/src/test/run-pass/tuple-struct-destructuring.rs index 1cb944da040..c7dc132f3b7 100644 --- a/src/test/run-pass/tuple-struct-destructuring.rs +++ b/src/test/run-pass/tuple-struct-destructuring.rs @@ -14,6 +14,6 @@ pub fn main() { let x = Foo(1, 2); let Foo(y, z) = x; io::println(fmt!("%d %d", y, z)); - assert!(y == 1); - assert!(z == 2); + assert_eq!(y, 1); + assert_eq!(z, 2); } diff --git a/src/test/run-pass/tuple-struct-matching.rs b/src/test/run-pass/tuple-struct-matching.rs index e3cbd1201c1..037f847629c 100644 --- a/src/test/run-pass/tuple-struct-matching.rs +++ b/src/test/run-pass/tuple-struct-matching.rs @@ -14,8 +14,8 @@ pub fn main() { let x = Foo(1, 2); match x { Foo(a, b) => { - assert!(a == 1); - assert!(b == 2); + assert_eq!(a, 1); + assert_eq!(b, 2); io::println(fmt!("%d %d", a, b)); } } diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs index 134f1e4098f..adb3ae9557b 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -20,19 +20,19 @@ struct x {a: int, b: (), c: ()} struct y {x: int} pub fn main() { - assert!((size_of::<u8>() == 1 as uint)); - assert!((size_of::<u32>() == 4 as uint)); - assert!((size_of::<char>() == 4 as uint)); - assert!((size_of::<i8>() == 1 as uint)); - assert!((size_of::<i32>() == 4 as uint)); - assert!((size_of::<t>() == 2 as uint)); - assert!((size_of::<u>() == 3 as uint)); + assert_eq!(size_of::<u8>(), 1 as uint); + assert_eq!(size_of::<u32>(), 4 as uint); + assert_eq!(size_of::<char>(), 4 as uint); + assert_eq!(size_of::<i8>(), 1 as uint); + assert_eq!(size_of::<i32>(), 4 as uint); + assert_eq!(size_of::<t>(), 2 as uint); + assert_eq!(size_of::<u>(), 3 as uint); // Alignment causes padding before the char and the u32. assert!(size_of::<v>() == 16 as uint); - assert!((size_of::<int>() == size_of::<uint>())); - assert!((size_of::<w>() == size_of::<int>())); - assert!((size_of::<x>() == size_of::<int>())); - assert!((size_of::<int>() == size_of::<y>())); + assert_eq!(size_of::<int>(), size_of::<uint>()); + assert_eq!(size_of::<w>(), size_of::<int>()); + assert_eq!(size_of::<x>(), size_of::<int>()); + assert_eq!(size_of::<int>(), size_of::<y>()); } diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs index 2b68e89ed26..f40d06f6c92 100644 --- a/src/test/run-pass/u32-decr.rs +++ b/src/test/run-pass/u32-decr.rs @@ -15,5 +15,5 @@ pub fn main() { let mut word: u32 = 200000u32; word = word - 1u32; - assert!((word == 199999u32)); + assert_eq!(word, 199999u32); } diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs index e864cd0ad4a..18543599fd0 100644 --- a/src/test/run-pass/u8-incr-decr.rs +++ b/src/test/run-pass/u8-incr-decr.rs @@ -24,5 +24,5 @@ pub fn main() { y = y - 9u8; // 0x9 - assert!((x == y)); + assert_eq!(x, y); } diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs index c9d31fb72b7..1a4013645e8 100644 --- a/src/test/run-pass/u8-incr.rs +++ b/src/test/run-pass/u8-incr.rs @@ -17,7 +17,7 @@ pub fn main() { let y: u8 = 12u8; x = x + 1u8; x = x - 1u8; - assert!((x == y)); + assert_eq!(x, y); // x = 14u8; // x = x + 1u8; diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs index d05cb76e113..e59fe469dec 100644 --- a/src/test/run-pass/unique-assign-copy.rs +++ b/src/test/run-pass/unique-assign-copy.rs @@ -15,6 +15,6 @@ pub fn main() { j = i.clone(); *i = 2; *j = 3; - assert!(*i == 2); - assert!(*j == 3); + assert_eq!(*i, 2); + assert_eq!(*j, 3); } diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs index 0faa6b1b555..2205eaeb97c 100644 --- a/src/test/run-pass/unique-assign-drop.rs +++ b/src/test/run-pass/unique-assign-drop.rs @@ -13,5 +13,5 @@ pub fn main() { let mut j = ~2; // Should drop the previous value of j j = i; - assert!(*j == 1); + assert_eq!(*j, 1); } diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 75753b31ed7..67ffc797ee4 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -15,7 +15,7 @@ fn f<T:Copy>(t: T) -> T { pub fn main() { let t = f(~100); - assert!(t == ~100); + assert_eq!(t, ~100); let t = f(~@~[100]); - assert!(t == ~@~[100]); + assert_eq!(t, ~@~[100]); } diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs index 6fc16cae76f..43df53c78a8 100644 --- a/src/test/run-pass/unique-assign.rs +++ b/src/test/run-pass/unique-assign.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i; i = ~1; - assert!(*i == 1); + assert_eq!(*i, 1); } diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs index 07105a53caf..6836ba4e79b 100644 --- a/src/test/run-pass/unique-autoderef-field.rs +++ b/src/test/run-pass/unique-autoderef-field.rs @@ -14,5 +14,5 @@ pub fn main() { let i = ~J { j: 100 }; - assert!(i.j == 100); + assert_eq!(i.j, 100); } diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index 324efe5abe5..46f9ca794a9 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~~[100]; - assert!(i[0] == 100); + assert_eq!(i[0], 100); } diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs index c8ed7b10a1f..ba5627fee52 100644 --- a/src/test/run-pass/unique-containing-tag.rs +++ b/src/test/run-pass/unique-containing-tag.rs @@ -15,14 +15,14 @@ pub fn main() { /*alt *x { t1(a) { - assert!(a == 10); + assert_eq!(a, 10); } _ { fail!(); } }*/ /*alt x { ~t1(a) { - assert!(a == 10); + assert_eq!(a, 10); } _ { fail!(); } }*/ diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs index b483881f1a6..38a608c191b 100644 --- a/src/test/run-pass/unique-copy-box.rs +++ b/src/test/run-pass/unique-copy-box.rs @@ -16,6 +16,6 @@ pub fn main() { let j = copy i; let rc2 = sys::refcount(*i); error!("rc1: %u rc2: %u", rc1, rc2); - assert!(rc1 + 1u == rc2); + assert_eq!(rc1 + 1u, rc2); } } diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs index 670bc35d857..13594d86f67 100644 --- a/src/test/run-pass/unique-decl-init-copy.rs +++ b/src/test/run-pass/unique-decl-init-copy.rs @@ -14,6 +14,6 @@ pub fn main() { let mut j = i.clone(); *i = 2; *j = 3; - assert!(*i == 2); - assert!(*j == 3); + assert_eq!(*i, 2); + assert_eq!(*j, 3); } diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs index f5f1829cae0..c507d19fac1 100644 --- a/src/test/run-pass/unique-decl-init.rs +++ b/src/test/run-pass/unique-decl-init.rs @@ -11,5 +11,5 @@ pub fn main() { let i = ~1; let j = i; - assert!(*j == 1); + assert_eq!(*j, 1); } diff --git a/src/test/run-pass/unique-decl-move-temp.rs b/src/test/run-pass/unique-decl-move-temp.rs index b9f122acbcd..6cf781d735c 100644 --- a/src/test/run-pass/unique-decl-move-temp.rs +++ b/src/test/run-pass/unique-decl-move-temp.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~100; - assert!(*i == 100); + assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs index 81c59bae357..335275ff7c1 100644 --- a/src/test/run-pass/unique-decl-move.rs +++ b/src/test/run-pass/unique-decl-move.rs @@ -11,5 +11,5 @@ pub fn main() { let i = ~100; let j = i; - assert!(*j == 100); + assert_eq!(*j, 100); } diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs index b9f122acbcd..6cf781d735c 100644 --- a/src/test/run-pass/unique-deref.rs +++ b/src/test/run-pass/unique-deref.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~100; - assert!(*i == 100); + assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs index 64e01f86474..6c35cb4dba7 100644 --- a/src/test/run-pass/unique-destructure.rs +++ b/src/test/run-pass/unique-destructure.rs @@ -12,5 +12,5 @@ struct Foo { a: int, b: int } pub fn main() { let ~Foo{a, b} = ~Foo{a: 100, b: 200}; - assert!(a + b == 300); + assert_eq!(a + b, 300); } diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs index 4a6386244f1..503bbae8c55 100644 --- a/src/test/run-pass/unique-fn-arg-move.rs +++ b/src/test/run-pass/unique-fn-arg-move.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(i: ~int) { - assert!(*i == 100); + assert_eq!(*i, 100); } pub fn main() { diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs index 56ec9663ec6..c2d78c33039 100644 --- a/src/test/run-pass/unique-fn-arg-mut.rs +++ b/src/test/run-pass/unique-fn-arg-mut.rs @@ -15,5 +15,5 @@ fn f(i: &mut ~int) { pub fn main() { let mut i = ~100; f(&mut i); - assert!(*i == 200); + assert_eq!(*i, 200); } diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs index 931c5acbe1d..230131bae62 100644 --- a/src/test/run-pass/unique-fn-arg.rs +++ b/src/test/run-pass/unique-fn-arg.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(i: ~int) { - assert!(*i == 100); + assert_eq!(*i, 100); } pub fn main() { diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs index 0ef9d12f75b..dd39e136fc9 100644 --- a/src/test/run-pass/unique-fn-ret.rs +++ b/src/test/run-pass/unique-fn-ret.rs @@ -13,5 +13,5 @@ fn f() -> ~int { } pub fn main() { - assert!(f() == ~100); + assert_eq!(f(), ~100); } diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs index e7226279579..3a27d7844bc 100644 --- a/src/test/run-pass/unique-in-vec-copy.rs +++ b/src/test/run-pass/unique-in-vec-copy.rs @@ -12,12 +12,12 @@ pub fn main() { let mut a = ~[~10]; let b = a.clone(); - assert!(*a[0] == 10); - assert!(*b[0] == 10); + assert_eq!(*a[0], 10); + assert_eq!(*b[0], 10); // This should only modify the value in a, not b *a[0] = 20; - assert!(*a[0] == 20); - assert!(*b[0] == 10); + assert_eq!(*a[0], 20); + assert_eq!(*b[0], 10); } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index da48f2ff51b..dbbd238cbac 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -13,7 +13,7 @@ use core::cmp::Eq; fn sendable() { fn f<T:Owned + Eq>(i: T, j: T) { - assert!(i == j); + assert_eq!(i, j); } fn g<T:Owned + Eq>(i: T, j: T) { @@ -31,7 +31,7 @@ fn sendable() { fn copyable() { fn f<T:Copy + Eq>(i: T, j: T) { - assert!(i == j); + assert_eq!(i, j); } fn g<T:Copy + Eq>(i: T, j: T) { @@ -49,7 +49,7 @@ fn copyable() { fn noncopyable() { fn f<T:Eq>(i: T, j: T) { - assert!(i == j); + assert_eq!(i, j); } fn g<T:Eq>(i: T, j: T) { diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs index 5ddc85ea5fa..29267956a59 100644 --- a/src/test/run-pass/unique-move-drop.rs +++ b/src/test/run-pass/unique-move-drop.rs @@ -12,5 +12,5 @@ pub fn main() { let i = ~100; let j = ~200; let j = i; - assert!(*j == 100); + assert_eq!(*j, 100); } diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs index 343b0d43142..7c7ca1379ea 100644 --- a/src/test/run-pass/unique-move-temp.rs +++ b/src/test/run-pass/unique-move-temp.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i; i = ~100; - assert!(*i == 100); + assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs index 3331350facd..dbdfc5cb5bb 100644 --- a/src/test/run-pass/unique-move.rs +++ b/src/test/run-pass/unique-move.rs @@ -12,5 +12,5 @@ pub fn main() { let i = ~100; let mut j; j = i; - assert!(*j == 100); + assert_eq!(*j, 100); } diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs index e4a1b4a548b..4f353c56671 100644 --- a/src/test/run-pass/unique-mutable.rs +++ b/src/test/run-pass/unique-mutable.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i = ~0; *i = 1; - assert!(*i == 1); + assert_eq!(*i, 1); } diff --git a/src/test/run-pass/unique-object.rs b/src/test/run-pass/unique-object.rs index 5e0954969ef..e645f13cd4c 100644 --- a/src/test/run-pass/unique-object.rs +++ b/src/test/run-pass/unique-object.rs @@ -25,5 +25,5 @@ impl Foo for Bar { pub fn main() { let x = ~Bar { x: 10 }; let y = x as ~Foo; - assert!(y.f() == 10); + assert_eq!(y.f(), 10); } diff --git a/src/test/run-pass/unique-pinned-nocopy-2.rs b/src/test/run-pass/unique-pinned-nocopy-2.rs index d3cdc9a8788..197f26f897d 100644 --- a/src/test/run-pass/unique-pinned-nocopy-2.rs +++ b/src/test/run-pass/unique-pinned-nocopy-2.rs @@ -32,5 +32,5 @@ pub fn main() { { let j = ~r(i); } - assert!(*i == 1); + assert_eq!(*i, 1); } diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs index 0564c2ebddd..f740dd2a22c 100644 --- a/src/test/run-pass/unique-rec.rs +++ b/src/test/run-pass/unique-rec.rs @@ -13,5 +13,5 @@ struct X { x: int } pub fn main() { let x = ~X {x: 1}; let bar = x; - assert!(bar.x == 1); + assert_eq!(bar.x, 1); } diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index df1c8708acd..9b522490f98 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -31,5 +31,5 @@ pub fn main() { actual += *j; } - assert!(expected == actual); + assert_eq!(expected, actual); } diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index c9d3a951920..a611992d7ee 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -14,5 +14,5 @@ pub fn main() { let (p, c) = stream(); c.send(~100); let v = p.recv(); - assert!(v == ~100); + assert_eq!(v, ~100); } diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs index bf58e2c7cb5..fa3aeb5d421 100644 --- a/src/test/run-pass/unique-swap.rs +++ b/src/test/run-pass/unique-swap.rs @@ -14,6 +14,6 @@ pub fn main() { let mut i = ~100; let mut j = ~200; util::swap(&mut i, &mut j); - assert!(i == ~200); - assert!(j == ~100); + assert_eq!(i, ~200); + assert_eq!(j, ~100); } diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs index f19558fbb1d..3385c6f6fef 100644 --- a/src/test/run-pass/unsafe-pointer-assignability.rs +++ b/src/test/run-pass/unsafe-pointer-assignability.rs @@ -10,7 +10,7 @@ fn f(x: *int) { unsafe { - assert!(*x == 3); + assert_eq!(*x, 3); } } diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index 51fc42491e0..aab51207a9f 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -15,14 +15,14 @@ pub fn main() { let y_diaeresis: char = 'ÿ'; // 0xff let pi: char = 'Π'; // 0x3a0 - assert!((yen as int == 0xa5)); - assert!((c_cedilla as int == 0xe7)); - assert!((thorn as int == 0xfe)); - assert!((y_diaeresis as int == 0xff)); - assert!((pi as int == 0x3a0)); + assert_eq!(yen as int, 0xa5); + assert_eq!(c_cedilla as int, 0xe7); + assert_eq!(thorn as int, 0xfe); + assert_eq!(y_diaeresis as int, 0xff); + assert_eq!(pi as int, 0x3a0); - assert!((pi as int == '\u03a0' as int)); - assert!(('\x0a' as int == '\n' as int)); + assert_eq!(pi as int, '\u03a0' as int); + assert_eq!('\x0a' as int, '\n' as int); let bhutan: ~str = ~"འབྲུག་ཡུལ།"; let japan: ~str = ~"日本"; @@ -37,7 +37,7 @@ pub fn main() { let austria_e: ~str = ~"\u00d6sterreich"; let oo: char = 'Ö'; - assert!((oo as int == 0xd6)); + assert_eq!(oo as int, 0xd6); fn check_str_eq(a: ~str, b: ~str) { let mut i: int = 0; @@ -46,7 +46,7 @@ pub fn main() { debug!(ab); let bb: u8 = b[i]; debug!(bb); - assert!((ab == bb)); + assert_eq!(ab, bb); i += 1; } } diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index 714fd6e3ac5..fd98723c2f6 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -15,12 +15,12 @@ pub fn main() { let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char]; let s: ~str = str::from_chars(chs); - assert!((str::len(s) == 10u)); - assert!((str::char_len(s) == 4u)); - assert!((vec::len(str::to_chars(s)) == 4u)); - assert!((str::from_chars(str::to_chars(s)) == s)); - assert!((str::char_at(s, 0u) == 'e')); - assert!((str::char_at(s, 1u) == 'é')); + assert!(str::len(s) == 10u); + assert!(str::char_len(s) == 4u); + assert!(vec::len(str::to_chars(s)) == 4u); + assert!(str::from_chars(str::to_chars(s)) == s); + assert!(str::char_at(s, 0u) == 'e'); + assert!(str::char_at(s, 1u) == 'é'); assert!((str::is_utf8(str::to_bytes(s)))); assert!((!str::is_utf8(~[0x80_u8]))); @@ -28,12 +28,12 @@ pub fn main() { assert!((!str::is_utf8(~[0xc0_u8, 0x10_u8]))); let mut stack = ~"a×c€"; - assert!((str::pop_char(&mut stack) == '€')); - assert!((str::pop_char(&mut stack) == 'c')); + assert_eq!(str::pop_char(&mut stack), '€'); + assert_eq!(str::pop_char(&mut stack), 'c'); str::push_char(&mut stack, 'u'); - assert!((stack == ~"a×u")); - assert!((str::shift_char(&mut stack) == 'a')); - assert!((str::shift_char(&mut stack) == '×')); + assert!(stack == ~"a×u"); + assert_eq!(str::shift_char(&mut stack), 'a'); + assert_eq!(str::shift_char(&mut stack), '×'); str::unshift_char(&mut stack, 'ß'); - assert!((stack == ~"ßu")); + assert!(stack == ~"ßu"); } diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs index 25d2d91d565..4e86b6cc948 100644 --- a/src/test/run-pass/utf8_idents.rs +++ b/src/test/run-pass/utf8_idents.rs @@ -13,7 +13,7 @@ pub fn main() { let Π = 3.14; let लंच = Π * Π + 1.54; assert!(float::abs((लंच - 1.54) - (Π * Π)) < ε); - assert!(საჭმელად_გემრიელი_სადილი() == 0); + assert_eq!(საჭმელად_გემრიელი_სადილი(), 0); } fn საჭმელად_გემრიელი_სადილი() -> int { @@ -37,9 +37,9 @@ fn საჭმელად_გემრიელი_სადილი() -> int // Lunchy arithmetic, mm. - assert!(hádegismatur * ручек * обед == 1000); - assert!(10 == ארוחת_צהריי); - assert!(ランチ + 午餐 + μεσημεριανό == 30); - assert!(ăn_trưa + อาหารกลางวัน == 20); + assert_eq!(hádegismatur * ручек * обед, 1000); + assert_eq!(10, ארוחת_צהריי); + assert_eq!(ランチ + 午餐 + μεσημεριανό, 30); + assert_eq!(ăn_trưa + อาหารกลางวัน, 20); return (абед + լանչ) >> غداء; } diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs index 0045b356d65..b6fa7c107db 100644 --- a/src/test/run-pass/vec-concat.rs +++ b/src/test/run-pass/vec-concat.rs @@ -14,7 +14,7 @@ pub fn main() { let b: ~[int] = ~[6, 7, 8, 9, 0]; let v: ~[int] = a + b; debug!(v[9]); - assert!((v[0] == 1)); - assert!((v[7] == 8)); - assert!((v[9] == 0)); + assert_eq!(v[0], 1); + assert_eq!(v[7], 8); + assert_eq!(v[9], 0); } diff --git a/src/test/run-pass/vec-each2_mut.rs b/src/test/run-pass/vec-each2_mut.rs index 3c6b7da9f14..05314f94c67 100644 --- a/src/test/run-pass/vec-each2_mut.rs +++ b/src/test/run-pass/vec-each2_mut.rs @@ -17,8 +17,8 @@ fn main(){ t2.push('b'); for vec::each2_mut(t1, t2) | i1, i2 | { - assert!(*i1 == 'a'); - assert!(*i2 == 'b'); + assert_eq!(*i1, 'a'); + assert_eq!(*i2, 'b'); } for vec::each2(t1, t2) | i1, i2 | { @@ -28,8 +28,8 @@ fn main(){ for vec::each2_mut(t1, t2) | i1, i2 | { *i1 = 'b'; *i2 = 'a'; - assert!(*i1 == 'b'); - assert!(*i2 == 'a'); + assert_eq!(*i1, 'b'); + assert_eq!(*i2, 'a'); } for vec::each2(t1, t2) | i1, i2 | { diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index e1e268e63de..816228b62c6 100644 --- a/src/test/run-pass/vec-growth.rs +++ b/src/test/run-pass/vec-growth.rs @@ -16,9 +16,9 @@ pub fn main() { v += ~[3]; v += ~[4]; v += ~[5]; - assert!((v[0] == 1)); - assert!((v[1] == 2)); - assert!((v[2] == 3)); - assert!((v[3] == 4)); - assert!((v[4] == 5)); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); + assert_eq!(v[3], 4); + assert_eq!(v[4], 5); } diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs index 012b8b83637..6757ef46951 100644 --- a/src/test/run-pass/vec-matching-autoslice.rs +++ b/src/test/run-pass/vec-matching-autoslice.rs @@ -3,7 +3,7 @@ pub fn main() { match x { [2, .._] => ::core::util::unreachable(), [1, ..tail] => { - assert!(tail == [2, 3]); + assert_eq!(tail, [2, 3]); } [_] => ::core::util::unreachable(), [] => ::core::util::unreachable() @@ -13,8 +13,8 @@ pub fn main() { match y { ([_, _, _], 0.5) => ::core::util::unreachable(), ([(1, a), (b, false), ..tail], _) => { - assert!(a == true); - assert!(b == 2); + assert_eq!(a, true); + assert_eq!(b, 2); assert!(tail.is_empty()); } ([..tail], _) => ::core::util::unreachable() diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs index e6b7bffc158..7dcea2d30b7 100644 --- a/src/test/run-pass/vec-matching-fold.rs +++ b/src/test/run-pass/vec-matching-fold.rs @@ -26,8 +26,8 @@ pub fn main() { let x = [1, 2, 3, 4, 5]; let product = foldl(x, 1, |a, b| a * *b); - assert!(product == 120); + assert_eq!(product, 120); let sum = foldr(x, 0, |a, b| *a + b); - assert!(sum == 15); + assert_eq!(sum, 15); } diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs index e9cf400334c..e4ca51368b2 100644 --- a/src/test/run-pass/vec-matching.rs +++ b/src/test/run-pass/vec-matching.rs @@ -6,7 +6,7 @@ fn a() { [_, .._, _, _] => ::core::util::unreachable(), [_, _] => ::core::util::unreachable(), [a] => { - assert!(a == 1); + assert_eq!(a, 1); } [] => ::core::util::unreachable() } @@ -16,33 +16,33 @@ fn b() { let x = [1, 2, 3]; match x { [a, b, ..c] => { - assert!(a == 1); - assert!(b == 2); - assert!(c == &[3]); + assert_eq!(a, 1); + assert_eq!(b, 2); + assert_eq!(c, &[3]); } _ => fail!() } match x { [..a, b, c] => { - assert!(a == &[1]); - assert!(b == 2); - assert!(c == 3); + assert_eq!(a, &[1]); + assert_eq!(b, 2); + assert_eq!(c, 3); } _ => fail!() } match x { [a, ..b, c] => { - assert!(a == 1); - assert!(b == &[2]); - assert!(c == 3); + assert_eq!(a, 1); + assert_eq!(b, &[2]); + assert_eq!(c, 3); } _ => fail!() } match x { [a, b, c] => { - assert!(a == 1); - assert!(b == 2); - assert!(c == 3); + assert_eq!(a, 1); + assert_eq!(b, 2); + assert_eq!(c, 3); } _ => fail!() } diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs index 7507a78378e..30f6befe69c 100644 --- a/src/test/run-pass/vec-self-append.rs +++ b/src/test/run-pass/vec-self-append.rs @@ -14,17 +14,17 @@ fn test_heap_to_heap() { // a spills onto the heap let mut a = ~[0, 1, 2, 3, 4]; a = a + a; // FIXME(#3387)---can't write a += a - assert!(a.len() == 10u); - assert!((a[0] == 0)); - assert!((a[1] == 1)); - assert!((a[2] == 2)); - assert!((a[3] == 3)); - assert!((a[4] == 4)); - assert!((a[5] == 0)); - assert!((a[6] == 1)); - assert!((a[7] == 2)); - assert!((a[8] == 3)); - assert!((a[9] == 4)); + assert_eq!(a.len(), 10u); + assert_eq!(a[0], 0); + assert_eq!(a[1], 1); + assert_eq!(a[2], 2); + assert_eq!(a[3], 3); + assert_eq!(a[4], 4); + assert_eq!(a[5], 0); + assert_eq!(a[6], 1); + assert_eq!(a[7], 2); + assert_eq!(a[8], 3); + assert_eq!(a[9], 4); } fn test_stack_to_heap() { @@ -32,13 +32,13 @@ fn test_stack_to_heap() { let mut a = ~[0, 1, 2]; // a spills to the heap a = a + a; // FIXME(#3387)---can't write a += a - assert!(a.len() == 6u); - assert!((a[0] == 0)); - assert!((a[1] == 1)); - assert!((a[2] == 2)); - assert!((a[3] == 0)); - assert!((a[4] == 1)); - assert!((a[5] == 2)); + assert_eq!(a.len(), 6u); + assert_eq!(a[0], 0); + assert_eq!(a[1], 1); + assert_eq!(a[2], 2); + assert_eq!(a[3], 0); + assert_eq!(a[4], 1); + assert_eq!(a[5], 2); } fn test_loop() { @@ -48,7 +48,7 @@ fn test_loop() { let mut expected_len = 1u; while i > 0 { error!(a.len()); - assert!(a.len() == expected_len); + assert_eq!(a.len(), expected_len); a = a + a; // FIXME(#3387)---can't write a += a i -= 1; expected_len *= 2u; diff --git a/src/test/run-pass/vec-slice-drop.rs b/src/test/run-pass/vec-slice-drop.rs index cc0649790fd..695441daf28 100644 --- a/src/test/run-pass/vec-slice-drop.rs +++ b/src/test/run-pass/vec-slice-drop.rs @@ -32,7 +32,7 @@ pub fn main() { let x = @mut 0; { let l = &[foo(x)]; - assert!(*l[0].x == 0); + assert_eq!(*l[0].x, 0); } - assert!(*x == 1); + assert_eq!(*x, 1); } diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index 8e653d21ec6..25ae7340bc1 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -11,6 +11,6 @@ pub fn main() { let v = ~[1,2,3,4,5]; let v2 = vec::slice(v, 1, 3); - assert!((v2[0] == 2)); - assert!((v2[1] == 3)); + assert_eq!(v2[0], 2); + assert_eq!(v2[1], 3); } diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs index fd65f150e4c..6a98ed678b2 100644 --- a/src/test/run-pass/vec-tail-matching.rs +++ b/src/test/run-pass/vec-tail-matching.rs @@ -11,7 +11,7 @@ pub fn main() { match x { [first, ..tail] => { assert!(first.string == ~"foo"); - assert!(tail.len() == 2); + assert_eq!(tail.len(), 2); assert!(tail[0].string == ~"bar"); assert!(tail[1].string == ~"baz"); @@ -20,8 +20,8 @@ pub fn main() { ::core::util::unreachable(); } [Foo { string: a }, Foo { string: b }] => { - assert!(a == ~"bar"); - assert!(b == ~"baz"); + assert_eq!(a, ~"bar"); + assert_eq!(b, ~"baz"); } _ => { ::core::util::unreachable(); diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index 1767dd3ee5b..a24ef38b283 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -9,16 +9,16 @@ // except according to those terms. pub fn main() { - assert!((~[0, 1]).to_str() == ~"[0, 1]"); - assert!((&[1, 2]).to_str() == ~"[1, 2]"); - assert!((@[2, 3]).to_str() == ~"[2, 3]"); + assert_eq!((~[0, 1]).to_str(), ~"[0, 1]"); + assert_eq!((&[1, 2]).to_str(), ~"[1, 2]"); + assert_eq!((@[2, 3]).to_str(), ~"[2, 3]"); let foo = ~[3, 4]; let bar = &[4, 5]; let baz = @[5, 6]; - assert!(foo.to_str() == ~"[3, 4]"); - assert!(bar.to_str() == ~"[4, 5]"); - assert!(baz.to_str() == ~"[5, 6]"); + assert_eq!(foo.to_str(), ~"[3, 4]"); + assert_eq!(bar.to_str(), ~"[4, 5]"); + assert_eq!(baz.to_str(), ~"[5, 6]"); } diff --git a/src/test/run-pass/vec-trailing-comma.rs b/src/test/run-pass/vec-trailing-comma.rs index 686fc655bdb..426416f63d3 100644 --- a/src/test/run-pass/vec-trailing-comma.rs +++ b/src/test/run-pass/vec-trailing-comma.rs @@ -13,8 +13,8 @@ pub fn main() { let v1: ~[int] = ~[10, 20, 30,]; let v2: ~[int] = ~[10, 20, 30]; - assert!((v1[2] == v2[2])); + assert_eq!(v1[2], v2[2]); let v3: ~[int] = ~[10,]; let v4: ~[int] = ~[10]; - assert!((v3[0] == v4[0])); + assert_eq!(v3[0], v4[0]); } diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs index d0215888147..34fcca9e35b 100644 --- a/src/test/run-pass/vec.rs +++ b/src/test/run-pass/vec.rs @@ -14,12 +14,12 @@ // -*- rust -*- pub fn main() { let v: ~[int] = ~[10, 20]; - assert!((v[0] == 10)); - assert!((v[1] == 20)); + assert_eq!(v[0], 10); + assert_eq!(v[1], 20); let mut x: int = 0; - assert!((v[x] == 10)); - assert!((v[x + 1] == 20)); + assert_eq!(v[x], 10); + assert_eq!(v[x + 1], 20); x = x + 1; - assert!((v[x] == 20)); - assert!((v[x - 1] == 10)); + assert_eq!(v[x], 20); + assert_eq!(v[x - 1], 10); } diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs index 417c0cdd915..465cb7d562b 100644 --- a/src/test/run-pass/while-with-break.rs +++ b/src/test/run-pass/while-with-break.rs @@ -15,5 +15,5 @@ pub fn main() { break; } } - assert!((i == 95)); + assert_eq!(i, 95); } diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index f22f90380c6..7e2229e78ea 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -19,5 +19,5 @@ fn f(p: &mut Point) { p.z = 13; } pub fn main() { let mut x: Point = Point {x: 10, y: 11, z: 12}; f(&mut x); - assert!((x.z == 13)); + assert_eq!(x.z, 13); } diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs index c7c47753b8a..f584237d0de 100644 --- a/src/test/run-pass/x86stdcall.rs +++ b/src/test/run-pass/x86stdcall.rs @@ -25,7 +25,7 @@ pub fn main() { kernel32::SetLastError(expected); let actual = kernel32::GetLastError(); log(error, actual); - assert!((expected == actual)); + assert_eq!(expected, actual); } } diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs index 50c3e780061..bf45b2fc039 100644 --- a/src/test/run-pass/zip-same-length.rs +++ b/src/test/run-pass/zip-same-length.rs @@ -34,6 +34,6 @@ pub fn main() { let ps = vec::zip(chars, ints); - assert!((ps.head() == &('a', 1u))); - assert!((ps.last() == &(j as char, 10u))); + assert_eq!(ps.head(), &('a', 1u)); + assert_eq!(ps.last(), &(j as char, 10u)); } |