OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto merge of #5407 : jbclements/rust/add-assert-eq-macro, r=jbclements

Browse Source 
Adds an assert_eq! macro that asserts that its two arguments are equal. Error messages can therefore be somewhat more informative than a simple assert, because the error message includes "expected" and "given" values.
This commit is contained in:
bors 2013-03-21 15:24:54 -07:00
commit ec8345b18a
18 changed files with 279 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
src/libcore/char.rs
View File

@ -288,16 +288,16 @@ fn test_is_whitespace() {
#[test]
fn test_to_digit() {
fail_unless!(to_digit('0', 10u) == Some(0u));
fail_unless!(to_digit('1', 2u) == Some(1u));
fail_unless!(to_digit('2', 3u) == Some(2u));
fail_unless!(to_digit('9', 10u) == Some(9u));
fail_unless!(to_digit('a', 16u) == Some(10u));
fail_unless!(to_digit('A', 16u) == Some(10u));
fail_unless!(to_digit('b', 16u) == Some(11u));
fail_unless!(to_digit('B', 16u) == Some(11u));
fail_unless!(to_digit('z', 36u) == Some(35u));
fail_unless!(to_digit('Z', 36u) == Some(35u));
assert_eq!(to_digit('0', 10u), Some(0u));
assert_eq!(to_digit('1', 2u), Some(1u));
assert_eq!(to_digit('2', 3u), Some(2u));
assert_eq!(to_digit('9', 10u), Some(9u));
assert_eq!(to_digit('a', 16u), Some(10u));
assert_eq!(to_digit('A', 16u), Some(10u));
assert_eq!(to_digit('b', 16u), Some(11u));
assert_eq!(to_digit('B', 16u), Some(11u));
assert_eq!(to_digit('z', 36u), Some(35u));
assert_eq!(to_digit('Z', 36u), Some(35u));
fail_unless!(to_digit(' ', 10u).is_none());
fail_unless!(to_digit('$', 36u).is_none());
@ -321,28 +321,28 @@ fn test_is_digit() {
#[test]
fn test_escape_default() {
fail_unless!(escape_default('\n') == ~"\\n");
fail_unless!(escape_default('\r') == ~"\\r");
fail_unless!(escape_default('\'') == ~"\\'");
fail_unless!(escape_default('"') == ~"\\\"");
fail_unless!(escape_default(' ') == ~" ");
fail_unless!(escape_default('a') == ~"a");
fail_unless!(escape_default('~') == ~"~");
fail_unless!(escape_default('\x00') == ~"\\x00");
fail_unless!(escape_default('\x1f') == ~"\\x1f");
fail_unless!(escape_default('\x7f') == ~"\\x7f");
fail_unless!(escape_default('\xff') == ~"\\xff");
fail_unless!(escape_default('\u011b') == ~"\\u011b");
fail_unless!(escape_default('\U0001d4b6') == ~"\\U0001d4b6");
assert_eq!(escape_default('\n'), ~"\\n");
assert_eq!(escape_default('\r'), ~"\\r");
assert_eq!(escape_default('\''), ~"\\'");
assert_eq!(escape_default('"'), ~"\\\"");
assert_eq!(escape_default(' '), ~" ");
assert_eq!(escape_default('a'), ~"a");
assert_eq!(escape_default('~'), ~"~");
assert_eq!(escape_default('\x00'), ~"\\x00");
assert_eq!(escape_default('\x1f'), ~"\\x1f");
assert_eq!(escape_default('\x7f'), ~"\\x7f");
assert_eq!(escape_default('\xff'), ~"\\xff");
assert_eq!(escape_default('\u011b'), ~"\\u011b");
assert_eq!(escape_default('\U0001d4b6'), ~"\\U0001d4b6");
}
#[test]
fn test_escape_unicode() {
fail_unless!(escape_unicode('\x00') == ~"\\x00");
fail_unless!(escape_unicode('\n') == ~"\\x0a");
fail_unless!(escape_unicode(' ') == ~"\\x20");
fail_unless!(escape_unicode('a') == ~"\\x61");
fail_unless!(escape_unicode('\u011b') == ~"\\u011b");
fail_unless!(escape_unicode('\U0001d4b6') == ~"\\U0001d4b6");
assert_eq!(escape_unicode('\x00'), ~"\\x00");
assert_eq!(escape_unicode('\n'), ~"\\x0a");
assert_eq!(escape_unicode(' '), ~"\\x20");
assert_eq!(escape_unicode('a'), ~"\\x61");
assert_eq!(escape_unicode('\u011b'), ~"\\u011b");
assert_eq!(escape_unicode('\U0001d4b6'), ~"\\U0001d4b6");
}

10
src/libcore/cmp.rs
View File

@ -172,10 +172,10 @@ pub pure fn max<T:Ord>(v1: T, v2: T) -> T {
mod test {
#[test]
fn test_int() {
fail_unless!(5.cmp(&10) == Less);
fail_unless!(10.cmp(&5) == Greater);
fail_unless!(5.cmp(&5) == Equal);
fail_unless!((-5).cmp(&12) == Less);
fail_unless!(12.cmp(-5) == Greater);
assert_eq!(5.cmp(&10), Less);
assert_eq!(10.cmp(&5), Greater);
assert_eq!(5.cmp(&5), Equal);
assert_eq!((-5).cmp(&12), Less);
assert_eq!(12.cmp(-5), Greater);
}
}

294
src/libcore/dlist.rs
View File

@ -555,15 +555,15 @@ mod tests {
let ab = from_vec(~[a,b]);
let cd = from_vec(~[c,d]);
let abcd = concat(concat(from_vec(~[ab,cd])));
abcd.assert_consistent(); fail_unless!(abcd.len() == 8);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 1);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 2);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 3);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 4);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 5);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 6);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 7);
abcd.assert_consistent(); fail_unless!(abcd.pop().get() == 8);
abcd.assert_consistent(); assert_eq!(abcd.len(), 8);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 1);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 2);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 3);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 4);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 5);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 6);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 7);
abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 8);
abcd.assert_consistent(); fail_unless!(abcd.is_empty());
}
#[test]
@ -571,15 +571,15 @@ mod tests {
let a = from_vec(~[1,2,3]);
let b = from_vec(~[4,5,6]);
a.append(b);
fail_unless!(a.len() == 6);
fail_unless!(b.len() == 0);
assert_eq!(a.len(), 6);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); fail_unless!(a.pop().get() == 1);
a.assert_consistent(); fail_unless!(a.pop().get() == 2);
a.assert_consistent(); fail_unless!(a.pop().get() == 3);
a.assert_consistent(); fail_unless!(a.pop().get() == 4);
a.assert_consistent(); fail_unless!(a.pop().get() == 5);
a.assert_consistent(); fail_unless!(a.pop().get() == 6);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 6);
a.assert_consistent(); fail_unless!(a.is_empty());
}
#[test]
@ -587,12 +587,12 @@ mod tests {
let a = from_vec(~[1,2,3]);
let b = DList::<int>();
a.append(b);
fail_unless!(a.len() == 3);
fail_unless!(b.len() == 0);
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); fail_unless!(a.pop().get() == 1);
a.assert_consistent(); fail_unless!(a.pop().get() == 2);
a.assert_consistent(); fail_unless!(a.pop().get() == 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); fail_unless!(a.is_empty());
}
#[test]
@ -600,12 +600,12 @@ mod tests {
let a = DList::<int>();
let b = from_vec(~[4,5,6]);
a.append(b);
fail_unless!(a.len() == 3);
fail_unless!(b.len() == 0);
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent(); fail_unless!(a.pop().get() == 4);
a.assert_consistent(); fail_unless!(a.pop().get() == 5);
a.assert_consistent(); fail_unless!(a.pop().get() == 6);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 6);
a.assert_consistent(); fail_unless!(a.is_empty());
}
#[test]
@ -613,8 +613,8 @@ mod tests {
let a = DList::<int>();
let b = DList::<int>();
a.append(b);
fail_unless!(a.len() == 0);
fail_unless!(b.len() == 0);
assert_eq!(a.len(), 0);
assert_eq!(b.len(), 0);
b.assert_consistent();
a.assert_consistent();
}
@ -637,34 +637,34 @@ mod tests {
let a = from_vec(~[1,2,3]);
let b = from_vec(~[4,5,6]);
b.prepend(a);
fail_unless!(a.len() == 0);
fail_unless!(b.len() == 6);
assert_eq!(a.len(), 0);
assert_eq!(b.len(), 6);
a.assert_consistent();
b.assert_consistent(); fail_unless!(b.pop().get() == 1);
b.assert_consistent(); fail_unless!(b.pop().get() == 2);
b.assert_consistent(); fail_unless!(b.pop().get() == 3);
b.assert_consistent(); fail_unless!(b.pop().get() == 4);
b.assert_consistent(); fail_unless!(b.pop().get() == 5);
b.assert_consistent(); fail_unless!(b.pop().get() == 6);
b.assert_consistent(); assert_eq!(b.pop().get(), 1);
b.assert_consistent(); assert_eq!(b.pop().get(), 2);
b.assert_consistent(); assert_eq!(b.pop().get(), 3);
b.assert_consistent(); assert_eq!(b.pop().get(), 4);
b.assert_consistent(); assert_eq!(b.pop().get(), 5);
b.assert_consistent(); assert_eq!(b.pop().get(), 6);
b.assert_consistent(); fail_unless!(b.is_empty());
}
#[test]
pub fn test_dlist_reverse() {
let a = from_vec(~[5,4,3,2,1]);
a.reverse();
fail_unless!(a.len() == 5);
a.assert_consistent(); fail_unless!(a.pop().get() == 1);
a.assert_consistent(); fail_unless!(a.pop().get() == 2);
a.assert_consistent(); fail_unless!(a.pop().get() == 3);
a.assert_consistent(); fail_unless!(a.pop().get() == 4);
a.assert_consistent(); fail_unless!(a.pop().get() == 5);
assert_eq!(a.len(), 5);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); fail_unless!(a.is_empty());
}
#[test]
pub fn test_dlist_reverse_empty() {
let a = DList::<int>();
a.reverse();
fail_unless!(a.len() == 0);
assert_eq!(a.len(), 0);
a.assert_consistent();
}
#[test]
@ -675,20 +675,20 @@ mod tests {
a.insert_before(3, nobe);
}
}
fail_unless!(a.len() == 6);
a.assert_consistent(); fail_unless!(a.pop().get() == 1);
a.assert_consistent(); fail_unless!(a.pop().get() == 2);
a.assert_consistent(); fail_unless!(a.pop().get() == 3);
a.assert_consistent(); fail_unless!(a.pop().get() == 4);
a.assert_consistent(); fail_unless!(a.pop().get() == 3);
a.assert_consistent(); fail_unless!(a.pop().get() == 5);
assert_eq!(a.len(), 6);
a.assert_consistent(); assert_eq!(a.pop().get(), 1);
a.assert_consistent(); assert_eq!(a.pop().get(), 2);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 4);
a.assert_consistent(); assert_eq!(a.pop().get(), 3);
a.assert_consistent(); assert_eq!(a.pop().get(), 5);
a.assert_consistent(); fail_unless!(a.is_empty());
}
#[test]
pub fn test_dlist_clear() {
let a = from_vec(~[5,4,3,2,1]);
a.clear();
fail_unless!(a.len() == 0);
assert_eq!(a.len(), 0);
a.assert_consistent();
}
#[test]
@ -701,33 +701,33 @@ mod tests {
#[test]
pub fn test_dlist_head_tail() {
let l = from_vec(~[1,2,3]);
fail_unless!(l.head() == 1);
fail_unless!(l.tail() == 3);
fail_unless!(l.len() == 3);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
pub fn test_dlist_pop() {
let l = from_vec(~[1,2,3]);
fail_unless!(l.pop().get() == 1);
fail_unless!(l.tail() == 3);
fail_unless!(l.head() == 2);
fail_unless!(l.pop().get() == 2);
fail_unless!(l.tail() == 3);
fail_unless!(l.head() == 3);
fail_unless!(l.pop().get() == 3);
assert_eq!(l.pop().get(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.head(), 2);
assert_eq!(l.pop().get(), 2);
assert_eq!(l.tail(), 3);
assert_eq!(l.head(), 3);
assert_eq!(l.pop().get(), 3);
fail_unless!(l.is_empty());
fail_unless!(l.pop().is_none());
}
#[test]
pub fn test_dlist_pop_tail() {
let l = from_vec(~[1,2,3]);
fail_unless!(l.pop_tail().get() == 3);
fail_unless!(l.tail() == 2);
fail_unless!(l.head() == 1);
fail_unless!(l.pop_tail().get() == 2);
fail_unless!(l.tail() == 1);
fail_unless!(l.head() == 1);
fail_unless!(l.pop_tail().get() == 1);
assert_eq!(l.pop_tail().get(), 3);
assert_eq!(l.tail(), 2);
assert_eq!(l.head(), 1);
assert_eq!(l.pop_tail().get(), 2);
assert_eq!(l.tail(), 1);
assert_eq!(l.head(), 1);
assert_eq!(l.pop_tail().get(), 1);
fail_unless!(l.is_empty());
fail_unless!(l.pop_tail().is_none());
}
@ -735,34 +735,34 @@ mod tests {
pub fn test_dlist_push() {
let l = DList::<int>();
l.push(1);
fail_unless!(l.head() == 1);
fail_unless!(l.tail() == 1);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 1);
l.push(2);
fail_unless!(l.head() == 1);
fail_unless!(l.tail() == 2);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 2);
l.push(3);
fail_unless!(l.head() == 1);
fail_unless!(l.tail() == 3);
fail_unless!(l.len() == 3);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
pub fn test_dlist_push_head() {
let l = DList::<int>();
l.push_head(3);
fail_unless!(l.head() == 3);
fail_unless!(l.tail() == 3);
assert_eq!(l.head(), 3);
assert_eq!(l.tail(), 3);
l.push_head(2);
fail_unless!(l.head() == 2);
fail_unless!(l.tail() == 3);
assert_eq!(l.head(), 2);
assert_eq!(l.tail(), 3);
l.push_head(1);
fail_unless!(l.head() == 1);
fail_unless!(l.tail() == 3);
fail_unless!(l.len() == 3);
assert_eq!(l.head(), 1);
assert_eq!(l.tail(), 3);
assert_eq!(l.len(), 3);
}
#[test]
pub fn test_dlist_foldl() {
let l = from_vec(vec::from_fn(101, |x|x));
fail_unless!(iter::foldl(&l, 0, |accum,elem| *accum+*elem) == 5050);
assert_eq!(iter::foldl(&l, 0, |accum,elem| *accum+*elem), 5050);
}
#[test]
pub fn test_dlist_break_early() {
@ -772,7 +772,7 @@ mod tests {
x += 1;
if (*i == 3) { break; }
}
fail_unless!(x == 3);
assert_eq!(x, 3);
}
#[test]
pub fn test_dlist_remove_head() {
@ -780,13 +780,13 @@ mod tests {
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); fail_unless!(l.head() == 2);
l.assert_consistent(); fail_unless!(l.tail() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 2);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -795,13 +795,13 @@ mod tests {
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -810,13 +810,13 @@ mod tests {
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -825,14 +825,14 @@ mod tests {
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let _three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); l.remove(two);
// and through and through, the vorpal blade went snicker-snack
l.assert_consistent(); fail_unless!(l.len() == 1);
l.assert_consistent(); fail_unless!(l.head() == 3);
l.assert_consistent(); fail_unless!(l.tail() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 3);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -841,13 +841,13 @@ mod tests {
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(one);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); fail_unless!(l.len() == 1);
l.assert_consistent(); fail_unless!(l.head() == 2);
l.assert_consistent(); fail_unless!(l.tail() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 2);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -856,13 +856,13 @@ mod tests {
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); fail_unless!(l.len() == 1);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); assert_eq!(l.len(), 1);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -871,7 +871,7 @@ mod tests {
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = l.push_n(3);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); l.remove(two);
l.assert_consistent(); l.remove(three);
l.assert_consistent(); l.remove(one); // Twenty-three is number one!
@ -884,14 +884,14 @@ mod tests {
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); let three = new_dlist_node(3);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_n_before(three, two);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -900,14 +900,14 @@ mod tests {
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); let three = new_dlist_node(3);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_n_after(three, one);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -915,14 +915,14 @@ mod tests {
let l = DList::<int>();
l.assert_consistent(); let one = l.push_n(1);
l.assert_consistent(); let _two = l.push_n(2);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_before(3, one);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); fail_unless!(l.head() == 3);
l.assert_consistent(); fail_unless!(l.tail() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 3);
l.assert_consistent(); assert_eq!(l.tail(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test]
@ -930,14 +930,14 @@ mod tests {
let l = DList::<int>();
l.assert_consistent(); let _one = l.push_n(1);
l.assert_consistent(); let two = l.push_n(2);
l.assert_consistent(); fail_unless!(l.len() == 2);
l.assert_consistent(); assert_eq!(l.len(), 2);
l.assert_consistent(); l.insert_after(3, two);
l.assert_consistent(); fail_unless!(l.len() == 3);
l.assert_consistent(); fail_unless!(l.head() == 1);
l.assert_consistent(); fail_unless!(l.tail() == 3);
l.assert_consistent(); fail_unless!(l.pop().get() == 1);
l.assert_consistent(); fail_unless!(l.pop().get() == 2);
l.assert_consistent(); fail_unless!(l.pop().get() == 3);
l.assert_consistent(); assert_eq!(l.len(), 3);
l.assert_consistent(); assert_eq!(l.head(), 1);
l.assert_consistent(); assert_eq!(l.tail(), 3);
l.assert_consistent(); assert_eq!(l.pop().get(), 1);
l.assert_consistent(); assert_eq!(l.pop().get(), 2);
l.assert_consistent(); assert_eq!(l.pop().get(), 3);
l.assert_consistent(); fail_unless!(l.is_empty());
}
#[test] #[should_fail] #[ignore(cfg(windows))]

34
src/libcore/either.rs
View File

@ -191,77 +191,77 @@ fn test_either_right() {
fn test_lefts() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = lefts(input);
fail_unless!((result == ~[10, 12, 14]));
assert_eq!(result, ~[10, 12, 14]);
}
#[test]
fn test_lefts_none() {
let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
let result = lefts(input);
fail_unless!((vec::len(result) == 0u));
assert_eq!(vec::len(result), 0u);
}
#[test]
fn test_lefts_empty() {
let input: ~[Either<int, int>] = ~[];
let result = lefts(input);
fail_unless!((vec::len(result) == 0u));
assert_eq!(vec::len(result), 0u);
}
#[test]
fn test_rights() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = rights(input);
fail_unless!((result == ~[11, 13]));
assert_eq!(result, ~[11, 13]);
}
#[test]
fn test_rights_none() {
let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
let result = rights(input);
fail_unless!((vec::len(result) == 0u));
assert_eq!(vec::len(result), 0u);
}
#[test]
fn test_rights_empty() {
let input: ~[Either<int, int>] = ~[];
let result = rights(input);
fail_unless!((vec::len(result) == 0u));
assert_eq!(vec::len(result), 0u);
}
#[test]
fn test_partition() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let (lefts, rights) = partition(input);
fail_unless!((lefts[0] == 10));
fail_unless!((lefts[1] == 12));
fail_unless!((lefts[2] == 14));
fail_unless!((rights[0] == 11));
fail_unless!((rights[1] == 13));
assert_eq!(lefts[0], 10);
assert_eq!(lefts[1], 12);
assert_eq!(lefts[2], 14);
assert_eq!(rights[0], 11);
assert_eq!(rights[1], 13);
}
#[test]
fn test_partition_no_lefts() {
let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
let (lefts, rights) = partition(input);
fail_unless!((vec::len(lefts) == 0u));
fail_unless!((vec::len(rights) == 2u));
assert_eq!(vec::len(lefts), 0u);
assert_eq!(vec::len(rights), 2u);
}
#[test]
fn test_partition_no_rights() {
let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
let (lefts, rights) = partition(input);
fail_unless!((vec::len(lefts) == 2u));
fail_unless!((vec::len(rights) == 0u));
assert_eq!(vec::len(lefts), 2u);
assert_eq!(vec::len(rights), 0u);
}
#[test]
fn test_partition_empty() {
let input: ~[Either<int, int>] = ~[];
let (lefts, rights) = partition(input);
fail_unless!((vec::len(lefts) == 0u));
fail_unless!((vec::len(rights) == 0u));
assert_eq!(vec::len(lefts), 0u);
assert_eq!(vec::len(rights), 0u);
}
//

20
src/libstd/json.rs
View File

@ -1278,20 +1278,6 @@ mod tests {
fail_unless!(a == b);
}
// two fns copied from libsyntax/util/testing.rs.
// Should they be in their own crate?
pub pure fn check_equal_ptr<T:cmp::Eq> (given : &T, expected: &T) {
if !((given == expected) && (expected == given )) {
fail!(fmt!("given %?, expected %?",given,expected));
}
}
pub pure fn check_equal<T:cmp::Eq> (given : T, expected: T) {
if !((given == expected) && (expected == given )) {
fail!(fmt!("given %?, expected %?",given,expected));
}
}
#[test]
fn test_write_enum () {
let bw = @io::BytesWriter();
@ -1309,7 +1295,7 @@ mod tests {
}
}
}
check_equal(str::from_bytes(bw.bytes), ~"[\"frog\",[\"Henry\",349]]");
assert_eq!(str::from_bytes(bw.bytes), ~"[\"frog\",[\"Henry\",349]]");
}
#[test]
@ -1324,7 +1310,7 @@ mod tests {
}
}
}
check_equal(str::from_bytes(bw.bytes), ~"\"jodhpurs\"");
assert_eq!(str::from_bytes(bw.bytes), ~"\"jodhpurs\"");
}
#[test]
@ -1336,7 +1322,7 @@ mod tests {
do encoder.emit_enum_variant (~"None",37,1242) {
}
}
check_equal(str::from_bytes(bw.bytes), ~"null");
assert_eq!(str::from_bytes(bw.bytes), ~"null");
}
#[test]

8
src/libsyntax/codemap.rs
View File

@ -208,7 +208,8 @@ pub enum ExpnInfo {
pub type FileName = ~str;
pub struct FileLines {
pub struct FileLines
{
file: @FileMap,
lines: ~[uint]
}
@ -509,17 +510,16 @@ priv impl CodeMap {
#[cfg(test)]
mod test {
use super::*;
use util::testing::check_equal;
#[test]
fn t1 () {
let cm = CodeMap::new();
let fm = cm.new_filemap(~"blork.rs",@~"first line.\nsecond line");
fm.next_line(BytePos(0));
check_equal(&fm.get_line(0),&~"first line.");
assert_eq!(&fm.get_line(0),&~"first line.");
// TESTING BROKEN BEHAVIOR:
fm.next_line(BytePos(10));
check_equal(&fm.get_line(1),&~".");
assert_eq!(&fm.get_line(1),&~".");
}
#[test]

3
src/libsyntax/ext/auto_encode.rs
View File

@ -1202,7 +1202,6 @@ fn mk_enum_deser_body(
mod test {
use std::serialize::Encodable;
use std::serialize::Encoder;
use util::testing::*;
// just adding the ones I want to test, for now:
#[deriving_eq]
@ -1321,7 +1320,7 @@ mod test {
}
#[test] fn encode_enum_test () {
check_equal (to_call_log(Book(34,44)),
assert_eq!(to_call_log(Book(34,44)),
~[CallToEmitEnum (~"Written"),
CallToEmitEnumVariant (~"Book",0,2),
CallToEmitEnumVariantArg (0),

25
src/libsyntax/ext/base.rs
View File

@ -509,7 +509,6 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{
#[cfg(test)]
mod test {
use super::MapChain;
use util::testing::check_equal;
use core::hashmap::linear::LinearMap;
#[test] fn testenv () {
@ -517,23 +516,23 @@ mod test {
a.insert (@~"abc",@15);
let m = MapChain::new(~a);
m.insert (@~"def",@16);
// FIXME: #4492 (ICE) check_equal(m.find(&@~"abc"),Some(@15));
// .... check_equal(m.find(&@~"def"),Some(@16));
check_equal(*(m.find(&@~"abc").get()),15);
check_equal(*(m.find(&@~"def").get()),16);
// FIXME: #4492 (ICE) assert_eq!(m.find(&@~"abc"),Some(@15));
// .... assert_eq!(m.find(&@~"def"),Some(@16));
assert_eq!(*(m.find(&@~"abc").get()),15);
assert_eq!(*(m.find(&@~"def").get()),16);
let n = m.push_frame();
// old bindings are still present:
check_equal(*(n.find(&@~"abc").get()),15);
check_equal(*(n.find(&@~"def").get()),16);
assert_eq!(*(n.find(&@~"abc").get()),15);
assert_eq!(*(n.find(&@~"def").get()),16);
n.insert (@~"def",@17);
// n shows the new binding
check_equal(*(n.find(&@~"abc").get()),15);
check_equal(*(n.find(&@~"def").get()),17);
assert_eq!(*(n.find(&@~"abc").get()),15);
assert_eq!(*(n.find(&@~"def").get()),17);
// ... but m still has the old ones
// FIXME: #4492: check_equal(m.find(&@~"abc"),Some(@15));
// FIXME: #4492: check_equal(m.find(&@~"def"),Some(@16));
check_equal(*(m.find(&@~"abc").get()),15);
check_equal(*(m.find(&@~"def").get()),16);
// FIXME: #4492: assert_eq!(m.find(&@~"abc"),Some(@15));
// FIXME: #4492: assert_eq!(m.find(&@~"def"),Some(@16));
assert_eq!(*(m.find(&@~"abc").get()),15);
assert_eq!(*(m.find(&@~"def").get()),16);
}
}

15
src/libsyntax/ext/expand.rs
View File

@ -464,6 +464,15 @@ pub fn core_macros() -> ~str {
}
)
macro_rules! assert_eq (
($given:expr , $expected:expr) =>
({let given_val = $given;
let expected_val = $expected;
// check both directions of equality....
if !((given_val == expected_val) && (expected_val == given_val)) {
fail!(fmt!(\"expected: %?, given: %?\",expected_val,given_val));
}}))
macro_rules! condition (
{ $c:ident: $in:ty -> $out:ty; } => {
@ -481,6 +490,7 @@ pub fn core_macros() -> ~str {
}
)
}";
}
@ -547,7 +557,6 @@ mod test {
use codemap;
use codemap::spanned;
use parse;
use util::testing::check_equal;
use core::option::{None, Some};
// make sure that fail! is present
@ -634,9 +643,9 @@ mod test {
let attr2 = make_dummy_attr (@~"bar");
let escape_attr = make_dummy_attr (@~"macro_escape");
let attrs1 = ~[attr1, escape_attr, attr2];
check_equal (contains_macro_escape (attrs1),true);
assert_eq!(contains_macro_escape (attrs1),true);
let attrs2 = ~[attr1,attr2];
check_equal (contains_macro_escape (attrs2),false);
assert_eq!(contains_macro_escape (attrs2),false);
}
// make a "meta_word" outer attribute with the given name

19
src/libsyntax/parse/lexer.rs
View File

@ -779,7 +779,6 @@ pub mod test {
use core::option::None;
use diagnostic;
use parse::token;
use util::testing::{check_equal, check_equal_ptr};
// represents a testing reader (incl. both reader and interner)
struct Env {
@ -809,17 +808,17 @@ pub mod test {
let tok2 = TokenAndSpan{
tok:token::IDENT(id, false),
sp:span {lo:BytePos(21),hi:BytePos(23),expn_info: None}};
check_equal (tok1,tok2);
assert_eq!(tok1,tok2);
// the 'main' id is already read:
check_equal (copy string_reader.last_pos,BytePos(28));
assert_eq!(copy string_reader.last_pos,BytePos(28));
// read another token:
let tok3 = string_reader.next_token();
let tok4 = TokenAndSpan{
tok:token::IDENT(ident_interner.intern (@~"main"), false),
sp:span {lo:BytePos(24),hi:BytePos(28),expn_info: None}};
check_equal (tok3,tok4);
assert_eq!(tok3,tok4);
// the lparen is already read:
check_equal (copy string_reader.last_pos,BytePos(29))
assert_eq!(copy string_reader.last_pos,BytePos(29))
}
// check that the given reader produces the desired stream
@ -828,7 +827,7 @@ pub mod test {
for expected.each |expected_tok| {
let TokenAndSpan {tok:actual_tok, sp: _} =
env.string_reader.next_token();
check_equal(&actual_tok,expected_tok);
assert_eq!(&actual_tok,expected_tok);
}
}
@ -872,21 +871,21 @@ pub mod test {
let env = setup(~"'a'");
let TokenAndSpan {tok, sp: _} =
env.string_reader.next_token();
fail_unless!(tok == token::LIT_INT('a' as i64, ast::ty_char));
assert_eq!(tok,token::LIT_INT('a' as i64, ast::ty_char));
}
#[test] fn character_space() {
let env = setup(~"' '");
let TokenAndSpan {tok, sp: _} =
env.string_reader.next_token();
fail_unless!(tok == token::LIT_INT(' ' as i64, ast::ty_char));
assert_eq!(tok, token::LIT_INT(' ' as i64, ast::ty_char));
}
#[test] fn character_escaped() {
let env = setup(~"'\n'");
let TokenAndSpan {tok, sp: _} =
env.string_reader.next_token();
fail_unless!(tok == token::LIT_INT('\n' as i64, ast::ty_char));
assert_eq!(tok, token::LIT_INT('\n' as i64, ast::ty_char));
}
#[test] fn lifetime_name() {
@ -894,7 +893,7 @@ pub mod test {
let TokenAndSpan {tok, sp: _} =
env.string_reader.next_token();
let id = env.interner.intern(@~"abc");
fail_unless!(tok == token::LIFETIME(id));
assert_eq!(tok, token::LIFETIME(id));
}
}

5
src/libsyntax/parse/mod.rs
View File

@ -313,7 +313,6 @@ mod test {
use std;
use core::io;
use core::option::None;
use util::testing::*;
#[test] fn to_json_str<E : Encodable<std::json::Encoder>>(val: @E) -> ~str {
do io::with_str_writer |writer| {
@ -327,7 +326,7 @@ mod test {
@~"fn foo (x : int) { x; }",
~[],
new_parse_sess(None));
check_equal(to_json_str(@tts),
assert_eq!(to_json_str(@tts),
~"[[\"tt_tok\",[null,[\"IDENT\",[\"fn\",false]]]],\
[\"tt_tok\",[null,[\"IDENT\",[\"foo\",false]]]],\
[\"tt_delim\",[[[\"tt_tok\",[null,[\"LPAREN\",[]]]],\
@ -347,7 +346,7 @@ mod test {
@~"fn foo (x : int) { x; }",
~[],~[],
new_parse_sess(None));
check_equal(ast1,ast2);
assert_eq!(ast1,ast2);
}
}

2
src/libsyntax/print/pp.rs
View File

@ -117,7 +117,7 @@ pub fn tok_str(++t: token) -> ~str {
pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint,
lim: uint) -> ~str {
let n = vec::len(toks);
fail_unless!((n == vec::len(szs)));
fail_unless!(n == vec::len(szs));
let mut i = left;
let mut L = lim;
let mut s = ~"[";

5
src/libsyntax/print/pprust.rs
View File

@ -2254,7 +2254,6 @@ pub mod test {
use core::cmp::Eq;
use core::option::None;
use parse;
use util::testing::check_equal;
fn string_check<T:Eq> (given : &T, expected: &T) {
if !(given == expected) {
@ -2275,7 +2274,7 @@ pub mod test {
cf: ast::return_val
};
let generics = ast_util::empty_generics();
check_equal (&fun_to_str(&decl, abba_ident, None, &generics, mock_interner),
assert_eq!(&fun_to_str(&decl, abba_ident, None, &generics, mock_interner),
&~"fn abba()");
}
@ -2295,7 +2294,7 @@ pub mod test {
});
let varstr = variant_to_str(var,mock_interner);
check_equal(&varstr,&~"pub principal_skinner");
assert_eq!(&varstr,&~"pub principal_skinner");
}
}

1
src/libsyntax/syntax.rc
View File

@ -46,7 +46,6 @@ pub mod visit;
pub mod fold;
pub mod util {
pub mod interner;
pub mod testing;
}

34
src/libsyntax/util/interner.rs
View File

@ -77,32 +77,32 @@ pub fn i1 () {
pub fn i2 () {
let i : Interner<@~str> = Interner::new();
// first one is zero:
fail_unless!(i.intern (@~"dog") == 0);
assert_eq!(i.intern (@~"dog"), 0);
// re-use gets the same entry:
fail_unless!(i.intern (@~"dog") == 0);
assert_eq!(i.intern (@~"dog"), 0);
// different string gets a different #:
fail_unless!(i.intern (@~"cat") == 1);
fail_unless!(i.intern (@~"cat") == 1);
assert_eq!(i.intern (@~"cat"), 1);
assert_eq!(i.intern (@~"cat"), 1);
// dog is still at zero
fail_unless!(i.intern (@~"dog") == 0);
assert_eq!(i.intern (@~"dog"), 0);
// gensym gets 3
fail_unless!(i.gensym (@~"zebra" ) == 2);
assert_eq!(i.gensym (@~"zebra" ), 2);
// gensym of same string gets new number :
fail_unless!(i.gensym (@~"zebra" ) == 3);
assert_eq!(i.gensym (@~"zebra" ), 3);
// gensym of *existing* string gets new number:
fail_unless!(i.gensym (@~"dog") == 4);
fail_unless!(i.get(0) == @~"dog");
fail_unless!(i.get(1) == @~"cat");
fail_unless!(i.get(2) == @~"zebra");
fail_unless!(i.get(3) == @~"zebra");
fail_unless!(i.get(4) == @~"dog");
assert_eq!(i.gensym (@~"dog"), 4);
assert_eq!(i.get(0), @~"dog");
assert_eq!(i.get(1), @~"cat");
assert_eq!(i.get(2), @~"zebra");
assert_eq!(i.get(3), @~"zebra");
assert_eq!(i.get(4), @~"dog");
}
#[test]
pub fn i3 () {
let i : Interner<@~str> = Interner::prefill([@~"Alan",@~"Bob",@~"Carol"]);
fail_unless!(i.get(0) == @~"Alan");
fail_unless!(i.get(1) == @~"Bob");
fail_unless!(i.get(2) == @~"Carol");
fail_unless!(i.intern(@~"Bob") == 1);
assert_eq!(i.get(0), @~"Alan");
assert_eq!(i.get(1), @~"Bob");
assert_eq!(i.get(2), @~"Carol");
assert_eq!(i.intern(@~"Bob"), 1);
}

24
src/libsyntax/util/testing.rs
View File

@ -1,24 +0,0 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// support for test cases.
use core::cmp;
pub pure fn check_equal_ptr<T:cmp::Eq> (given : &T, expected: &T) {
if !((given == expected) && (expected == given )) {
fail!(fmt!("given %?, expected %?",given,expected));
}
}
pub pure fn check_equal<T:cmp::Eq> (given : T, expected: T) {
if !((given == expected) && (expected == given )) {
fail!(fmt!("given %?, expected %?",given,expected));
}
}

8
src/test/run-fail/assert-eq-macro-fail.rs Normal file
View File

@ -0,0 +1,8 @@
// error-pattern:expected: 15, given: 14
#[deriving_eq]
struct Point { x : int }
fn main() {
assert_eq!(14,15);
}

10
src/test/run-pass/assert-eq-macro-success.rs Normal file
View File

@ -0,0 +1,10 @@
#[deriving_eq]
struct Point { x : int }
fn main() {
assert_eq!(14,14);
assert_eq!(~"abc",~"abc");
assert_eq!(~Point{x:34},~Point{x:34});
assert_eq!(&Point{x:34},&Point{x:34});
assert_eq!(@Point{x:34},@Point{x:34});
}