diff --git a/doc/rust.md b/doc/rust.md index cc144ed730a79..24200459d90f3 100644 --- a/doc/rust.md +++ b/doc/rust.md @@ -1971,7 +1971,7 @@ let v = ~[1,2,3]; mutate(copy v); // Pass a copy -fail_unless!(v[0] == 1); // Original was not modified +assert!(v[0] == 1); // Original was not modified ~~~~ ### Unary move expressions @@ -2491,7 +2491,7 @@ An example of a tuple type and its use: type Pair<'self> = (int,&'self str); let p: Pair<'static> = (10,"hello"); let (a, b) = p; -fail_unless!(b != "world"); +assert!(b != "world"); ~~~~ @@ -2519,7 +2519,7 @@ An example of a vector type and its use: ~~~~ let v: &[int] = &[7, 5, 3]; let i: int = v[2]; -fail_unless!(i == 3); +assert!(i == 3); ~~~~ All in-bounds elements of a vector are always initialized, @@ -2925,7 +2925,7 @@ example of an _implicit dereference_ operation performed on box values: ~~~~~~~~ struct Foo { y: int } let x = @Foo{y: 10}; -fail_unless!(x.y == 10); +assert!(x.y == 10); ~~~~~~~~ Other operations act on box values as single-word-sized address values. For diff --git a/doc/tutorial-ffi.md b/doc/tutorial-ffi.md index 6660a4a794216..4a93eecac0da5 100644 --- a/doc/tutorial-ffi.md +++ b/doc/tutorial-ffi.md @@ -239,7 +239,7 @@ fn unix_time_in_microseconds() -> u64 { } } -# fn main() { fail_unless!(fmt!("%?", unix_time_in_microseconds()) != ~""); } +# fn main() { assert!(fmt!("%?", unix_time_in_microseconds()) != ~""); } ~~~~ The `#[nolink]` attribute indicates that there's no foreign library to diff --git a/doc/tutorial-tasks.md b/doc/tutorial-tasks.md index 922fad82f39d2..5168809e9aab7 100644 --- a/doc/tutorial-tasks.md +++ b/doc/tutorial-tasks.md @@ -297,7 +297,7 @@ let result = ports.foldl(0, |accum, port| *accum + port.recv() ); Rust has a built-in mechanism for raising exceptions. The `fail!()` macro (which can also be written with an error string as an argument: `fail!( -~reason)`) and the `fail_unless!` construct (which effectively calls `fail!()` +~reason)`) and the `assert!` construct (which effectively calls `fail!()` if a boolean expression is false) are both ways to raise exceptions. When a task raises an exception the task unwinds its stack---running destructors and freeing memory along the way---and then exits. Unlike exceptions in C++, @@ -339,7 +339,7 @@ let result: Result = do task::try { fail!(~"oops!"); } }; -fail_unless!(result.is_err()); +assert!(result.is_err()); ~~~ Unlike `spawn`, the function spawned using `try` may return a value, @@ -401,7 +401,7 @@ do spawn { // Bidirectionally linked // Wait for the supervised child task to exist. let message = receiver.recv(); // Kill both it and the parent task. - fail_unless!(message != 42); + assert!(message != 42); } do try { // Unidirectionally linked sender.send(42); @@ -507,13 +507,13 @@ do spawn { }; from_child.send(22); -fail_unless!(from_child.recv() == ~"22"); +assert!(from_child.recv() == ~"22"); from_child.send(23); from_child.send(0); -fail_unless!(from_child.recv() == ~"23"); -fail_unless!(from_child.recv() == ~"0"); +assert!(from_child.recv() == ~"23"); +assert!(from_child.recv() == ~"0"); # } ~~~~ diff --git a/doc/tutorial.md b/doc/tutorial.md index 7518e3ef67614..9344c43ba10ad 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -381,7 +381,7 @@ expression to the given type. ~~~~ let x: float = 4.0; let y: uint = x as uint; -fail_unless!(y == 4u); +assert!(y == 4u); ~~~~ ## Syntax extensions @@ -850,8 +850,8 @@ Ending the function with a semicolon like so is equivalent to returning `()`. fn line(a: int, b: int, x: int) -> int { a * x + b } fn oops(a: int, b: int, x: int) -> () { a * x + b; } -fail_unless!(8 == line(5, 3, 1)); -fail_unless!(() == oops(5, 3, 1)); +assert!(8 == line(5, 3, 1)); +assert!(() == oops(5, 3, 1)); ~~~~ As with `match` expressions and `let` bindings, function arguments support @@ -1417,8 +1417,8 @@ and [`core::str`]. Here are some examples. let crayons = [Almond, AntiqueBrass, Apricot]; // Check the length of the vector -fail_unless!(crayons.len() == 3); -fail_unless!(!crayons.is_empty()); +assert!(crayons.len() == 3); +assert!(!crayons.is_empty()); // Iterate over a vector, obtaining a pointer to each element for crayons.each |crayon| { diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc index e213f4fc6da34..585fd1271a8fa 100644 --- a/src/compiletest/compiletest.rc +++ b/src/compiletest/compiletest.rc @@ -65,7 +65,7 @@ pub fn parse_config(args: ~[~str]) -> config { getopts::optflag(~"jit"), getopts::optflag(~"newrt")]; - fail_unless!(!args.is_empty()); + assert!(!args.is_empty()); let args_ = vec::tail(args); let matches = &match getopts::getopts(args_, opts) { diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs index 3302b353d69aa..a96f36f5e702c 100644 --- a/src/compiletest/procsrv.rs +++ b/src/compiletest/procsrv.rs @@ -25,7 +25,7 @@ fn target_env(lib_path: ~str, prog: ~str) -> ~[(~str,~str)] { let mut env = os::env(); // Make sure we include the aux directory in the path - fail_unless!(prog.ends_with(~".exe")); + assert!(prog.ends_with(~".exe")); let aux_path = prog.slice(0u, prog.len() - 4u) + ~".libaux"; env = do vec::map(env) |pair| { diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index c96a6502eecf7..3e3d70530dd35 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -292,30 +292,30 @@ pub fn test() { } assert_eq!(seq_range(10, 15), @[10, 11, 12, 13, 14]); - fail_unless!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]); - fail_unless!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]); + assert!(from_fn(5, |x| x+1) == @[1, 2, 3, 4, 5]); + assert!(from_elem(5, 3.14) == @[3.14, 3.14, 3.14, 3.14, 3.14]); } #[test] pub fn append_test() { - fail_unless!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]); + assert!(@[1,2,3] + @[4,5,6] == @[1,2,3,4,5,6]); } #[test] pub fn test_from_owned() { - fail_unless!(from_owned::(~[]) == @[]); - fail_unless!(from_owned(~[true]) == @[true]); - fail_unless!(from_owned(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]); - fail_unless!(from_owned(~[~"abc", ~"123"]) == @[~"abc", ~"123"]); - fail_unless!(from_owned(~[~[42]]) == @[~[42]]); + assert!(from_owned::(~[]) == @[]); + assert!(from_owned(~[true]) == @[true]); + assert!(from_owned(~[1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]); + assert!(from_owned(~[~"abc", ~"123"]) == @[~"abc", ~"123"]); + assert!(from_owned(~[~[42]]) == @[~[42]]); } #[test] pub fn test_from_slice() { - fail_unless!(from_slice::([]) == @[]); - fail_unless!(from_slice([true]) == @[true]); - fail_unless!(from_slice([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]); - fail_unless!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]); - fail_unless!(from_slice([@[42]]) == @[@[42]]); + assert!(from_slice::([]) == @[]); + assert!(from_slice([true]) == @[true]); + assert!(from_slice([1, 2, 3, 4, 5]) == @[1, 2, 3, 4, 5]); + assert!(from_slice([@"abc", @"123"]) == @[@"abc", @"123"]); + assert!(from_slice([@[42]]) == @[@[42]]); } diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index 2b669a285b31c..a30cb92693748 100644 --- a/src/libcore/bool.rs +++ b/src/libcore/bool.rs @@ -86,20 +86,20 @@ pub fn test_bool_from_str() { use from_str::FromStr; do all_values |v| { - fail_unless!(Some(v) == FromStr::from_str(to_str(v))) + assert!(Some(v) == FromStr::from_str(to_str(v))) } } #[test] pub fn test_bool_to_str() { - fail_unless!(to_str(false) == ~"false"); - fail_unless!(to_str(true) == ~"true"); + assert!(to_str(false) == ~"false"); + assert!(to_str(true) == ~"true"); } #[test] pub fn test_bool_to_bit() { do all_values |v| { - fail_unless!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 }); + assert!(to_bit(v) == if is_true(v) { 1u8 } else { 0u8 }); } } diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs index 6d8674caf870b..4369d4be217af 100644 --- a/src/libcore/cast.rs +++ b/src/libcore/cast.rs @@ -50,7 +50,7 @@ pub unsafe fn bump_box_refcount(t: @T) { forget(t); } * * # Example * - * fail_unless!(transmute("L") == ~[76u8, 0u8]); + * assert!(transmute("L") == ~[76u8, 0u8]); */ #[inline(always)] pub unsafe fn transmute(thing: L) -> G { @@ -116,7 +116,7 @@ pub mod tests { #[test] pub fn test_reinterpret_cast() { - fail_unless!(1u == unsafe { reinterpret_cast(&1) }); + assert!(1u == unsafe { reinterpret_cast(&1) }); } #[test] @@ -127,8 +127,8 @@ pub mod tests { let ptr: *int = transmute(box); // refcount 2 let _box1: @~str = reinterpret_cast(&ptr); let _box2: @~str = reinterpret_cast(&ptr); - fail_unless!(*_box1 == ~"box box box"); - fail_unless!(*_box2 == ~"box box box"); + assert!(*_box1 == ~"box box box"); + assert!(*_box2 == ~"box box box"); // Will destroy _box1 and _box2. Without the bump, this would // use-after-free. With too many bumps, it would leak. } @@ -140,7 +140,7 @@ pub mod tests { unsafe { let x = @100u8; let x: *BoxRepr = transmute(x); - fail_unless!((*x).data == 100); + assert!((*x).data == 100); let _x: @int = transmute(x); } } @@ -148,7 +148,7 @@ pub mod tests { #[test] pub fn test_transmute2() { unsafe { - fail_unless!(~[76u8, 0u8] == transmute(~"L")); + assert!(~[76u8, 0u8] == transmute(~"L")); } } } diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 72beb4e017dfc..28b3ebe4484c7 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -80,12 +80,12 @@ pub impl Cell { #[test] fn test_basic() { let value_cell = Cell(~10); - fail_unless!(!value_cell.is_empty()); + assert!(!value_cell.is_empty()); let value = value_cell.take(); - fail_unless!(value == ~10); - fail_unless!(value_cell.is_empty()); + assert!(value == ~10); + assert!(value_cell.is_empty()); value_cell.put_back(value); - fail_unless!(!value_cell.is_empty()); + assert!(!value_cell.is_empty()); } #[test] diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 027329a235544..4f1dbe6ab7f23 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -200,7 +200,7 @@ pub fn escape_unicode(c: char) -> ~str { let (c, pad) = (if c <= '\xff' { ('x', 2u) } else if c <= '\uffff' { ('u', 4u) } else { ('U', 8u) }); - fail_unless!(str::len(s) <= pad); + assert!(str::len(s) <= pad); let mut out = ~"\\"; unsafe { str::push_str(&mut out, str::from_char(c)); @@ -258,32 +258,32 @@ impl Eq for char { #[test] fn test_is_lowercase() { - fail_unless!(is_lowercase('a')); - fail_unless!(is_lowercase('ö')); - fail_unless!(is_lowercase('ß')); - fail_unless!(!is_lowercase('Ü')); - fail_unless!(!is_lowercase('P')); + assert!(is_lowercase('a')); + assert!(is_lowercase('ö')); + assert!(is_lowercase('ß')); + assert!(!is_lowercase('Ü')); + assert!(!is_lowercase('P')); } #[test] fn test_is_uppercase() { - fail_unless!(!is_uppercase('h')); - fail_unless!(!is_uppercase('ä')); - fail_unless!(!is_uppercase('ß')); - fail_unless!(is_uppercase('Ö')); - fail_unless!(is_uppercase('T')); + assert!(!is_uppercase('h')); + assert!(!is_uppercase('ä')); + assert!(!is_uppercase('ß')); + assert!(is_uppercase('Ö')); + assert!(is_uppercase('T')); } #[test] fn test_is_whitespace() { - fail_unless!(is_whitespace(' ')); - fail_unless!(is_whitespace('\u2007')); - fail_unless!(is_whitespace('\t')); - fail_unless!(is_whitespace('\n')); + assert!(is_whitespace(' ')); + assert!(is_whitespace('\u2007')); + assert!(is_whitespace('\t')); + assert!(is_whitespace('\n')); - fail_unless!(!is_whitespace('a')); - fail_unless!(!is_whitespace('_')); - fail_unless!(!is_whitespace('\u0000')); + assert!(!is_whitespace('a')); + assert!(!is_whitespace('_')); + assert!(!is_whitespace('\u0000')); } #[test] @@ -299,24 +299,24 @@ fn test_to_digit() { assert_eq!(to_digit('z', 36u), Some(35u)); assert_eq!(to_digit('Z', 36u), Some(35u)); - fail_unless!(to_digit(' ', 10u).is_none()); - fail_unless!(to_digit('$', 36u).is_none()); + assert!(to_digit(' ', 10u).is_none()); + assert!(to_digit('$', 36u).is_none()); } #[test] fn test_is_ascii() { - fail_unless!(str::all(~"banana", is_ascii)); - fail_unless!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii)); + assert!(str::all(~"banana", is_ascii)); + assert!(! str::all(~"ประเทศไทย中华Việt Nam", is_ascii)); } #[test] fn test_is_digit() { - fail_unless!(is_digit('2')); - fail_unless!(is_digit('7')); - fail_unless!(! is_digit('c')); - fail_unless!(! is_digit('i')); - fail_unless!(! is_digit('z')); - fail_unless!(! is_digit('Q')); + assert!(is_digit('2')); + assert!(is_digit('7')); + assert!(! is_digit('c')); + assert!(! is_digit('i')); + assert!(! is_digit('z')); + assert!(! is_digit('Q')); } #[test] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 95f6f9bc1b510..a928d3bb2af1f 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -177,7 +177,7 @@ mod test { #[test] fn test_int_totaleq() { - fail_unless!(5.equals(&5)); - fail_unless!(!2.equals(&17)); + assert!(5.equals(&5)); + assert!(!2.equals(&17)); } } diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 731ef42599538..9fd6f1db793b0 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -465,6 +465,6 @@ pub mod test { let _chan = chan; } - fail_unless!(!port.peek()); + assert!(!port.peek()); } } diff --git a/src/libcore/condition.rs b/src/libcore/condition.rs index 41504f1a0e109..ed94f2ef2c45c 100644 --- a/src/libcore/condition.rs +++ b/src/libcore/condition.rs @@ -127,7 +127,7 @@ mod test { trouble(1); } - fail_unless!(inner_trapped); + assert!(inner_trapped); } #[test] @@ -143,7 +143,7 @@ mod test { trouble(1); } - fail_unless!(outer_trapped); + assert!(outer_trapped); } fn nested_reraise_trap_test_inner() { @@ -160,7 +160,7 @@ mod test { trouble(1); } - fail_unless!(inner_trapped); + assert!(inner_trapped); } #[test] @@ -175,7 +175,7 @@ mod test { nested_reraise_trap_test_inner(); } - fail_unless!(outer_trapped); + assert!(outer_trapped); } #[test] @@ -190,6 +190,6 @@ mod test { trouble(1); } - fail_unless!(trapped); + assert!(trapped); } } diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index 159a79129ee4c..ee7c1651514fe 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -171,7 +171,7 @@ priv impl DList { // Remove a node from the list. fn unlink(@mut self, nobe: @mut DListNode) { self.assert_mine(nobe); - fail_unless!(self.size > 0); + assert!(self.size > 0); self.link(nobe.prev, nobe.next); nobe.prev = None; // Release extraneous references. nobe.next = None; @@ -193,7 +193,7 @@ priv impl DList { nobe: DListLink, neighbour: @mut DListNode) { self.assert_mine(neighbour); - fail_unless!(self.size > 0); + assert!(self.size > 0); self.link(neighbour.prev, nobe); self.link(nobe, Some(neighbour)); self.size += 1; @@ -202,7 +202,7 @@ priv impl DList { neighbour: @mut DListNode, nobe: DListLink) { self.assert_mine(neighbour); - fail_unless!(self.size > 0); + assert!(self.size > 0); self.link(nobe, neighbour.next); self.link(Some(neighbour), nobe); self.size += 1; @@ -410,7 +410,7 @@ pub impl DList { /// Check data structure integrity. O(n). fn assert_consistent(@mut self) { if self.hd.is_none() || self.tl.is_none() { - fail_unless!(self.hd.is_none() && self.tl.is_none()); + assert!(self.hd.is_none() && self.tl.is_none()); } // iterate forwards let mut count = 0; @@ -418,7 +418,7 @@ pub impl DList { let mut rabbit = link; while link.is_some() { let nobe = link.get(); - fail_unless!(nobe.linked); + assert!(nobe.linked); // check cycle if rabbit.is_some() { rabbit = rabbit.get().next; @@ -427,19 +427,19 @@ pub impl DList { rabbit = rabbit.get().next; } if rabbit.is_some() { - fail_unless!(!managed::mut_ptr_eq(rabbit.get(), nobe)); + assert!(!managed::mut_ptr_eq(rabbit.get(), nobe)); } // advance link = nobe.next_link(); count += 1; } - fail_unless!(count == self.len()); + assert!(count == self.len()); // iterate backwards - some of this is probably redundant. link = self.peek_tail_n(); rabbit = link; while link.is_some() { let nobe = link.get(); - fail_unless!(nobe.linked); + assert!(nobe.linked); // check cycle if rabbit.is_some() { rabbit = rabbit.get().prev; @@ -448,13 +448,13 @@ pub impl DList { rabbit = rabbit.get().prev; } if rabbit.is_some() { - fail_unless!(!managed::mut_ptr_eq(rabbit.get(), nobe)); + assert!(!managed::mut_ptr_eq(rabbit.get(), nobe)); } // advance link = nobe.prev_link(); count -= 1; } - fail_unless!(count == 0); + assert!(count == 0); } } @@ -510,7 +510,7 @@ impl BaseIter for @mut DList { let mut link = self.peek_n(); while link.is_some() { let nobe = link.get(); - fail_unless!(nobe.linked); + assert!(nobe.linked); { let frozen_nobe = &*nobe; @@ -563,7 +563,7 @@ mod tests { abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 6); abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 7); abcd.assert_consistent(); assert_eq!(abcd.pop().get(), 8); - abcd.assert_consistent(); fail_unless!(abcd.is_empty()); + abcd.assert_consistent(); assert!(abcd.is_empty()); } #[test] pub fn test_dlist_append() { @@ -579,7 +579,7 @@ mod tests { a.assert_consistent(); assert_eq!(a.pop().get(), 4); a.assert_consistent(); assert_eq!(a.pop().get(), 5); a.assert_consistent(); assert_eq!(a.pop().get(), 6); - a.assert_consistent(); fail_unless!(a.is_empty()); + a.assert_consistent(); assert!(a.is_empty()); } #[test] pub fn test_dlist_append_empty() { @@ -592,7 +592,7 @@ mod tests { a.assert_consistent(); assert_eq!(a.pop().get(), 1); a.assert_consistent(); assert_eq!(a.pop().get(), 2); a.assert_consistent(); assert_eq!(a.pop().get(), 3); - a.assert_consistent(); fail_unless!(a.is_empty()); + a.assert_consistent(); assert!(a.is_empty()); } #[test] pub fn test_dlist_append_to_empty() { @@ -605,7 +605,7 @@ mod tests { a.assert_consistent(); assert_eq!(a.pop().get(), 4); a.assert_consistent(); assert_eq!(a.pop().get(), 5); a.assert_consistent(); assert_eq!(a.pop().get(), 6); - a.assert_consistent(); fail_unless!(a.is_empty()); + a.assert_consistent(); assert!(a.is_empty()); } #[test] pub fn test_dlist_append_two_empty() { @@ -645,7 +645,7 @@ mod tests { b.assert_consistent(); assert_eq!(b.pop().get(), 4); b.assert_consistent(); assert_eq!(b.pop().get(), 5); b.assert_consistent(); assert_eq!(b.pop().get(), 6); - b.assert_consistent(); fail_unless!(b.is_empty()); + b.assert_consistent(); assert!(b.is_empty()); } #[test] pub fn test_dlist_reverse() { @@ -657,7 +657,7 @@ mod tests { a.assert_consistent(); assert_eq!(a.pop().get(), 3); a.assert_consistent(); assert_eq!(a.pop().get(), 4); a.assert_consistent(); assert_eq!(a.pop().get(), 5); - a.assert_consistent(); fail_unless!(a.is_empty()); + a.assert_consistent(); assert!(a.is_empty()); } #[test] pub fn test_dlist_reverse_empty() { @@ -681,7 +681,7 @@ mod tests { a.assert_consistent(); assert_eq!(a.pop().get(), 4); a.assert_consistent(); assert_eq!(a.pop().get(), 3); a.assert_consistent(); assert_eq!(a.pop().get(), 5); - a.assert_consistent(); fail_unless!(a.is_empty()); + a.assert_consistent(); assert!(a.is_empty()); } #[test] pub fn test_dlist_clear() { @@ -694,8 +694,8 @@ mod tests { pub fn test_dlist_is_empty() { let empty = DList::(); let full1 = from_vec(~[1,2,3]); - fail_unless!(empty.is_empty()); - fail_unless!(!full1.is_empty()); + assert!(empty.is_empty()); + assert!(!full1.is_empty()); } #[test] pub fn test_dlist_head_tail() { @@ -714,8 +714,8 @@ mod tests { assert_eq!(l.tail(), 3); assert_eq!(l.head(), 3); assert_eq!(l.pop().get(), 3); - fail_unless!(l.is_empty()); - fail_unless!(l.pop().is_none()); + assert!(l.is_empty()); + assert!(l.pop().is_none()); } #[test] pub fn test_dlist_pop_tail() { @@ -727,8 +727,8 @@ mod tests { assert_eq!(l.tail(), 1); assert_eq!(l.head(), 1); assert_eq!(l.pop_tail().get(), 1); - fail_unless!(l.is_empty()); - fail_unless!(l.pop_tail().is_none()); + assert!(l.is_empty()); + assert!(l.pop_tail().is_none()); } #[test] pub fn test_dlist_push() { @@ -786,7 +786,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.tail(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 2); l.assert_consistent(); assert_eq!(l.pop().get(), 3); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_mid() { @@ -801,7 +801,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.tail(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 3); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_tail() { @@ -816,7 +816,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.tail(), 2); l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 2); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_one_two() { @@ -832,7 +832,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.head(), 3); l.assert_consistent(); assert_eq!(l.tail(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 3); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_one_three() { @@ -847,7 +847,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.head(), 2); l.assert_consistent(); assert_eq!(l.tail(), 2); l.assert_consistent(); assert_eq!(l.pop().get(), 2); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_two_three() { @@ -862,7 +862,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.head(), 1); l.assert_consistent(); assert_eq!(l.tail(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 1); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_remove_all() { @@ -874,8 +874,8 @@ mod tests { l.assert_consistent(); l.remove(two); l.assert_consistent(); l.remove(three); l.assert_consistent(); l.remove(one); // Twenty-three is number one! - l.assert_consistent(); fail_unless!(l.peek().is_none()); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.peek().is_none()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_insert_n_before() { @@ -891,7 +891,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 2); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_insert_n_after() { @@ -907,7 +907,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 2); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_insert_before_head() { @@ -922,7 +922,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.pop().get(), 3); l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 2); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] pub fn test_dlist_insert_after_tail() { @@ -937,7 +937,7 @@ mod tests { l.assert_consistent(); assert_eq!(l.pop().get(), 1); l.assert_consistent(); assert_eq!(l.pop().get(), 2); l.assert_consistent(); assert_eq!(l.pop().get(), 3); - l.assert_consistent(); fail_unless!(l.is_empty()); + l.assert_consistent(); assert!(l.is_empty()); } #[test] #[should_fail] #[ignore(cfg(windows))] pub fn test_dlist_asymmetric_link() { diff --git a/src/libcore/either.rs b/src/libcore/either.rs index 2af9e91a30fce..92f850cddd6d1 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -176,7 +176,7 @@ fn test_either_left() { let val = Left(10); fn f_left(x: &int) -> bool { *x == 10 } fn f_right(_x: &uint) -> bool { false } - fail_unless!((either(f_left, f_right, &val))); + assert!((either(f_left, f_right, &val))); } #[test] @@ -184,7 +184,7 @@ fn test_either_right() { let val = Right(10u); fn f_left(_x: &int) -> bool { false } fn f_right(x: &uint) -> bool { *x == 10u } - fail_unless!((either(f_left, f_right, &val))); + assert!((either(f_left, f_right, &val))); } #[test] diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs index d1647ea36fd78..a4f12f7da7e2e 100644 --- a/src/libcore/flate.rs +++ b/src/libcore/flate.rs @@ -55,7 +55,7 @@ pub fn deflate_bytes(bytes: &const [u8]) -> ~[u8] { len as size_t, ptr::addr_of(&outsz), lz_norm); - fail_unless!(res as int != 0); + assert!(res as int != 0); let out = vec::raw::from_buf_raw(res as *u8, outsz as uint); libc::free(res); @@ -73,7 +73,7 @@ pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] { len as size_t, ptr::addr_of(&outsz), 0); - fail_unless!(res as int != 0); + assert!(res as int != 0); let out = vec::raw::from_buf_raw(res as *u8, outsz as uint); libc::free(res); @@ -102,6 +102,6 @@ fn test_flate_round_trip() { debug!("%u bytes deflated to %u (%.1f%% size)", in.len(), cmp.len(), 100.0 * ((cmp.len() as float) / (in.len() as float))); - fail_unless!((in == out)); + assert!((in == out)); } } diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs index 10abaf04912cc..d31f35b011508 100644 --- a/src/libcore/hash.rs +++ b/src/libcore/hash.rs @@ -456,7 +456,7 @@ pub fn test_siphash() { let vec = u8to64_le!(vecs[t], 0); let out = buf.hash_keyed(k0, k1); debug!("got %?, expected %?", out, vec); - fail_unless!(vec == out); + assert!(vec == out); stream_full.reset(); stream_full.input(buf); @@ -465,7 +465,7 @@ pub fn test_siphash() { let v = to_hex_str(&vecs[t]); debug!("%d: (%s) => inc=%s full=%s", t, v, i, f); - fail_unless!(f == i && f == v); + assert!(f == i && f == v); buf += ~[t as u8]; stream_inc.input(~[t as u8]); @@ -477,20 +477,20 @@ pub fn test_siphash() { #[test] #[cfg(target_arch = "arm")] pub fn test_hash_uint() { let val = 0xdeadbeef_deadbeef_u64; - fail_unless!((val as u64).hash() != (val as uint).hash()); - fail_unless!((val as u32).hash() == (val as uint).hash()); + assert!((val as u64).hash() != (val as uint).hash()); + assert!((val as u32).hash() == (val as uint).hash()); } #[test] #[cfg(target_arch = "x86_64")] pub fn test_hash_uint() { let val = 0xdeadbeef_deadbeef_u64; - fail_unless!((val as u64).hash() == (val as uint).hash()); - fail_unless!((val as u32).hash() != (val as uint).hash()); + assert!((val as u64).hash() == (val as uint).hash()); + assert!((val as u32).hash() != (val as uint).hash()); } #[test] #[cfg(target_arch = "x86")] pub fn test_hash_uint() { let val = 0xdeadbeef_deadbeef_u64; - fail_unless!((val as u64).hash() != (val as uint).hash()); - fail_unless!((val as u32).hash() == (val as uint).hash()); + assert!((val as u64).hash() != (val as uint).hash()); + assert!((val as u32).hash() == (val as uint).hash()); } #[test] @@ -505,17 +505,17 @@ pub fn test_hash_idempotent() { pub fn test_hash_no_bytes_dropped_64() { let val = 0xdeadbeef_deadbeef_u64; - fail_unless!(val.hash() != zero_byte(val, 0).hash()); - fail_unless!(val.hash() != zero_byte(val, 1).hash()); - fail_unless!(val.hash() != zero_byte(val, 2).hash()); - fail_unless!(val.hash() != zero_byte(val, 3).hash()); - fail_unless!(val.hash() != zero_byte(val, 4).hash()); - fail_unless!(val.hash() != zero_byte(val, 5).hash()); - fail_unless!(val.hash() != zero_byte(val, 6).hash()); - fail_unless!(val.hash() != zero_byte(val, 7).hash()); + assert!(val.hash() != zero_byte(val, 0).hash()); + assert!(val.hash() != zero_byte(val, 1).hash()); + assert!(val.hash() != zero_byte(val, 2).hash()); + assert!(val.hash() != zero_byte(val, 3).hash()); + assert!(val.hash() != zero_byte(val, 4).hash()); + assert!(val.hash() != zero_byte(val, 5).hash()); + assert!(val.hash() != zero_byte(val, 6).hash()); + assert!(val.hash() != zero_byte(val, 7).hash()); fn zero_byte(val: u64, byte: uint) -> u64 { - fail_unless!(byte < 8); + assert!(byte < 8); val & !(0xff << (byte * 8)) } } @@ -524,13 +524,13 @@ pub fn test_hash_no_bytes_dropped_64() { pub fn test_hash_no_bytes_dropped_32() { let val = 0xdeadbeef_u32; - fail_unless!(val.hash() != zero_byte(val, 0).hash()); - fail_unless!(val.hash() != zero_byte(val, 1).hash()); - fail_unless!(val.hash() != zero_byte(val, 2).hash()); - fail_unless!(val.hash() != zero_byte(val, 3).hash()); + assert!(val.hash() != zero_byte(val, 0).hash()); + assert!(val.hash() != zero_byte(val, 1).hash()); + assert!(val.hash() != zero_byte(val, 2).hash()); + assert!(val.hash() != zero_byte(val, 3).hash()); fn zero_byte(val: u32, byte: uint) -> u32 { - fail_unless!(byte < 4); + assert!(byte < 4); val & !(0xff << (byte * 8)) } } diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index 93679e094d9ea..3df48ac70a241 100644 --- a/src/libcore/hashmap.rs +++ b/src/libcore/hashmap.rs @@ -676,18 +676,18 @@ pub mod linear { #[test] pub fn test_insert() { let mut m = LinearMap::new(); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.insert(2, 4)); - fail_unless!(*m.get(&1) == 2); - fail_unless!(*m.get(&2) == 4); + assert!(m.insert(1, 2)); + assert!(m.insert(2, 4)); + assert!(*m.get(&1) == 2); + assert!(*m.get(&2) == 4); } #[test] fn test_find_mut() { let mut m = LinearMap::new(); - fail_unless!(m.insert(1, 12)); - fail_unless!(m.insert(2, 8)); - fail_unless!(m.insert(5, 14)); + assert!(m.insert(1, 12)); + assert!(m.insert(2, 8)); + assert!(m.insert(5, 14)); let new = 100; match m.find_mut(&5) { None => fail!(), Some(x) => *x = new @@ -698,110 +698,110 @@ pub mod linear { #[test] pub fn test_insert_overwrite() { let mut m = LinearMap::new(); - fail_unless!(m.insert(1, 2)); - fail_unless!(*m.get(&1) == 2); - fail_unless!(!m.insert(1, 3)); - fail_unless!(*m.get(&1) == 3); + assert!(m.insert(1, 2)); + assert!(*m.get(&1) == 2); + assert!(!m.insert(1, 3)); + assert!(*m.get(&1) == 3); } #[test] pub fn test_insert_conflicts() { let mut m = linear::linear_map_with_capacity(4); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.insert(5, 3)); - fail_unless!(m.insert(9, 4)); - fail_unless!(*m.get(&9) == 4); - fail_unless!(*m.get(&5) == 3); - fail_unless!(*m.get(&1) == 2); + assert!(m.insert(1, 2)); + assert!(m.insert(5, 3)); + assert!(m.insert(9, 4)); + assert!(*m.get(&9) == 4); + assert!(*m.get(&5) == 3); + assert!(*m.get(&1) == 2); } #[test] pub fn test_conflict_remove() { let mut m = linear::linear_map_with_capacity(4); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.insert(5, 3)); - fail_unless!(m.insert(9, 4)); - fail_unless!(m.remove(&1)); - fail_unless!(*m.get(&9) == 4); - fail_unless!(*m.get(&5) == 3); + assert!(m.insert(1, 2)); + assert!(m.insert(5, 3)); + assert!(m.insert(9, 4)); + assert!(m.remove(&1)); + assert!(*m.get(&9) == 4); + assert!(*m.get(&5) == 3); } #[test] pub fn test_is_empty() { let mut m = linear::linear_map_with_capacity(4); - fail_unless!(m.insert(1, 2)); - fail_unless!(!m.is_empty()); - fail_unless!(m.remove(&1)); - fail_unless!(m.is_empty()); + assert!(m.insert(1, 2)); + assert!(!m.is_empty()); + assert!(m.remove(&1)); + assert!(m.is_empty()); } #[test] pub fn test_pop() { let mut m = LinearMap::new(); m.insert(1, 2); - fail_unless!(m.pop(&1) == Some(2)); - fail_unless!(m.pop(&1) == None); + assert!(m.pop(&1) == Some(2)); + assert!(m.pop(&1) == None); } #[test] pub fn test_swap() { let mut m = LinearMap::new(); - fail_unless!(m.swap(1, 2) == None); - fail_unless!(m.swap(1, 3) == Some(2)); - fail_unless!(m.swap(1, 4) == Some(3)); + assert!(m.swap(1, 2) == None); + assert!(m.swap(1, 3) == Some(2)); + assert!(m.swap(1, 4) == Some(3)); } #[test] pub fn test_find_or_insert() { let mut m = LinearMap::new::(); - fail_unless!(m.find_or_insert(1, 2) == &2); - fail_unless!(m.find_or_insert(1, 3) == &2); + assert!(m.find_or_insert(1, 2) == &2); + assert!(m.find_or_insert(1, 3) == &2); } #[test] pub fn test_find_or_insert_with() { let mut m = LinearMap::new::(); - fail_unless!(m.find_or_insert_with(1, |_| 2) == &2); - fail_unless!(m.find_or_insert_with(1, |_| 3) == &2); + assert!(m.find_or_insert_with(1, |_| 2) == &2); + assert!(m.find_or_insert_with(1, |_| 3) == &2); } #[test] pub fn test_consume() { let mut m = LinearMap::new(); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.insert(2, 3)); + assert!(m.insert(1, 2)); + assert!(m.insert(2, 3)); let mut m2 = LinearMap::new(); do m.consume |k, v| { m2.insert(k, v); } - fail_unless!(m.len() == 0); - fail_unless!(m2.len() == 2); - fail_unless!(m2.get(&1) == &2); - fail_unless!(m2.get(&2) == &3); + assert!(m.len() == 0); + assert!(m2.len() == 2); + assert!(m2.get(&1) == &2); + assert!(m2.get(&2) == &3); } #[test] pub fn test_iterate() { let mut m = linear::linear_map_with_capacity(4); for uint::range(0, 32) |i| { - fail_unless!(m.insert(i, i*2)); + assert!(m.insert(i, i*2)); } let mut observed = 0; for m.each |&(k, v)| { - fail_unless!(*v == *k * 2); + assert!(*v == *k * 2); observed |= (1 << *k); } - fail_unless!(observed == 0xFFFF_FFFF); + assert!(observed == 0xFFFF_FFFF); } #[test] pub fn test_find() { let mut m = LinearMap::new(); - fail_unless!(m.find(&1).is_none()); + assert!(m.find(&1).is_none()); m.insert(1, 2); match m.find(&1) { None => fail!(), - Some(v) => fail_unless!(*v == 2) + Some(v) => assert!(*v == 2) } } @@ -816,19 +816,19 @@ pub mod linear { m2.insert(1, 2); m2.insert(2, 3); - fail_unless!(m1 != m2); + assert!(m1 != m2); m2.insert(3, 4); - fail_unless!(m1 == m2); + assert!(m1 == m2); } #[test] pub fn test_expand() { let mut m = LinearMap::new(); - fail_unless!(m.len() == 0); - fail_unless!(m.is_empty()); + assert!(m.len() == 0); + assert!(m.is_empty()); let mut i = 0u; let old_resize_at = m.resize_at; @@ -837,8 +837,8 @@ pub mod linear { i += 1; } - fail_unless!(m.len() == i); - fail_unless!(!m.is_empty()); + assert!(m.len() == i); + assert!(!m.is_empty()); } } @@ -852,51 +852,51 @@ pub mod linear { fn test_disjoint() { let mut xs = linear::LinearSet::new(); let mut ys = linear::LinearSet::new(); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(xs.insert(5)); - fail_unless!(ys.insert(11)); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(xs.insert(7)); - fail_unless!(xs.insert(19)); - fail_unless!(xs.insert(4)); - fail_unless!(ys.insert(2)); - fail_unless!(ys.insert(-11)); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(ys.insert(7)); - fail_unless!(!xs.is_disjoint(&ys)); - fail_unless!(!ys.is_disjoint(&xs)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(xs.insert(5)); + assert!(ys.insert(11)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(xs.insert(7)); + assert!(xs.insert(19)); + assert!(xs.insert(4)); + assert!(ys.insert(2)); + assert!(ys.insert(-11)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(ys.insert(7)); + assert!(!xs.is_disjoint(&ys)); + assert!(!ys.is_disjoint(&xs)); } #[test] fn test_subset_and_superset() { let mut a = linear::LinearSet::new(); - fail_unless!(a.insert(0)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(7)); + assert!(a.insert(0)); + assert!(a.insert(5)); + assert!(a.insert(11)); + assert!(a.insert(7)); let mut b = linear::LinearSet::new(); - fail_unless!(b.insert(0)); - fail_unless!(b.insert(7)); - fail_unless!(b.insert(19)); - fail_unless!(b.insert(250)); - fail_unless!(b.insert(11)); - fail_unless!(b.insert(200)); + assert!(b.insert(0)); + assert!(b.insert(7)); + assert!(b.insert(19)); + assert!(b.insert(250)); + assert!(b.insert(11)); + assert!(b.insert(200)); - fail_unless!(!a.is_subset(&b)); - fail_unless!(!a.is_superset(&b)); - fail_unless!(!b.is_subset(&a)); - fail_unless!(!b.is_superset(&a)); + assert!(!a.is_subset(&b)); + assert!(!a.is_superset(&b)); + assert!(!b.is_subset(&a)); + assert!(!b.is_superset(&a)); - fail_unless!(b.insert(5)); + assert!(b.insert(5)); - fail_unless!(a.is_subset(&b)); - fail_unless!(!a.is_superset(&b)); - fail_unless!(!b.is_subset(&a)); - fail_unless!(b.is_superset(&a)); + assert!(a.is_subset(&b)); + assert!(!a.is_superset(&b)); + assert!(!b.is_subset(&a)); + assert!(b.is_superset(&a)); } #[test] @@ -904,29 +904,29 @@ pub mod linear { let mut a = linear::LinearSet::new(); let mut b = linear::LinearSet::new(); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(77)); - fail_unless!(a.insert(103)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(-5)); - - fail_unless!(b.insert(2)); - fail_unless!(b.insert(11)); - fail_unless!(b.insert(77)); - fail_unless!(b.insert(-9)); - fail_unless!(b.insert(-42)); - fail_unless!(b.insert(5)); - fail_unless!(b.insert(3)); + assert!(a.insert(11)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(77)); + assert!(a.insert(103)); + assert!(a.insert(5)); + assert!(a.insert(-5)); + + assert!(b.insert(2)); + assert!(b.insert(11)); + assert!(b.insert(77)); + assert!(b.insert(-9)); + assert!(b.insert(-42)); + assert!(b.insert(5)); + assert!(b.insert(3)); let mut i = 0; let expected = [3, 5, 11, 77]; for a.intersection(&b) |x| { - fail_unless!(vec::contains(expected, x)); + assert!(vec::contains(expected, x)); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] @@ -934,22 +934,22 @@ pub mod linear { let mut a = linear::LinearSet::new(); let mut b = linear::LinearSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(9)); - fail_unless!(a.insert(11)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(9)); + assert!(a.insert(11)); - fail_unless!(b.insert(3)); - fail_unless!(b.insert(9)); + assert!(b.insert(3)); + assert!(b.insert(9)); let mut i = 0; let expected = [1, 5, 11]; for a.difference(&b) |x| { - fail_unless!(vec::contains(expected, x)); + assert!(vec::contains(expected, x)); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] @@ -957,25 +957,25 @@ pub mod linear { let mut a = linear::LinearSet::new(); let mut b = linear::LinearSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(9)); - fail_unless!(a.insert(11)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(9)); + assert!(a.insert(11)); - fail_unless!(b.insert(-2)); - fail_unless!(b.insert(3)); - fail_unless!(b.insert(9)); - fail_unless!(b.insert(14)); - fail_unless!(b.insert(22)); + assert!(b.insert(-2)); + assert!(b.insert(3)); + assert!(b.insert(9)); + assert!(b.insert(14)); + assert!(b.insert(22)); let mut i = 0; let expected = [-2, 1, 5, 11, 14, 22]; for a.symmetric_difference(&b) |x| { - fail_unless!(vec::contains(expected, x)); + assert!(vec::contains(expected, x)); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] @@ -983,29 +983,29 @@ pub mod linear { let mut a = linear::LinearSet::new(); let mut b = linear::LinearSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(9)); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(16)); - fail_unless!(a.insert(19)); - fail_unless!(a.insert(24)); - - fail_unless!(b.insert(-2)); - fail_unless!(b.insert(1)); - fail_unless!(b.insert(5)); - fail_unless!(b.insert(9)); - fail_unless!(b.insert(13)); - fail_unless!(b.insert(19)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(9)); + assert!(a.insert(11)); + assert!(a.insert(16)); + assert!(a.insert(19)); + assert!(a.insert(24)); + + assert!(b.insert(-2)); + assert!(b.insert(1)); + assert!(b.insert(5)); + assert!(b.insert(9)); + assert!(b.insert(13)); + assert!(b.insert(19)); let mut i = 0; let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]; for a.union(&b) |x| { - fail_unless!(vec::contains(expected, x)); + assert!(vec::contains(expected, x)); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } } } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index aedbbd6e29828..60a0ee4fa9713 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -252,7 +252,7 @@ impl ReaderUtil for T { let w = str::utf8_char_width(b0); let end = i + w; i += 1; - fail_unless!((w > 0)); + assert!((w > 0)); if w == 1 { chars.push(b0 as char); loop; @@ -265,8 +265,8 @@ impl ReaderUtil for T { while i < end { let next = bytes[i] as int; i += 1; - fail_unless!((next > -1)); - fail_unless!((next & 192 == 128)); + assert!((next > -1)); + assert!((next & 192 == 128)); val <<= 6; val += (next & 63) as uint; } @@ -307,7 +307,7 @@ impl ReaderUtil for T { if vec::len(c) == 0 { return -1 as char; // FIXME will this stay valid? // #2004 } - fail_unless!((vec::len(c) == 1)); + assert!((vec::len(c) == 1)); return c[0]; } @@ -364,7 +364,7 @@ impl ReaderUtil for T { // FIXME int reading methods need to deal with eof - issue #2004 fn read_le_uint_n(&self, nbytes: uint) -> u64 { - fail_unless!(nbytes > 0 && nbytes <= 8); + assert!(nbytes > 0 && nbytes <= 8); let mut val = 0u64, pos = 0, i = nbytes; while i > 0 { @@ -380,7 +380,7 @@ impl ReaderUtil for T { } fn read_be_uint_n(&self, nbytes: uint) -> u64 { - fail_unless!(nbytes > 0 && nbytes <= 8); + assert!(nbytes > 0 && nbytes <= 8); let mut val = 0u64, i = nbytes; while i > 0 { @@ -510,7 +510,7 @@ impl Reader for *libc::FILE { fn read(&self, bytes: &mut [u8], len: uint) -> uint { unsafe { do vec::as_mut_buf(bytes) |buf_p, buf_len| { - fail_unless!(buf_len >= len); + assert!(buf_len >= len); let count = libc::fread(buf_p as *mut c_void, 1u as size_t, len as size_t, *self); @@ -531,7 +531,7 @@ impl Reader for *libc::FILE { } fn seek(&self, offset: int, whence: SeekStyle) { unsafe { - fail_unless!(libc::fseek(*self, + assert!(libc::fseek(*self, offset as c_long, convert_whence(whence)) == 0 as c_int); } @@ -717,7 +717,7 @@ impl Writer for *libc::FILE { } fn seek(&self, offset: int, whence: SeekStyle) { unsafe { - fail_unless!(libc::fseek(*self, + assert!(libc::fseek(*self, offset as c_long, convert_whence(whence)) == 0 as c_int); } @@ -845,7 +845,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag]) pub fn u64_to_le_bytes(n: u64, size: uint, f: &fn(v: &[u8]) -> T) -> T { - fail_unless!(size <= 8u); + assert!(size <= 8u); match size { 1u => f(&[n as u8]), 2u => f(&[n as u8, @@ -877,7 +877,7 @@ pub fn u64_to_le_bytes(n: u64, size: uint, pub fn u64_to_be_bytes(n: u64, size: uint, f: &fn(v: &[u8]) -> T) -> T { - fail_unless!(size <= 8u); + assert!(size <= 8u); match size { 1u => f(&[n as u8]), 2u => f(&[(n >> 8) as u8, @@ -912,7 +912,7 @@ pub fn u64_from_be_bytes(data: &const [u8], size: uint) -> u64 { let mut sz = size; - fail_unless!((sz <= 8u)); + assert!((sz <= 8u)); let mut val = 0_u64; let mut pos = start; while sz > 0u { @@ -1186,7 +1186,7 @@ pub fn with_str_writer(f: &fn(@Writer)) -> ~str { // Make sure the vector has a trailing null and is proper utf8. v.push(0); } - fail_unless!(str::is_utf8(v)); + assert!(str::is_utf8(v)); unsafe { ::cast::transmute(v) } } @@ -1261,7 +1261,7 @@ pub mod fsync { None => (), Some(level) => { // fail hard if not succesful - fail_unless!(((self.arg.fsync_fn)(self.arg.val, level) + assert!(((self.arg.fsync_fn)(self.arg.val, level) != -1)); } } @@ -1346,14 +1346,14 @@ mod tests { let inp: @io::Reader = result::get(&io::file_reader(tmpfile)); let frood2: ~str = inp.read_c_str(); debug!(copy frood2); - fail_unless!(frood == frood2); + assert!(frood == frood2); } #[test] fn test_readchars_empty() { do io::with_str_reader(~"") |inp| { let res : ~[char] = inp.read_chars(128); - fail_unless!((vec::len(res) == 0)); + assert!((vec::len(res) == 0)); } } @@ -1361,22 +1361,22 @@ mod tests { fn test_read_line_utf8() { do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| { let line = inp.read_line(); - fail_unless!(line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤"); + assert!(line == ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤"); } } #[test] fn test_read_lines() { do io::with_str_reader(~"a\nb\nc\n") |inp| { - fail_unless!(inp.read_lines() == ~[~"a", ~"b", ~"c"]); + assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]); } do io::with_str_reader(~"a\nb\nc") |inp| { - fail_unless!(inp.read_lines() == ~[~"a", ~"b", ~"c"]); + assert!(inp.read_lines() == ~[~"a", ~"b", ~"c"]); } do io::with_str_reader(~"") |inp| { - fail_unless!(inp.read_lines().is_empty()); + assert!(inp.read_lines().is_empty()); } } @@ -1393,9 +1393,9 @@ mod tests { do io::with_str_reader(s) |inp| { let res : ~[char] = inp.read_chars(len); if (len <= vec::len(ivals)) { - fail_unless!((vec::len(res) == len)); + assert!((vec::len(res) == len)); } - fail_unless!(vec::slice(ivals, 0u, vec::len(res)) == + assert!(vec::slice(ivals, 0u, vec::len(res)) == vec::map(res, |x| *x as int)); } } @@ -1412,7 +1412,7 @@ mod tests { fn test_readchar() { do io::with_str_reader(~"生") |inp| { let res : char = inp.read_char(); - fail_unless!((res as int == 29983)); + assert!((res as int == 29983)); } } @@ -1420,7 +1420,7 @@ mod tests { fn test_readchar_empty() { do io::with_str_reader(~"") |inp| { let res : char = inp.read_char(); - fail_unless!((res as int == -1)); + assert!((res as int == -1)); } } @@ -1428,7 +1428,7 @@ mod tests { fn file_reader_not_exist() { match io::file_reader(&Path("not a file")) { result::Err(copy e) => { - fail_unless!(e == ~"error opening not a file"); + assert!(e == ~"error opening not a file"); } result::Ok(_) => fail!() } @@ -1469,7 +1469,7 @@ mod tests { fn file_writer_bad_name() { match io::file_writer(&Path("?/?"), ~[]) { result::Err(copy e) => { - fail_unless!(str::starts_with(e, "error opening")); + assert!(str::starts_with(e, "error opening")); } result::Ok(_) => fail!() } @@ -1479,7 +1479,7 @@ mod tests { fn buffered_file_writer_bad_name() { match io::buffered_file_writer(&Path("?/?")) { result::Err(copy e) => { - fail_unless!(str::starts_with(e, "error opening")); + assert!(str::starts_with(e, "error opening")); } result::Ok(_) => fail!() } @@ -1489,15 +1489,15 @@ mod tests { fn bytes_buffer_overwrite() { let wr = BytesWriter(); wr.write(~[0u8, 1u8, 2u8, 3u8]); - fail_unless!(wr.bytes == ~[0u8, 1u8, 2u8, 3u8]); + assert!(wr.bytes == ~[0u8, 1u8, 2u8, 3u8]); wr.seek(-2, SeekCur); wr.write(~[4u8, 5u8, 6u8, 7u8]); - fail_unless!(wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]); + assert!(wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]); wr.seek(-2, SeekEnd); wr.write(~[8u8]); wr.seek(1, SeekSet); wr.write(~[9u8]); - fail_unless!(wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]); + assert!(wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]); } #[test] @@ -1517,7 +1517,7 @@ mod tests { { let file = io::file_reader(&path).get(); for uints.each |i| { - fail_unless!(file.read_le_u64() == *i); + assert!(file.read_le_u64() == *i); } } } @@ -1539,7 +1539,7 @@ mod tests { { let file = io::file_reader(&path).get(); for uints.each |i| { - fail_unless!(file.read_be_u64() == *i); + assert!(file.read_be_u64() == *i); } } } @@ -1563,7 +1563,7 @@ mod tests { for ints.each |i| { // this tests that the sign extension is working // (comparing the values as i32 would not test this) - fail_unless!(file.read_be_int_n(4) == *i as i64); + assert!(file.read_be_int_n(4) == *i as i64); } } } @@ -1582,7 +1582,7 @@ mod tests { { let file = io::file_reader(&path).get(); let f = file.read_be_f32(); - fail_unless!(f == 8.1250); + assert!(f == 8.1250); } } @@ -1599,8 +1599,8 @@ mod tests { { let file = io::file_reader(&path).get(); - fail_unless!(file.read_be_f32() == 8.1250); - fail_unless!(file.read_le_f32() == 8.1250); + assert!(file.read_be_f32() == 8.1250); + assert!(file.read_le_f32() == 8.1250); } } } diff --git a/src/libcore/managed.rs b/src/libcore/managed.rs index 4de9f32e7320e..234b710d238b0 100644 --- a/src/libcore/managed.rs +++ b/src/libcore/managed.rs @@ -91,8 +91,8 @@ impl Ord for @mut T { fn test() { let x = @3; let y = @3; - fail_unless!((ptr_eq::(x, x))); - fail_unless!((ptr_eq::(y, y))); - fail_unless!((!ptr_eq::(x, y))); - fail_unless!((!ptr_eq::(y, x))); + assert!((ptr_eq::(x, x))); + assert!((ptr_eq::(y, y))); + assert!((!ptr_eq::(x, y))); + assert!((!ptr_eq::(y, x))); } diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs index fc4e52891dd26..e9639820e836b 100644 --- a/src/libcore/mutable.rs +++ b/src/libcore/mutable.rs @@ -38,7 +38,7 @@ pub fn Mut(t: T) -> Mut { pub fn unwrap(m: Mut) -> T { // Borrowck should prevent us from calling unwrap while the value // is in use, as that would be a move from a borrowed value. - fail_unless!((m.mode as uint) == (ReadOnly as uint)); + assert!((m.mode as uint) == (ReadOnly as uint)); let Data {value: value, mode: _} = m; value } @@ -103,9 +103,9 @@ pub fn test_const_in_mut() { let m = @Mut(1); do m.borrow_mut |p| { do m.borrow_const |q| { - fail_unless!(*p == *q); + assert!(*p == *q); *p += 1; - fail_unless!(*p == *q); + assert!(*p == *q); } } } @@ -115,9 +115,9 @@ pub fn test_mut_in_const() { let m = @Mut(1); do m.borrow_const |p| { do m.borrow_mut |q| { - fail_unless!(*p == *q); + assert!(*p == *q); *q += 1; - fail_unless!(*p == *q); + assert!(*p == *q); } } } @@ -127,7 +127,7 @@ pub fn test_imm_in_const() { let m = @Mut(1); do m.borrow_const |p| { do m.borrow_imm |q| { - fail_unless!(*p == *q); + assert!(*p == *q); } } } @@ -137,7 +137,7 @@ pub fn test_const_in_imm() { let m = @Mut(1); do m.borrow_imm |p| { do m.borrow_const |q| { - fail_unless!(*p == *q); + assert!(*p == *q); } } } diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 4a8649fb66e78..6361a6a5cb75e 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -585,56 +585,56 @@ pub fn test_num() { let ten: f32 = num::cast(10); let two: f32 = num::cast(2); - fail_unless!((ten.add(&two) == num::cast(12))); - fail_unless!((ten.sub(&two) == num::cast(8))); - fail_unless!((ten.mul(&two) == num::cast(20))); - fail_unless!((ten.div(&two) == num::cast(5))); - fail_unless!((ten.modulo(&two) == num::cast(0))); + assert!((ten.add(&two) == num::cast(12))); + assert!((ten.sub(&two) == num::cast(8))); + assert!((ten.mul(&two) == num::cast(20))); + assert!((ten.div(&two) == num::cast(5))); + assert!((ten.modulo(&two) == num::cast(0))); } #[test] fn test_numcast() { - fail_unless!((20u == 20f32.to_uint())); - fail_unless!((20u8 == 20f32.to_u8())); - fail_unless!((20u16 == 20f32.to_u16())); - fail_unless!((20u32 == 20f32.to_u32())); - fail_unless!((20u64 == 20f32.to_u64())); - fail_unless!((20i == 20f32.to_int())); - fail_unless!((20i8 == 20f32.to_i8())); - fail_unless!((20i16 == 20f32.to_i16())); - fail_unless!((20i32 == 20f32.to_i32())); - fail_unless!((20i64 == 20f32.to_i64())); - fail_unless!((20f == 20f32.to_float())); - fail_unless!((20f32 == 20f32.to_f32())); - fail_unless!((20f64 == 20f32.to_f64())); - - fail_unless!((20f32 == NumCast::from(20u))); - fail_unless!((20f32 == NumCast::from(20u8))); - fail_unless!((20f32 == NumCast::from(20u16))); - fail_unless!((20f32 == NumCast::from(20u32))); - fail_unless!((20f32 == NumCast::from(20u64))); - fail_unless!((20f32 == NumCast::from(20i))); - fail_unless!((20f32 == NumCast::from(20i8))); - fail_unless!((20f32 == NumCast::from(20i16))); - fail_unless!((20f32 == NumCast::from(20i32))); - fail_unless!((20f32 == NumCast::from(20i64))); - fail_unless!((20f32 == NumCast::from(20f))); - fail_unless!((20f32 == NumCast::from(20f32))); - fail_unless!((20f32 == NumCast::from(20f64))); - - fail_unless!((20f32 == num::cast(20u))); - fail_unless!((20f32 == num::cast(20u8))); - fail_unless!((20f32 == num::cast(20u16))); - fail_unless!((20f32 == num::cast(20u32))); - fail_unless!((20f32 == num::cast(20u64))); - fail_unless!((20f32 == num::cast(20i))); - fail_unless!((20f32 == num::cast(20i8))); - fail_unless!((20f32 == num::cast(20i16))); - fail_unless!((20f32 == num::cast(20i32))); - fail_unless!((20f32 == num::cast(20i64))); - fail_unless!((20f32 == num::cast(20f))); - fail_unless!((20f32 == num::cast(20f32))); - fail_unless!((20f32 == num::cast(20f64))); + assert!((20u == 20f32.to_uint())); + assert!((20u8 == 20f32.to_u8())); + assert!((20u16 == 20f32.to_u16())); + assert!((20u32 == 20f32.to_u32())); + assert!((20u64 == 20f32.to_u64())); + assert!((20i == 20f32.to_int())); + assert!((20i8 == 20f32.to_i8())); + assert!((20i16 == 20f32.to_i16())); + assert!((20i32 == 20f32.to_i32())); + assert!((20i64 == 20f32.to_i64())); + assert!((20f == 20f32.to_float())); + assert!((20f32 == 20f32.to_f32())); + assert!((20f64 == 20f32.to_f64())); + + assert!((20f32 == NumCast::from(20u))); + assert!((20f32 == NumCast::from(20u8))); + assert!((20f32 == NumCast::from(20u16))); + assert!((20f32 == NumCast::from(20u32))); + assert!((20f32 == NumCast::from(20u64))); + assert!((20f32 == NumCast::from(20i))); + assert!((20f32 == NumCast::from(20i8))); + assert!((20f32 == NumCast::from(20i16))); + assert!((20f32 == NumCast::from(20i32))); + assert!((20f32 == NumCast::from(20i64))); + assert!((20f32 == NumCast::from(20f))); + assert!((20f32 == NumCast::from(20f32))); + assert!((20f32 == NumCast::from(20f64))); + + assert!((20f32 == num::cast(20u))); + assert!((20f32 == num::cast(20u8))); + assert!((20f32 == num::cast(20u16))); + assert!((20f32 == num::cast(20u32))); + assert!((20f32 == num::cast(20u64))); + assert!((20f32 == num::cast(20i))); + assert!((20f32 == num::cast(20i8))); + assert!((20f32 == num::cast(20i16))); + assert!((20f32 == num::cast(20i32))); + assert!((20f32 == num::cast(20i64))); + assert!((20f32 == num::cast(20f))); + assert!((20f32 == num::cast(20f32))); + assert!((20f32 == num::cast(20f64))); } // diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 8107110e977d8..9e731e61ec49e 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -607,56 +607,56 @@ pub fn test_num() { let ten: f64 = num::cast(10); let two: f64 = num::cast(2); - fail_unless!((ten.add(&two) == num::cast(12))); - fail_unless!((ten.sub(&two) == num::cast(8))); - fail_unless!((ten.mul(&two) == num::cast(20))); - fail_unless!((ten.div(&two) == num::cast(5))); - fail_unless!((ten.modulo(&two) == num::cast(0))); + assert!((ten.add(&two) == num::cast(12))); + assert!((ten.sub(&two) == num::cast(8))); + assert!((ten.mul(&two) == num::cast(20))); + assert!((ten.div(&two) == num::cast(5))); + assert!((ten.modulo(&two) == num::cast(0))); } #[test] fn test_numcast() { - fail_unless!((20u == 20f64.to_uint())); - fail_unless!((20u8 == 20f64.to_u8())); - fail_unless!((20u16 == 20f64.to_u16())); - fail_unless!((20u32 == 20f64.to_u32())); - fail_unless!((20u64 == 20f64.to_u64())); - fail_unless!((20i == 20f64.to_int())); - fail_unless!((20i8 == 20f64.to_i8())); - fail_unless!((20i16 == 20f64.to_i16())); - fail_unless!((20i32 == 20f64.to_i32())); - fail_unless!((20i64 == 20f64.to_i64())); - fail_unless!((20f == 20f64.to_float())); - fail_unless!((20f32 == 20f64.to_f32())); - fail_unless!((20f64 == 20f64.to_f64())); - - fail_unless!((20f64 == NumCast::from(20u))); - fail_unless!((20f64 == NumCast::from(20u8))); - fail_unless!((20f64 == NumCast::from(20u16))); - fail_unless!((20f64 == NumCast::from(20u32))); - fail_unless!((20f64 == NumCast::from(20u64))); - fail_unless!((20f64 == NumCast::from(20i))); - fail_unless!((20f64 == NumCast::from(20i8))); - fail_unless!((20f64 == NumCast::from(20i16))); - fail_unless!((20f64 == NumCast::from(20i32))); - fail_unless!((20f64 == NumCast::from(20i64))); - fail_unless!((20f64 == NumCast::from(20f))); - fail_unless!((20f64 == NumCast::from(20f32))); - fail_unless!((20f64 == NumCast::from(20f64))); - - fail_unless!((20f64 == num::cast(20u))); - fail_unless!((20f64 == num::cast(20u8))); - fail_unless!((20f64 == num::cast(20u16))); - fail_unless!((20f64 == num::cast(20u32))); - fail_unless!((20f64 == num::cast(20u64))); - fail_unless!((20f64 == num::cast(20i))); - fail_unless!((20f64 == num::cast(20i8))); - fail_unless!((20f64 == num::cast(20i16))); - fail_unless!((20f64 == num::cast(20i32))); - fail_unless!((20f64 == num::cast(20i64))); - fail_unless!((20f64 == num::cast(20f))); - fail_unless!((20f64 == num::cast(20f32))); - fail_unless!((20f64 == num::cast(20f64))); + assert!((20u == 20f64.to_uint())); + assert!((20u8 == 20f64.to_u8())); + assert!((20u16 == 20f64.to_u16())); + assert!((20u32 == 20f64.to_u32())); + assert!((20u64 == 20f64.to_u64())); + assert!((20i == 20f64.to_int())); + assert!((20i8 == 20f64.to_i8())); + assert!((20i16 == 20f64.to_i16())); + assert!((20i32 == 20f64.to_i32())); + assert!((20i64 == 20f64.to_i64())); + assert!((20f == 20f64.to_float())); + assert!((20f32 == 20f64.to_f32())); + assert!((20f64 == 20f64.to_f64())); + + assert!((20f64 == NumCast::from(20u))); + assert!((20f64 == NumCast::from(20u8))); + assert!((20f64 == NumCast::from(20u16))); + assert!((20f64 == NumCast::from(20u32))); + assert!((20f64 == NumCast::from(20u64))); + assert!((20f64 == NumCast::from(20i))); + assert!((20f64 == NumCast::from(20i8))); + assert!((20f64 == NumCast::from(20i16))); + assert!((20f64 == NumCast::from(20i32))); + assert!((20f64 == NumCast::from(20i64))); + assert!((20f64 == NumCast::from(20f))); + assert!((20f64 == NumCast::from(20f32))); + assert!((20f64 == NumCast::from(20f64))); + + assert!((20f64 == num::cast(20u))); + assert!((20f64 == num::cast(20u8))); + assert!((20f64 == num::cast(20u16))); + assert!((20f64 == num::cast(20u32))); + assert!((20f64 == num::cast(20u64))); + assert!((20f64 == num::cast(20i))); + assert!((20f64 == num::cast(20i8))); + assert!((20f64 == num::cast(20i16))); + assert!((20f64 == num::cast(20i32))); + assert!((20f64 == num::cast(20i64))); + assert!((20f64 == num::cast(20f))); + assert!((20f64 == num::cast(20f32))); + assert!((20f64 == num::cast(20f64))); } // diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs index 0aec9f08cb4b5..c80d52f496b49 100644 --- a/src/libcore/num/float.rs +++ b/src/libcore/num/float.rs @@ -181,7 +181,7 @@ pub fn to_str_exact(num: float, digits: uint) -> ~str { #[test] pub fn test_to_str_exact_do_decimal() { let s = to_str_exact(5.0, 4u); - fail_unless!(s == ~"5.0000"); + assert!(s == ~"5.0000"); } /** @@ -501,191 +501,191 @@ impl ops::Neg for float { #[test] pub fn test_from_str() { - fail_unless!(from_str(~"3") == Some(3.)); - fail_unless!(from_str(~"3.14") == Some(3.14)); - fail_unless!(from_str(~"+3.14") == Some(3.14)); - fail_unless!(from_str(~"-3.14") == Some(-3.14)); - fail_unless!(from_str(~"2.5E10") == Some(25000000000.)); - fail_unless!(from_str(~"2.5e10") == Some(25000000000.)); - fail_unless!(from_str(~"25000000000.E-10") == Some(2.5)); - fail_unless!(from_str(~".") == Some(0.)); - fail_unless!(from_str(~".e1") == Some(0.)); - fail_unless!(from_str(~".e-1") == Some(0.)); - fail_unless!(from_str(~"5.") == Some(5.)); - fail_unless!(from_str(~".5") == Some(0.5)); - fail_unless!(from_str(~"0.5") == Some(0.5)); - fail_unless!(from_str(~"-.5") == Some(-0.5)); - fail_unless!(from_str(~"-5") == Some(-5.)); - fail_unless!(from_str(~"inf") == Some(infinity)); - fail_unless!(from_str(~"+inf") == Some(infinity)); - fail_unless!(from_str(~"-inf") == Some(neg_infinity)); + assert!(from_str(~"3") == Some(3.)); + assert!(from_str(~"3.14") == Some(3.14)); + assert!(from_str(~"+3.14") == Some(3.14)); + assert!(from_str(~"-3.14") == Some(-3.14)); + assert!(from_str(~"2.5E10") == Some(25000000000.)); + assert!(from_str(~"2.5e10") == Some(25000000000.)); + assert!(from_str(~"25000000000.E-10") == Some(2.5)); + assert!(from_str(~".") == Some(0.)); + assert!(from_str(~".e1") == Some(0.)); + assert!(from_str(~".e-1") == Some(0.)); + assert!(from_str(~"5.") == Some(5.)); + assert!(from_str(~".5") == Some(0.5)); + assert!(from_str(~"0.5") == Some(0.5)); + assert!(from_str(~"-.5") == Some(-0.5)); + assert!(from_str(~"-5") == Some(-5.)); + assert!(from_str(~"inf") == Some(infinity)); + assert!(from_str(~"+inf") == Some(infinity)); + assert!(from_str(~"-inf") == Some(neg_infinity)); // note: NaN != NaN, hence this slightly complex test match from_str(~"NaN") { - Some(f) => fail_unless!(is_NaN(f)), + Some(f) => assert!(is_NaN(f)), None => fail!() } // note: -0 == 0, hence these slightly more complex tests match from_str(~"-0") { - Some(v) if is_zero(v) => fail_unless!(is_negative(v)), + Some(v) if is_zero(v) => assert!(is_negative(v)), _ => fail!() } match from_str(~"0") { - Some(v) if is_zero(v) => fail_unless!(is_positive(v)), + Some(v) if is_zero(v) => assert!(is_positive(v)), _ => fail!() } - fail_unless!(from_str(~"").is_none()); - fail_unless!(from_str(~"x").is_none()); - fail_unless!(from_str(~" ").is_none()); - fail_unless!(from_str(~" ").is_none()); - fail_unless!(from_str(~"e").is_none()); - fail_unless!(from_str(~"E").is_none()); - fail_unless!(from_str(~"E1").is_none()); - fail_unless!(from_str(~"1e1e1").is_none()); - fail_unless!(from_str(~"1e1.1").is_none()); - fail_unless!(from_str(~"1e1-1").is_none()); + assert!(from_str(~"").is_none()); + assert!(from_str(~"x").is_none()); + assert!(from_str(~" ").is_none()); + assert!(from_str(~" ").is_none()); + assert!(from_str(~"e").is_none()); + assert!(from_str(~"E").is_none()); + assert!(from_str(~"E1").is_none()); + assert!(from_str(~"1e1e1").is_none()); + assert!(from_str(~"1e1.1").is_none()); + assert!(from_str(~"1e1-1").is_none()); } #[test] pub fn test_from_str_hex() { - fail_unless!(from_str_hex(~"a4") == Some(164.)); - fail_unless!(from_str_hex(~"a4.fe") == Some(164.9921875)); - fail_unless!(from_str_hex(~"-a4.fe") == Some(-164.9921875)); - fail_unless!(from_str_hex(~"+a4.fe") == Some(164.9921875)); - fail_unless!(from_str_hex(~"ff0P4") == Some(0xff00 as float)); - fail_unless!(from_str_hex(~"ff0p4") == Some(0xff00 as float)); - fail_unless!(from_str_hex(~"ff0p-4") == Some(0xff as float)); - fail_unless!(from_str_hex(~".") == Some(0.)); - fail_unless!(from_str_hex(~".p1") == Some(0.)); - fail_unless!(from_str_hex(~".p-1") == Some(0.)); - fail_unless!(from_str_hex(~"f.") == Some(15.)); - fail_unless!(from_str_hex(~".f") == Some(0.9375)); - fail_unless!(from_str_hex(~"0.f") == Some(0.9375)); - fail_unless!(from_str_hex(~"-.f") == Some(-0.9375)); - fail_unless!(from_str_hex(~"-f") == Some(-15.)); - fail_unless!(from_str_hex(~"inf") == Some(infinity)); - fail_unless!(from_str_hex(~"+inf") == Some(infinity)); - fail_unless!(from_str_hex(~"-inf") == Some(neg_infinity)); + assert!(from_str_hex(~"a4") == Some(164.)); + assert!(from_str_hex(~"a4.fe") == Some(164.9921875)); + assert!(from_str_hex(~"-a4.fe") == Some(-164.9921875)); + assert!(from_str_hex(~"+a4.fe") == Some(164.9921875)); + assert!(from_str_hex(~"ff0P4") == Some(0xff00 as float)); + assert!(from_str_hex(~"ff0p4") == Some(0xff00 as float)); + assert!(from_str_hex(~"ff0p-4") == Some(0xff as float)); + assert!(from_str_hex(~".") == Some(0.)); + assert!(from_str_hex(~".p1") == Some(0.)); + assert!(from_str_hex(~".p-1") == Some(0.)); + assert!(from_str_hex(~"f.") == Some(15.)); + assert!(from_str_hex(~".f") == Some(0.9375)); + assert!(from_str_hex(~"0.f") == Some(0.9375)); + assert!(from_str_hex(~"-.f") == Some(-0.9375)); + assert!(from_str_hex(~"-f") == Some(-15.)); + assert!(from_str_hex(~"inf") == Some(infinity)); + assert!(from_str_hex(~"+inf") == Some(infinity)); + assert!(from_str_hex(~"-inf") == Some(neg_infinity)); // note: NaN != NaN, hence this slightly complex test match from_str_hex(~"NaN") { - Some(f) => fail_unless!(is_NaN(f)), + Some(f) => assert!(is_NaN(f)), None => fail!() } // note: -0 == 0, hence these slightly more complex tests match from_str_hex(~"-0") { - Some(v) if is_zero(v) => fail_unless!(is_negative(v)), + Some(v) if is_zero(v) => assert!(is_negative(v)), _ => fail!() } match from_str_hex(~"0") { - Some(v) if is_zero(v) => fail_unless!(is_positive(v)), + Some(v) if is_zero(v) => assert!(is_positive(v)), _ => fail!() } - fail_unless!(from_str_hex(~"e") == Some(14.)); - fail_unless!(from_str_hex(~"E") == Some(14.)); - fail_unless!(from_str_hex(~"E1") == Some(225.)); - fail_unless!(from_str_hex(~"1e1e1") == Some(123361.)); - fail_unless!(from_str_hex(~"1e1.1") == Some(481.0625)); - - fail_unless!(from_str_hex(~"").is_none()); - fail_unless!(from_str_hex(~"x").is_none()); - fail_unless!(from_str_hex(~" ").is_none()); - fail_unless!(from_str_hex(~" ").is_none()); - fail_unless!(from_str_hex(~"p").is_none()); - fail_unless!(from_str_hex(~"P").is_none()); - fail_unless!(from_str_hex(~"P1").is_none()); - fail_unless!(from_str_hex(~"1p1p1").is_none()); - fail_unless!(from_str_hex(~"1p1.1").is_none()); - fail_unless!(from_str_hex(~"1p1-1").is_none()); + assert!(from_str_hex(~"e") == Some(14.)); + assert!(from_str_hex(~"E") == Some(14.)); + assert!(from_str_hex(~"E1") == Some(225.)); + assert!(from_str_hex(~"1e1e1") == Some(123361.)); + assert!(from_str_hex(~"1e1.1") == Some(481.0625)); + + assert!(from_str_hex(~"").is_none()); + assert!(from_str_hex(~"x").is_none()); + assert!(from_str_hex(~" ").is_none()); + assert!(from_str_hex(~" ").is_none()); + assert!(from_str_hex(~"p").is_none()); + assert!(from_str_hex(~"P").is_none()); + assert!(from_str_hex(~"P1").is_none()); + assert!(from_str_hex(~"1p1p1").is_none()); + assert!(from_str_hex(~"1p1.1").is_none()); + assert!(from_str_hex(~"1p1-1").is_none()); } #[test] pub fn test_to_str_hex() { - fail_unless!(to_str_hex(164.) == ~"a4"); - fail_unless!(to_str_hex(164.9921875) == ~"a4.fe"); - fail_unless!(to_str_hex(-164.9921875) == ~"-a4.fe"); - fail_unless!(to_str_hex(0xff00 as float) == ~"ff00"); - fail_unless!(to_str_hex(-(0xff00 as float)) == ~"-ff00"); - fail_unless!(to_str_hex(0.) == ~"0"); - fail_unless!(to_str_hex(15.) == ~"f"); - fail_unless!(to_str_hex(-15.) == ~"-f"); - fail_unless!(to_str_hex(0.9375) == ~"0.f"); - fail_unless!(to_str_hex(-0.9375) == ~"-0.f"); - fail_unless!(to_str_hex(infinity) == ~"inf"); - fail_unless!(to_str_hex(neg_infinity) == ~"-inf"); - fail_unless!(to_str_hex(NaN) == ~"NaN"); - fail_unless!(to_str_hex(0.) == ~"0"); - fail_unless!(to_str_hex(-0.) == ~"-0"); + assert!(to_str_hex(164.) == ~"a4"); + assert!(to_str_hex(164.9921875) == ~"a4.fe"); + assert!(to_str_hex(-164.9921875) == ~"-a4.fe"); + assert!(to_str_hex(0xff00 as float) == ~"ff00"); + assert!(to_str_hex(-(0xff00 as float)) == ~"-ff00"); + assert!(to_str_hex(0.) == ~"0"); + assert!(to_str_hex(15.) == ~"f"); + assert!(to_str_hex(-15.) == ~"-f"); + assert!(to_str_hex(0.9375) == ~"0.f"); + assert!(to_str_hex(-0.9375) == ~"-0.f"); + assert!(to_str_hex(infinity) == ~"inf"); + assert!(to_str_hex(neg_infinity) == ~"-inf"); + assert!(to_str_hex(NaN) == ~"NaN"); + assert!(to_str_hex(0.) == ~"0"); + assert!(to_str_hex(-0.) == ~"-0"); } #[test] pub fn test_to_str_radix() { - fail_unless!(to_str_radix(36., 36u) == ~"10"); - fail_unless!(to_str_radix(8.125, 2u) == ~"1000.001"); + assert!(to_str_radix(36., 36u) == ~"10"); + assert!(to_str_radix(8.125, 2u) == ~"1000.001"); } #[test] pub fn test_from_str_radix() { - fail_unless!(from_str_radix(~"10", 36u) == Some(36.)); - fail_unless!(from_str_radix(~"1000.001", 2u) == Some(8.125)); + assert!(from_str_radix(~"10", 36u) == Some(36.)); + assert!(from_str_radix(~"1000.001", 2u) == Some(8.125)); } #[test] pub fn test_positive() { - fail_unless!((is_positive(infinity))); - fail_unless!((is_positive(1.))); - fail_unless!((is_positive(0.))); - fail_unless!((!is_positive(-1.))); - fail_unless!((!is_positive(neg_infinity))); - fail_unless!((!is_positive(1./neg_infinity))); - fail_unless!((!is_positive(NaN))); + assert!((is_positive(infinity))); + assert!((is_positive(1.))); + assert!((is_positive(0.))); + assert!((!is_positive(-1.))); + assert!((!is_positive(neg_infinity))); + assert!((!is_positive(1./neg_infinity))); + assert!((!is_positive(NaN))); } #[test] pub fn test_negative() { - fail_unless!((!is_negative(infinity))); - fail_unless!((!is_negative(1.))); - fail_unless!((!is_negative(0.))); - fail_unless!((is_negative(-1.))); - fail_unless!((is_negative(neg_infinity))); - fail_unless!((is_negative(1./neg_infinity))); - fail_unless!((!is_negative(NaN))); + assert!((!is_negative(infinity))); + assert!((!is_negative(1.))); + assert!((!is_negative(0.))); + assert!((is_negative(-1.))); + assert!((is_negative(neg_infinity))); + assert!((is_negative(1./neg_infinity))); + assert!((!is_negative(NaN))); } #[test] pub fn test_nonpositive() { - fail_unless!((!is_nonpositive(infinity))); - fail_unless!((!is_nonpositive(1.))); - fail_unless!((!is_nonpositive(0.))); - fail_unless!((is_nonpositive(-1.))); - fail_unless!((is_nonpositive(neg_infinity))); - fail_unless!((is_nonpositive(1./neg_infinity))); - fail_unless!((!is_nonpositive(NaN))); + assert!((!is_nonpositive(infinity))); + assert!((!is_nonpositive(1.))); + assert!((!is_nonpositive(0.))); + assert!((is_nonpositive(-1.))); + assert!((is_nonpositive(neg_infinity))); + assert!((is_nonpositive(1./neg_infinity))); + assert!((!is_nonpositive(NaN))); } #[test] pub fn test_nonnegative() { - fail_unless!((is_nonnegative(infinity))); - fail_unless!((is_nonnegative(1.))); - fail_unless!((is_nonnegative(0.))); - fail_unless!((!is_nonnegative(-1.))); - fail_unless!((!is_nonnegative(neg_infinity))); - fail_unless!((!is_nonnegative(1./neg_infinity))); - fail_unless!((!is_nonnegative(NaN))); + assert!((is_nonnegative(infinity))); + assert!((is_nonnegative(1.))); + assert!((is_nonnegative(0.))); + assert!((!is_nonnegative(-1.))); + assert!((!is_nonnegative(neg_infinity))); + assert!((!is_nonnegative(1./neg_infinity))); + assert!((!is_nonnegative(NaN))); } #[test] pub fn test_to_str_inf() { - fail_unless!(to_str_digits(infinity, 10u) == ~"inf"); - fail_unless!(to_str_digits(-infinity, 10u) == ~"-inf"); + assert!(to_str_digits(infinity, 10u) == ~"inf"); + assert!(to_str_digits(-infinity, 10u) == ~"-inf"); } #[test] pub fn test_round() { - fail_unless!(round(5.8) == 6.0); - fail_unless!(round(5.2) == 5.0); - fail_unless!(round(3.0) == 3.0); - fail_unless!(round(2.5) == 3.0); - fail_unless!(round(-3.5) == -4.0); + assert!(round(5.8) == 6.0); + assert!(round(5.2) == 5.0); + assert!(round(3.0) == 3.0); + assert!(round(2.5) == 3.0); + assert!(round(-3.5) == -4.0); } #[test] @@ -693,56 +693,56 @@ pub fn test_num() { let ten: float = num::cast(10); let two: float = num::cast(2); - fail_unless!((ten.add(&two) == num::cast(12))); - fail_unless!((ten.sub(&two) == num::cast(8))); - fail_unless!((ten.mul(&two) == num::cast(20))); - fail_unless!((ten.div(&two) == num::cast(5))); - fail_unless!((ten.modulo(&two) == num::cast(0))); + assert!((ten.add(&two) == num::cast(12))); + assert!((ten.sub(&two) == num::cast(8))); + assert!((ten.mul(&two) == num::cast(20))); + assert!((ten.div(&two) == num::cast(5))); + assert!((ten.modulo(&two) == num::cast(0))); } #[test] fn test_numcast() { - fail_unless!((20u == 20f.to_uint())); - fail_unless!((20u8 == 20f.to_u8())); - fail_unless!((20u16 == 20f.to_u16())); - fail_unless!((20u32 == 20f.to_u32())); - fail_unless!((20u64 == 20f.to_u64())); - fail_unless!((20i == 20f.to_int())); - fail_unless!((20i8 == 20f.to_i8())); - fail_unless!((20i16 == 20f.to_i16())); - fail_unless!((20i32 == 20f.to_i32())); - fail_unless!((20i64 == 20f.to_i64())); - fail_unless!((20f == 20f.to_float())); - fail_unless!((20f32 == 20f.to_f32())); - fail_unless!((20f64 == 20f.to_f64())); - - fail_unless!((20f == NumCast::from(20u))); - fail_unless!((20f == NumCast::from(20u8))); - fail_unless!((20f == NumCast::from(20u16))); - fail_unless!((20f == NumCast::from(20u32))); - fail_unless!((20f == NumCast::from(20u64))); - fail_unless!((20f == NumCast::from(20i))); - fail_unless!((20f == NumCast::from(20i8))); - fail_unless!((20f == NumCast::from(20i16))); - fail_unless!((20f == NumCast::from(20i32))); - fail_unless!((20f == NumCast::from(20i64))); - fail_unless!((20f == NumCast::from(20f))); - fail_unless!((20f == NumCast::from(20f32))); - fail_unless!((20f == NumCast::from(20f64))); - - fail_unless!((20f == num::cast(20u))); - fail_unless!((20f == num::cast(20u8))); - fail_unless!((20f == num::cast(20u16))); - fail_unless!((20f == num::cast(20u32))); - fail_unless!((20f == num::cast(20u64))); - fail_unless!((20f == num::cast(20i))); - fail_unless!((20f == num::cast(20i8))); - fail_unless!((20f == num::cast(20i16))); - fail_unless!((20f == num::cast(20i32))); - fail_unless!((20f == num::cast(20i64))); - fail_unless!((20f == num::cast(20f))); - fail_unless!((20f == num::cast(20f32))); - fail_unless!((20f == num::cast(20f64))); + assert!((20u == 20f.to_uint())); + assert!((20u8 == 20f.to_u8())); + assert!((20u16 == 20f.to_u16())); + assert!((20u32 == 20f.to_u32())); + assert!((20u64 == 20f.to_u64())); + assert!((20i == 20f.to_int())); + assert!((20i8 == 20f.to_i8())); + assert!((20i16 == 20f.to_i16())); + assert!((20i32 == 20f.to_i32())); + assert!((20i64 == 20f.to_i64())); + assert!((20f == 20f.to_float())); + assert!((20f32 == 20f.to_f32())); + assert!((20f64 == 20f.to_f64())); + + assert!((20f == NumCast::from(20u))); + assert!((20f == NumCast::from(20u8))); + assert!((20f == NumCast::from(20u16))); + assert!((20f == NumCast::from(20u32))); + assert!((20f == NumCast::from(20u64))); + assert!((20f == NumCast::from(20i))); + assert!((20f == NumCast::from(20i8))); + assert!((20f == NumCast::from(20i16))); + assert!((20f == NumCast::from(20i32))); + assert!((20f == NumCast::from(20i64))); + assert!((20f == NumCast::from(20f))); + assert!((20f == NumCast::from(20f32))); + assert!((20f == NumCast::from(20f64))); + + assert!((20f == num::cast(20u))); + assert!((20f == num::cast(20u8))); + assert!((20f == num::cast(20u16))); + assert!((20f == num::cast(20u32))); + assert!((20f == num::cast(20u64))); + assert!((20f == num::cast(20i))); + assert!((20f == num::cast(20i8))); + assert!((20f == num::cast(20i16))); + assert!((20f == num::cast(20i32))); + assert!((20f == num::cast(20i64))); + assert!((20f == num::cast(20f))); + assert!((20f == num::cast(20f32))); + assert!((20f == num::cast(20f64))); } diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs index af56d3e63051a..a3cbd9fe7e3a4 100644 --- a/src/libcore/num/int-template.rs +++ b/src/libcore/num/int-template.rs @@ -41,18 +41,18 @@ pub fn div(x: T, y: T) -> T { x / y } * * # Examples * ~~~ - * fail_unless!(int::rem(5 / 2) == 1); + * assert!(int::rem(5 / 2) == 1); * ~~~ * * When faced with negative numbers, the result copies the sign of the * dividend. * * ~~~ - * fail_unless!(int::rem(2 / -3) == 2); + * assert!(int::rem(2 / -3) == 2); * ~~~ * * ~~~ - * fail_unless!(int::rem(-2 / 3) == -2); + * assert!(int::rem(-2 / 3) == -2); * ~~~ * */ @@ -95,7 +95,7 @@ pub fn is_nonnegative(x: T) -> bool { x >= 0 as T } * for int::range(1, 5) |i| { * sum += i; * } - * fail_unless!(sum == 10); + * assert!(sum == 10); * ~~~ */ #[inline(always)] @@ -275,122 +275,122 @@ impl ToStrRadix for T { #[test] fn test_from_str() { - fail_unless!(from_str(~"0") == Some(0 as T)); - fail_unless!(from_str(~"3") == Some(3 as T)); - fail_unless!(from_str(~"10") == Some(10 as T)); - fail_unless!(i32::from_str(~"123456789") == Some(123456789 as i32)); - fail_unless!(from_str(~"00100") == Some(100 as T)); + assert!(from_str(~"0") == Some(0 as T)); + assert!(from_str(~"3") == Some(3 as T)); + assert!(from_str(~"10") == Some(10 as T)); + assert!(i32::from_str(~"123456789") == Some(123456789 as i32)); + assert!(from_str(~"00100") == Some(100 as T)); - fail_unless!(from_str(~"-1") == Some(-1 as T)); - fail_unless!(from_str(~"-3") == Some(-3 as T)); - fail_unless!(from_str(~"-10") == Some(-10 as T)); - fail_unless!(i32::from_str(~"-123456789") == Some(-123456789 as i32)); - fail_unless!(from_str(~"-00100") == Some(-100 as T)); + assert!(from_str(~"-1") == Some(-1 as T)); + assert!(from_str(~"-3") == Some(-3 as T)); + assert!(from_str(~"-10") == Some(-10 as T)); + assert!(i32::from_str(~"-123456789") == Some(-123456789 as i32)); + assert!(from_str(~"-00100") == Some(-100 as T)); - fail_unless!(from_str(~" ").is_none()); - fail_unless!(from_str(~"x").is_none()); + assert!(from_str(~" ").is_none()); + assert!(from_str(~"x").is_none()); } #[test] fn test_parse_bytes() { use str::to_bytes; - fail_unless!(parse_bytes(to_bytes(~"123"), 10u) == Some(123 as T)); - fail_unless!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9 as T)); - fail_unless!(parse_bytes(to_bytes(~"123"), 8u) == Some(83 as T)); - fail_unless!(i32::parse_bytes(to_bytes(~"123"), 16u) == Some(291 as i32)); - fail_unless!(i32::parse_bytes(to_bytes(~"ffff"), 16u) == + assert!(parse_bytes(to_bytes(~"123"), 10u) == Some(123 as T)); + assert!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9 as T)); + assert!(parse_bytes(to_bytes(~"123"), 8u) == Some(83 as T)); + assert!(i32::parse_bytes(to_bytes(~"123"), 16u) == Some(291 as i32)); + assert!(i32::parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535 as i32)); - fail_unless!(i32::parse_bytes(to_bytes(~"FFFF"), 16u) == + assert!(i32::parse_bytes(to_bytes(~"FFFF"), 16u) == Some(65535 as i32)); - fail_unless!(parse_bytes(to_bytes(~"z"), 36u) == Some(35 as T)); - fail_unless!(parse_bytes(to_bytes(~"Z"), 36u) == Some(35 as T)); + assert!(parse_bytes(to_bytes(~"z"), 36u) == Some(35 as T)); + assert!(parse_bytes(to_bytes(~"Z"), 36u) == Some(35 as T)); - fail_unless!(parse_bytes(to_bytes(~"-123"), 10u) == Some(-123 as T)); - fail_unless!(parse_bytes(to_bytes(~"-1001"), 2u) == Some(-9 as T)); - fail_unless!(parse_bytes(to_bytes(~"-123"), 8u) == Some(-83 as T)); - fail_unless!(i32::parse_bytes(to_bytes(~"-123"), 16u) == + assert!(parse_bytes(to_bytes(~"-123"), 10u) == Some(-123 as T)); + assert!(parse_bytes(to_bytes(~"-1001"), 2u) == Some(-9 as T)); + assert!(parse_bytes(to_bytes(~"-123"), 8u) == Some(-83 as T)); + assert!(i32::parse_bytes(to_bytes(~"-123"), 16u) == Some(-291 as i32)); - fail_unless!(i32::parse_bytes(to_bytes(~"-ffff"), 16u) == + assert!(i32::parse_bytes(to_bytes(~"-ffff"), 16u) == Some(-65535 as i32)); - fail_unless!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u) == + assert!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u) == Some(-65535 as i32)); - fail_unless!(parse_bytes(to_bytes(~"-z"), 36u) == Some(-35 as T)); - fail_unless!(parse_bytes(to_bytes(~"-Z"), 36u) == Some(-35 as T)); + assert!(parse_bytes(to_bytes(~"-z"), 36u) == Some(-35 as T)); + assert!(parse_bytes(to_bytes(~"-Z"), 36u) == Some(-35 as T)); - fail_unless!(parse_bytes(to_bytes(~"Z"), 35u).is_none()); - fail_unless!(parse_bytes(to_bytes(~"-9"), 2u).is_none()); + assert!(parse_bytes(to_bytes(~"Z"), 35u).is_none()); + assert!(parse_bytes(to_bytes(~"-9"), 2u).is_none()); } #[test] fn test_to_str() { - fail_unless!((to_str_radix(0 as T, 10u) == ~"0")); - fail_unless!((to_str_radix(1 as T, 10u) == ~"1")); - fail_unless!((to_str_radix(-1 as T, 10u) == ~"-1")); - fail_unless!((to_str_radix(127 as T, 16u) == ~"7f")); - fail_unless!((to_str_radix(100 as T, 10u) == ~"100")); + assert!((to_str_radix(0 as T, 10u) == ~"0")); + assert!((to_str_radix(1 as T, 10u) == ~"1")); + assert!((to_str_radix(-1 as T, 10u) == ~"-1")); + assert!((to_str_radix(127 as T, 16u) == ~"7f")); + assert!((to_str_radix(100 as T, 10u) == ~"100")); } #[test] fn test_int_to_str_overflow() { let mut i8_val: i8 = 127_i8; - fail_unless!((i8::to_str(i8_val) == ~"127")); + assert!((i8::to_str(i8_val) == ~"127")); i8_val += 1 as i8; - fail_unless!((i8::to_str(i8_val) == ~"-128")); + assert!((i8::to_str(i8_val) == ~"-128")); let mut i16_val: i16 = 32_767_i16; - fail_unless!((i16::to_str(i16_val) == ~"32767")); + assert!((i16::to_str(i16_val) == ~"32767")); i16_val += 1 as i16; - fail_unless!((i16::to_str(i16_val) == ~"-32768")); + assert!((i16::to_str(i16_val) == ~"-32768")); let mut i32_val: i32 = 2_147_483_647_i32; - fail_unless!((i32::to_str(i32_val) == ~"2147483647")); + assert!((i32::to_str(i32_val) == ~"2147483647")); i32_val += 1 as i32; - fail_unless!((i32::to_str(i32_val) == ~"-2147483648")); + assert!((i32::to_str(i32_val) == ~"-2147483648")); let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; - fail_unless!((i64::to_str(i64_val) == ~"9223372036854775807")); + assert!((i64::to_str(i64_val) == ~"9223372036854775807")); i64_val += 1 as i64; - fail_unless!((i64::to_str(i64_val) == ~"-9223372036854775808")); + assert!((i64::to_str(i64_val) == ~"-9223372036854775808")); } #[test] fn test_int_from_str_overflow() { let mut i8_val: i8 = 127_i8; - fail_unless!((i8::from_str(~"127") == Some(i8_val))); - fail_unless!((i8::from_str(~"128").is_none())); + assert!((i8::from_str(~"127") == Some(i8_val))); + assert!((i8::from_str(~"128").is_none())); i8_val += 1 as i8; - fail_unless!((i8::from_str(~"-128") == Some(i8_val))); - fail_unless!((i8::from_str(~"-129").is_none())); + assert!((i8::from_str(~"-128") == Some(i8_val))); + assert!((i8::from_str(~"-129").is_none())); let mut i16_val: i16 = 32_767_i16; - fail_unless!((i16::from_str(~"32767") == Some(i16_val))); - fail_unless!((i16::from_str(~"32768").is_none())); + assert!((i16::from_str(~"32767") == Some(i16_val))); + assert!((i16::from_str(~"32768").is_none())); i16_val += 1 as i16; - fail_unless!((i16::from_str(~"-32768") == Some(i16_val))); - fail_unless!((i16::from_str(~"-32769").is_none())); + assert!((i16::from_str(~"-32768") == Some(i16_val))); + assert!((i16::from_str(~"-32769").is_none())); let mut i32_val: i32 = 2_147_483_647_i32; - fail_unless!((i32::from_str(~"2147483647") == Some(i32_val))); - fail_unless!((i32::from_str(~"2147483648").is_none())); + assert!((i32::from_str(~"2147483647") == Some(i32_val))); + assert!((i32::from_str(~"2147483648").is_none())); i32_val += 1 as i32; - fail_unless!((i32::from_str(~"-2147483648") == Some(i32_val))); - fail_unless!((i32::from_str(~"-2147483649").is_none())); + assert!((i32::from_str(~"-2147483648") == Some(i32_val))); + assert!((i32::from_str(~"-2147483649").is_none())); let mut i64_val: i64 = 9_223_372_036_854_775_807_i64; - fail_unless!((i64::from_str(~"9223372036854775807") == Some(i64_val))); - fail_unless!((i64::from_str(~"9223372036854775808").is_none())); + assert!((i64::from_str(~"9223372036854775807") == Some(i64_val))); + assert!((i64::from_str(~"9223372036854775808").is_none())); i64_val += 1 as i64; - fail_unless!((i64::from_str(~"-9223372036854775808") == Some(i64_val))); - fail_unless!((i64::from_str(~"-9223372036854775809").is_none())); + assert!((i64::from_str(~"-9223372036854775808") == Some(i64_val))); + assert!((i64::from_str(~"-9223372036854775809").is_none())); } #[test] @@ -398,11 +398,11 @@ pub fn test_num() { let ten: T = num::cast(10); let two: T = num::cast(2); - fail_unless!((ten.add(&two) == num::cast(12))); - fail_unless!((ten.sub(&two) == num::cast(8))); - fail_unless!((ten.mul(&two) == num::cast(20))); - fail_unless!((ten.div(&two) == num::cast(5))); - fail_unless!((ten.modulo(&two) == num::cast(0))); + assert!((ten.add(&two) == num::cast(12))); + assert!((ten.sub(&two) == num::cast(8))); + assert!((ten.mul(&two) == num::cast(20))); + assert!((ten.div(&two) == num::cast(5))); + assert!((ten.modulo(&two) == num::cast(0))); } #[test] @@ -421,7 +421,7 @@ pub fn test_ranges() { for range_step(36,30,-2) |i| { l.push(i); } - fail_unless!(l == ~[0,1,2, + assert!(l == ~[0,1,2, 13,12,11, 20,22,24, 36,34,32]); diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs index 965b6f86a53d6..76be224af15b9 100644 --- a/src/libcore/num/int-template/i16.rs +++ b/src/libcore/num/int-template/i16.rs @@ -43,45 +43,45 @@ impl NumCast for i16 { #[test] fn test_numcast() { - fail_unless!((20u == 20i16.to_uint())); - fail_unless!((20u8 == 20i16.to_u8())); - fail_unless!((20u16 == 20i16.to_u16())); - fail_unless!((20u32 == 20i16.to_u32())); - fail_unless!((20u64 == 20i16.to_u64())); - fail_unless!((20i == 20i16.to_int())); - fail_unless!((20i8 == 20i16.to_i8())); - fail_unless!((20i16 == 20i16.to_i16())); - fail_unless!((20i32 == 20i16.to_i32())); - fail_unless!((20i64 == 20i16.to_i64())); - fail_unless!((20f == 20i16.to_float())); - fail_unless!((20f32 == 20i16.to_f32())); - fail_unless!((20f64 == 20i16.to_f64())); + assert!((20u == 20i16.to_uint())); + assert!((20u8 == 20i16.to_u8())); + assert!((20u16 == 20i16.to_u16())); + assert!((20u32 == 20i16.to_u32())); + assert!((20u64 == 20i16.to_u64())); + assert!((20i == 20i16.to_int())); + assert!((20i8 == 20i16.to_i8())); + assert!((20i16 == 20i16.to_i16())); + assert!((20i32 == 20i16.to_i32())); + assert!((20i64 == 20i16.to_i64())); + assert!((20f == 20i16.to_float())); + assert!((20f32 == 20i16.to_f32())); + assert!((20f64 == 20i16.to_f64())); - fail_unless!((20i16 == NumCast::from(20u))); - fail_unless!((20i16 == NumCast::from(20u8))); - fail_unless!((20i16 == NumCast::from(20u16))); - fail_unless!((20i16 == NumCast::from(20u32))); - fail_unless!((20i16 == NumCast::from(20u64))); - fail_unless!((20i16 == NumCast::from(20i))); - fail_unless!((20i16 == NumCast::from(20i8))); - fail_unless!((20i16 == NumCast::from(20i16))); - fail_unless!((20i16 == NumCast::from(20i32))); - fail_unless!((20i16 == NumCast::from(20i64))); - fail_unless!((20i16 == NumCast::from(20f))); - fail_unless!((20i16 == NumCast::from(20f32))); - fail_unless!((20i16 == NumCast::from(20f64))); + assert!((20i16 == NumCast::from(20u))); + assert!((20i16 == NumCast::from(20u8))); + assert!((20i16 == NumCast::from(20u16))); + assert!((20i16 == NumCast::from(20u32))); + assert!((20i16 == NumCast::from(20u64))); + assert!((20i16 == NumCast::from(20i))); + assert!((20i16 == NumCast::from(20i8))); + assert!((20i16 == NumCast::from(20i16))); + assert!((20i16 == NumCast::from(20i32))); + assert!((20i16 == NumCast::from(20i64))); + assert!((20i16 == NumCast::from(20f))); + assert!((20i16 == NumCast::from(20f32))); + assert!((20i16 == NumCast::from(20f64))); - fail_unless!((20i16 == num::cast(20u))); - fail_unless!((20i16 == num::cast(20u8))); - fail_unless!((20i16 == num::cast(20u16))); - fail_unless!((20i16 == num::cast(20u32))); - fail_unless!((20i16 == num::cast(20u64))); - fail_unless!((20i16 == num::cast(20i))); - fail_unless!((20i16 == num::cast(20i8))); - fail_unless!((20i16 == num::cast(20i16))); - fail_unless!((20i16 == num::cast(20i32))); - fail_unless!((20i16 == num::cast(20i64))); - fail_unless!((20i16 == num::cast(20f))); - fail_unless!((20i16 == num::cast(20f32))); - fail_unless!((20i16 == num::cast(20f64))); + assert!((20i16 == num::cast(20u))); + assert!((20i16 == num::cast(20u8))); + assert!((20i16 == num::cast(20u16))); + assert!((20i16 == num::cast(20u32))); + assert!((20i16 == num::cast(20u64))); + assert!((20i16 == num::cast(20i))); + assert!((20i16 == num::cast(20i8))); + assert!((20i16 == num::cast(20i16))); + assert!((20i16 == num::cast(20i32))); + assert!((20i16 == num::cast(20i64))); + assert!((20i16 == num::cast(20f))); + assert!((20i16 == num::cast(20f32))); + assert!((20i16 == num::cast(20f64))); } diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs index 030bc9c3fdefe..596d29aa2910a 100644 --- a/src/libcore/num/int-template/i32.rs +++ b/src/libcore/num/int-template/i32.rs @@ -43,45 +43,45 @@ impl NumCast for i32 { #[test] fn test_numcast() { - fail_unless!((20u == 20i32.to_uint())); - fail_unless!((20u8 == 20i32.to_u8())); - fail_unless!((20u16 == 20i32.to_u16())); - fail_unless!((20u32 == 20i32.to_u32())); - fail_unless!((20u64 == 20i32.to_u64())); - fail_unless!((20i == 20i32.to_int())); - fail_unless!((20i8 == 20i32.to_i8())); - fail_unless!((20i16 == 20i32.to_i16())); - fail_unless!((20i32 == 20i32.to_i32())); - fail_unless!((20i64 == 20i32.to_i64())); - fail_unless!((20f == 20i32.to_float())); - fail_unless!((20f32 == 20i32.to_f32())); - fail_unless!((20f64 == 20i32.to_f64())); + assert!((20u == 20i32.to_uint())); + assert!((20u8 == 20i32.to_u8())); + assert!((20u16 == 20i32.to_u16())); + assert!((20u32 == 20i32.to_u32())); + assert!((20u64 == 20i32.to_u64())); + assert!((20i == 20i32.to_int())); + assert!((20i8 == 20i32.to_i8())); + assert!((20i16 == 20i32.to_i16())); + assert!((20i32 == 20i32.to_i32())); + assert!((20i64 == 20i32.to_i64())); + assert!((20f == 20i32.to_float())); + assert!((20f32 == 20i32.to_f32())); + assert!((20f64 == 20i32.to_f64())); - fail_unless!((20i32 == NumCast::from(20u))); - fail_unless!((20i32 == NumCast::from(20u8))); - fail_unless!((20i32 == NumCast::from(20u16))); - fail_unless!((20i32 == NumCast::from(20u32))); - fail_unless!((20i32 == NumCast::from(20u64))); - fail_unless!((20i32 == NumCast::from(20i))); - fail_unless!((20i32 == NumCast::from(20i8))); - fail_unless!((20i32 == NumCast::from(20i16))); - fail_unless!((20i32 == NumCast::from(20i32))); - fail_unless!((20i32 == NumCast::from(20i64))); - fail_unless!((20i32 == NumCast::from(20f))); - fail_unless!((20i32 == NumCast::from(20f32))); - fail_unless!((20i32 == NumCast::from(20f64))); + assert!((20i32 == NumCast::from(20u))); + assert!((20i32 == NumCast::from(20u8))); + assert!((20i32 == NumCast::from(20u16))); + assert!((20i32 == NumCast::from(20u32))); + assert!((20i32 == NumCast::from(20u64))); + assert!((20i32 == NumCast::from(20i))); + assert!((20i32 == NumCast::from(20i8))); + assert!((20i32 == NumCast::from(20i16))); + assert!((20i32 == NumCast::from(20i32))); + assert!((20i32 == NumCast::from(20i64))); + assert!((20i32 == NumCast::from(20f))); + assert!((20i32 == NumCast::from(20f32))); + assert!((20i32 == NumCast::from(20f64))); - fail_unless!((20i32 == num::cast(20u))); - fail_unless!((20i32 == num::cast(20u8))); - fail_unless!((20i32 == num::cast(20u16))); - fail_unless!((20i32 == num::cast(20u32))); - fail_unless!((20i32 == num::cast(20u64))); - fail_unless!((20i32 == num::cast(20i))); - fail_unless!((20i32 == num::cast(20i8))); - fail_unless!((20i32 == num::cast(20i16))); - fail_unless!((20i32 == num::cast(20i32))); - fail_unless!((20i32 == num::cast(20i64))); - fail_unless!((20i32 == num::cast(20f))); - fail_unless!((20i32 == num::cast(20f32))); - fail_unless!((20i32 == num::cast(20f64))); + assert!((20i32 == num::cast(20u))); + assert!((20i32 == num::cast(20u8))); + assert!((20i32 == num::cast(20u16))); + assert!((20i32 == num::cast(20u32))); + assert!((20i32 == num::cast(20u64))); + assert!((20i32 == num::cast(20i))); + assert!((20i32 == num::cast(20i8))); + assert!((20i32 == num::cast(20i16))); + assert!((20i32 == num::cast(20i32))); + assert!((20i32 == num::cast(20i64))); + assert!((20i32 == num::cast(20f))); + assert!((20i32 == num::cast(20f32))); + assert!((20i32 == num::cast(20f64))); } diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs index 283de94e9d80e..d02c46d939310 100644 --- a/src/libcore/num/int-template/i64.rs +++ b/src/libcore/num/int-template/i64.rs @@ -43,45 +43,45 @@ impl NumCast for i64 { #[test] fn test_numcast() { - fail_unless!((20u == 20i64.to_uint())); - fail_unless!((20u8 == 20i64.to_u8())); - fail_unless!((20u16 == 20i64.to_u16())); - fail_unless!((20u32 == 20i64.to_u32())); - fail_unless!((20u64 == 20i64.to_u64())); - fail_unless!((20i == 20i64.to_int())); - fail_unless!((20i8 == 20i64.to_i8())); - fail_unless!((20i16 == 20i64.to_i16())); - fail_unless!((20i32 == 20i64.to_i32())); - fail_unless!((20i64 == 20i64.to_i64())); - fail_unless!((20f == 20i64.to_float())); - fail_unless!((20f32 == 20i64.to_f32())); - fail_unless!((20f64 == 20i64.to_f64())); + assert!((20u == 20i64.to_uint())); + assert!((20u8 == 20i64.to_u8())); + assert!((20u16 == 20i64.to_u16())); + assert!((20u32 == 20i64.to_u32())); + assert!((20u64 == 20i64.to_u64())); + assert!((20i == 20i64.to_int())); + assert!((20i8 == 20i64.to_i8())); + assert!((20i16 == 20i64.to_i16())); + assert!((20i32 == 20i64.to_i32())); + assert!((20i64 == 20i64.to_i64())); + assert!((20f == 20i64.to_float())); + assert!((20f32 == 20i64.to_f32())); + assert!((20f64 == 20i64.to_f64())); - fail_unless!((20i64 == NumCast::from(20u))); - fail_unless!((20i64 == NumCast::from(20u8))); - fail_unless!((20i64 == NumCast::from(20u16))); - fail_unless!((20i64 == NumCast::from(20u32))); - fail_unless!((20i64 == NumCast::from(20u64))); - fail_unless!((20i64 == NumCast::from(20i))); - fail_unless!((20i64 == NumCast::from(20i8))); - fail_unless!((20i64 == NumCast::from(20i16))); - fail_unless!((20i64 == NumCast::from(20i32))); - fail_unless!((20i64 == NumCast::from(20i64))); - fail_unless!((20i64 == NumCast::from(20f))); - fail_unless!((20i64 == NumCast::from(20f32))); - fail_unless!((20i64 == NumCast::from(20f64))); + assert!((20i64 == NumCast::from(20u))); + assert!((20i64 == NumCast::from(20u8))); + assert!((20i64 == NumCast::from(20u16))); + assert!((20i64 == NumCast::from(20u32))); + assert!((20i64 == NumCast::from(20u64))); + assert!((20i64 == NumCast::from(20i))); + assert!((20i64 == NumCast::from(20i8))); + assert!((20i64 == NumCast::from(20i16))); + assert!((20i64 == NumCast::from(20i32))); + assert!((20i64 == NumCast::from(20i64))); + assert!((20i64 == NumCast::from(20f))); + assert!((20i64 == NumCast::from(20f32))); + assert!((20i64 == NumCast::from(20f64))); - fail_unless!((20i64 == num::cast(20u))); - fail_unless!((20i64 == num::cast(20u8))); - fail_unless!((20i64 == num::cast(20u16))); - fail_unless!((20i64 == num::cast(20u32))); - fail_unless!((20i64 == num::cast(20u64))); - fail_unless!((20i64 == num::cast(20i))); - fail_unless!((20i64 == num::cast(20i8))); - fail_unless!((20i64 == num::cast(20i16))); - fail_unless!((20i64 == num::cast(20i32))); - fail_unless!((20i64 == num::cast(20i64))); - fail_unless!((20i64 == num::cast(20f))); - fail_unless!((20i64 == num::cast(20f32))); - fail_unless!((20i64 == num::cast(20f64))); + assert!((20i64 == num::cast(20u))); + assert!((20i64 == num::cast(20u8))); + assert!((20i64 == num::cast(20u16))); + assert!((20i64 == num::cast(20u32))); + assert!((20i64 == num::cast(20u64))); + assert!((20i64 == num::cast(20i))); + assert!((20i64 == num::cast(20i8))); + assert!((20i64 == num::cast(20i16))); + assert!((20i64 == num::cast(20i32))); + assert!((20i64 == num::cast(20i64))); + assert!((20i64 == num::cast(20f))); + assert!((20i64 == num::cast(20f32))); + assert!((20i64 == num::cast(20f64))); } diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs index 2f2de358337b7..c0dd6e01d4b7f 100644 --- a/src/libcore/num/int-template/i8.rs +++ b/src/libcore/num/int-template/i8.rs @@ -43,45 +43,45 @@ impl NumCast for i8 { #[test] fn test_numcast() { - fail_unless!((20u == 20i8.to_uint())); - fail_unless!((20u8 == 20i8.to_u8())); - fail_unless!((20u16 == 20i8.to_u16())); - fail_unless!((20u32 == 20i8.to_u32())); - fail_unless!((20u64 == 20i8.to_u64())); - fail_unless!((20i == 20i8.to_int())); - fail_unless!((20i8 == 20i8.to_i8())); - fail_unless!((20i16 == 20i8.to_i16())); - fail_unless!((20i32 == 20i8.to_i32())); - fail_unless!((20i64 == 20i8.to_i64())); - fail_unless!((20f == 20i8.to_float())); - fail_unless!((20f32 == 20i8.to_f32())); - fail_unless!((20f64 == 20i8.to_f64())); + assert!((20u == 20i8.to_uint())); + assert!((20u8 == 20i8.to_u8())); + assert!((20u16 == 20i8.to_u16())); + assert!((20u32 == 20i8.to_u32())); + assert!((20u64 == 20i8.to_u64())); + assert!((20i == 20i8.to_int())); + assert!((20i8 == 20i8.to_i8())); + assert!((20i16 == 20i8.to_i16())); + assert!((20i32 == 20i8.to_i32())); + assert!((20i64 == 20i8.to_i64())); + assert!((20f == 20i8.to_float())); + assert!((20f32 == 20i8.to_f32())); + assert!((20f64 == 20i8.to_f64())); - fail_unless!((20i8 == NumCast::from(20u))); - fail_unless!((20i8 == NumCast::from(20u8))); - fail_unless!((20i8 == NumCast::from(20u16))); - fail_unless!((20i8 == NumCast::from(20u32))); - fail_unless!((20i8 == NumCast::from(20u64))); - fail_unless!((20i8 == NumCast::from(20i))); - fail_unless!((20i8 == NumCast::from(20i8))); - fail_unless!((20i8 == NumCast::from(20i16))); - fail_unless!((20i8 == NumCast::from(20i32))); - fail_unless!((20i8 == NumCast::from(20i64))); - fail_unless!((20i8 == NumCast::from(20f))); - fail_unless!((20i8 == NumCast::from(20f32))); - fail_unless!((20i8 == NumCast::from(20f64))); + assert!((20i8 == NumCast::from(20u))); + assert!((20i8 == NumCast::from(20u8))); + assert!((20i8 == NumCast::from(20u16))); + assert!((20i8 == NumCast::from(20u32))); + assert!((20i8 == NumCast::from(20u64))); + assert!((20i8 == NumCast::from(20i))); + assert!((20i8 == NumCast::from(20i8))); + assert!((20i8 == NumCast::from(20i16))); + assert!((20i8 == NumCast::from(20i32))); + assert!((20i8 == NumCast::from(20i64))); + assert!((20i8 == NumCast::from(20f))); + assert!((20i8 == NumCast::from(20f32))); + assert!((20i8 == NumCast::from(20f64))); - fail_unless!((20i8 == num::cast(20u))); - fail_unless!((20i8 == num::cast(20u8))); - fail_unless!((20i8 == num::cast(20u16))); - fail_unless!((20i8 == num::cast(20u32))); - fail_unless!((20i8 == num::cast(20u64))); - fail_unless!((20i8 == num::cast(20i))); - fail_unless!((20i8 == num::cast(20i8))); - fail_unless!((20i8 == num::cast(20i16))); - fail_unless!((20i8 == num::cast(20i32))); - fail_unless!((20i8 == num::cast(20i64))); - fail_unless!((20i8 == num::cast(20f))); - fail_unless!((20i8 == num::cast(20f32))); - fail_unless!((20i8 == num::cast(20f64))); + assert!((20i8 == num::cast(20u))); + assert!((20i8 == num::cast(20u8))); + assert!((20i8 == num::cast(20u16))); + assert!((20i8 == num::cast(20u32))); + assert!((20i8 == num::cast(20u64))); + assert!((20i8 == num::cast(20i))); + assert!((20i8 == num::cast(20i8))); + assert!((20i8 == num::cast(20i16))); + assert!((20i8 == num::cast(20i32))); + assert!((20i8 == num::cast(20i64))); + assert!((20i8 == num::cast(20f))); + assert!((20i8 == num::cast(20f32))); + assert!((20i8 == num::cast(20f64))); } diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs index 3c89492c7e48e..ea8aec1222438 100644 --- a/src/libcore/num/int-template/int.rs +++ b/src/libcore/num/int-template/int.rs @@ -40,21 +40,21 @@ mod inst { #[test] fn test_pow() { - fail_unless!((pow(0, 0u) == 1)); - fail_unless!((pow(0, 1u) == 0)); - fail_unless!((pow(0, 2u) == 0)); - fail_unless!((pow(-1, 0u) == 1)); - fail_unless!((pow(1, 0u) == 1)); - fail_unless!((pow(-3, 2u) == 9)); - fail_unless!((pow(-3, 3u) == -27)); - fail_unless!((pow(4, 9u) == 262144)); + assert!((pow(0, 0u) == 1)); + assert!((pow(0, 1u) == 0)); + assert!((pow(0, 2u) == 0)); + assert!((pow(-1, 0u) == 1)); + assert!((pow(1, 0u) == 1)); + assert!((pow(-3, 2u) == 9)); + assert!((pow(-3, 3u) == -27)); + assert!((pow(4, 9u) == 262144)); } #[test] fn test_overflows() { - fail_unless!((::int::max_value > 0)); - fail_unless!((::int::min_value <= 0)); - fail_unless!((::int::min_value + ::int::max_value + 1 == 0)); + assert!((::int::max_value > 0)); + assert!((::int::min_value <= 0)); + assert!((::int::min_value + ::int::max_value + 1 == 0)); } } @@ -84,45 +84,45 @@ impl NumCast for int { #[test] fn test_numcast() { - fail_unless!((20u == 20i.to_uint())); - fail_unless!((20u8 == 20i.to_u8())); - fail_unless!((20u16 == 20i.to_u16())); - fail_unless!((20u32 == 20i.to_u32())); - fail_unless!((20u64 == 20i.to_u64())); - fail_unless!((20i == 20i.to_int())); - fail_unless!((20i8 == 20i.to_i8())); - fail_unless!((20i16 == 20i.to_i16())); - fail_unless!((20i32 == 20i.to_i32())); - fail_unless!((20i64 == 20i.to_i64())); - fail_unless!((20f == 20i.to_float())); - fail_unless!((20f32 == 20i.to_f32())); - fail_unless!((20f64 == 20i.to_f64())); + assert!((20u == 20i.to_uint())); + assert!((20u8 == 20i.to_u8())); + assert!((20u16 == 20i.to_u16())); + assert!((20u32 == 20i.to_u32())); + assert!((20u64 == 20i.to_u64())); + assert!((20i == 20i.to_int())); + assert!((20i8 == 20i.to_i8())); + assert!((20i16 == 20i.to_i16())); + assert!((20i32 == 20i.to_i32())); + assert!((20i64 == 20i.to_i64())); + assert!((20f == 20i.to_float())); + assert!((20f32 == 20i.to_f32())); + assert!((20f64 == 20i.to_f64())); - fail_unless!((20i == NumCast::from(20u))); - fail_unless!((20i == NumCast::from(20u8))); - fail_unless!((20i == NumCast::from(20u16))); - fail_unless!((20i == NumCast::from(20u32))); - fail_unless!((20i == NumCast::from(20u64))); - fail_unless!((20i == NumCast::from(20i))); - fail_unless!((20i == NumCast::from(20i8))); - fail_unless!((20i == NumCast::from(20i16))); - fail_unless!((20i == NumCast::from(20i32))); - fail_unless!((20i == NumCast::from(20i64))); - fail_unless!((20i == NumCast::from(20f))); - fail_unless!((20i == NumCast::from(20f32))); - fail_unless!((20i == NumCast::from(20f64))); + assert!((20i == NumCast::from(20u))); + assert!((20i == NumCast::from(20u8))); + assert!((20i == NumCast::from(20u16))); + assert!((20i == NumCast::from(20u32))); + assert!((20i == NumCast::from(20u64))); + assert!((20i == NumCast::from(20i))); + assert!((20i == NumCast::from(20i8))); + assert!((20i == NumCast::from(20i16))); + assert!((20i == NumCast::from(20i32))); + assert!((20i == NumCast::from(20i64))); + assert!((20i == NumCast::from(20f))); + assert!((20i == NumCast::from(20f32))); + assert!((20i == NumCast::from(20f64))); - fail_unless!((20i == num::cast(20u))); - fail_unless!((20i == num::cast(20u8))); - fail_unless!((20i == num::cast(20u16))); - fail_unless!((20i == num::cast(20u32))); - fail_unless!((20i == num::cast(20u64))); - fail_unless!((20i == num::cast(20i))); - fail_unless!((20i == num::cast(20i8))); - fail_unless!((20i == num::cast(20i16))); - fail_unless!((20i == num::cast(20i32))); - fail_unless!((20i == num::cast(20i64))); - fail_unless!((20i == num::cast(20f))); - fail_unless!((20i == num::cast(20f32))); - fail_unless!((20i == num::cast(20f64))); + assert!((20i == num::cast(20u))); + assert!((20i == num::cast(20u8))); + assert!((20i == num::cast(20u16))); + assert!((20i == num::cast(20u32))); + assert!((20i == num::cast(20u64))); + assert!((20i == num::cast(20i))); + assert!((20i == num::cast(20i8))); + assert!((20i == num::cast(20i16))); + assert!((20i == num::cast(20i32))); + assert!((20i == num::cast(20i64))); + assert!((20i == num::cast(20f))); + assert!((20i == num::cast(20f32))); + assert!((20i == num::cast(20f64))); } diff --git a/src/libcore/num/num.rs b/src/libcore/num/num.rs index 0fe96c8b3442e..daa36f9dc32f5 100644 --- a/src/libcore/num/num.rs +++ b/src/libcore/num/num.rs @@ -55,7 +55,7 @@ pub enum RoundMode { * * ~~~ * let twenty: f32 = num::cast(0x14); - * fail_unless!(twenty == 20f32); + * assert!(twenty == 20f32); * ~~~ */ #[inline(always)] diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs index 410799f43ce87..400417284a279 100644 --- a/src/libcore/num/uint-template.rs +++ b/src/libcore/num/uint-template.rs @@ -241,104 +241,104 @@ impl ToStrRadix for T { #[test] pub fn test_to_str() { - fail_unless!(to_str_radix(0 as T, 10u) == ~"0"); - fail_unless!(to_str_radix(1 as T, 10u) == ~"1"); - fail_unless!(to_str_radix(2 as T, 10u) == ~"2"); - fail_unless!(to_str_radix(11 as T, 10u) == ~"11"); - fail_unless!(to_str_radix(11 as T, 16u) == ~"b"); - fail_unless!(to_str_radix(255 as T, 16u) == ~"ff"); - fail_unless!(to_str_radix(0xff as T, 10u) == ~"255"); + assert!(to_str_radix(0 as T, 10u) == ~"0"); + assert!(to_str_radix(1 as T, 10u) == ~"1"); + assert!(to_str_radix(2 as T, 10u) == ~"2"); + assert!(to_str_radix(11 as T, 10u) == ~"11"); + assert!(to_str_radix(11 as T, 16u) == ~"b"); + assert!(to_str_radix(255 as T, 16u) == ~"ff"); + assert!(to_str_radix(0xff as T, 10u) == ~"255"); } #[test] pub fn test_from_str() { - fail_unless!(from_str(~"0") == Some(0u as T)); - fail_unless!(from_str(~"3") == Some(3u as T)); - fail_unless!(from_str(~"10") == Some(10u as T)); - fail_unless!(u32::from_str(~"123456789") == Some(123456789 as u32)); - fail_unless!(from_str(~"00100") == Some(100u as T)); + assert!(from_str(~"0") == Some(0u as T)); + assert!(from_str(~"3") == Some(3u as T)); + assert!(from_str(~"10") == Some(10u as T)); + assert!(u32::from_str(~"123456789") == Some(123456789 as u32)); + assert!(from_str(~"00100") == Some(100u as T)); - fail_unless!(from_str(~"").is_none()); - fail_unless!(from_str(~" ").is_none()); - fail_unless!(from_str(~"x").is_none()); + assert!(from_str(~"").is_none()); + assert!(from_str(~" ").is_none()); + assert!(from_str(~"x").is_none()); } #[test] pub fn test_parse_bytes() { use str::to_bytes; - fail_unless!(parse_bytes(to_bytes(~"123"), 10u) == Some(123u as T)); - fail_unless!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9u as T)); - fail_unless!(parse_bytes(to_bytes(~"123"), 8u) == Some(83u as T)); - fail_unless!(u16::parse_bytes(to_bytes(~"123"), 16u) == + assert!(parse_bytes(to_bytes(~"123"), 10u) == Some(123u as T)); + assert!(parse_bytes(to_bytes(~"1001"), 2u) == Some(9u as T)); + assert!(parse_bytes(to_bytes(~"123"), 8u) == Some(83u as T)); + assert!(u16::parse_bytes(to_bytes(~"123"), 16u) == Some(291u as u16)); - fail_unless!(u16::parse_bytes(to_bytes(~"ffff"), 16u) == + assert!(u16::parse_bytes(to_bytes(~"ffff"), 16u) == Some(65535u as u16)); - fail_unless!(parse_bytes(to_bytes(~"z"), 36u) == Some(35u as T)); + assert!(parse_bytes(to_bytes(~"z"), 36u) == Some(35u as T)); - fail_unless!(parse_bytes(to_bytes(~"Z"), 10u).is_none()); - fail_unless!(parse_bytes(to_bytes(~"_"), 2u).is_none()); + assert!(parse_bytes(to_bytes(~"Z"), 10u).is_none()); + assert!(parse_bytes(to_bytes(~"_"), 2u).is_none()); } #[test] fn test_uint_to_str_overflow() { let mut u8_val: u8 = 255_u8; - fail_unless!((u8::to_str(u8_val) == ~"255")); + assert!((u8::to_str(u8_val) == ~"255")); u8_val += 1 as u8; - fail_unless!((u8::to_str(u8_val) == ~"0")); + assert!((u8::to_str(u8_val) == ~"0")); let mut u16_val: u16 = 65_535_u16; - fail_unless!((u16::to_str(u16_val) == ~"65535")); + assert!((u16::to_str(u16_val) == ~"65535")); u16_val += 1 as u16; - fail_unless!((u16::to_str(u16_val) == ~"0")); + assert!((u16::to_str(u16_val) == ~"0")); let mut u32_val: u32 = 4_294_967_295_u32; - fail_unless!((u32::to_str(u32_val) == ~"4294967295")); + assert!((u32::to_str(u32_val) == ~"4294967295")); u32_val += 1 as u32; - fail_unless!((u32::to_str(u32_val) == ~"0")); + assert!((u32::to_str(u32_val) == ~"0")); let mut u64_val: u64 = 18_446_744_073_709_551_615_u64; - fail_unless!((u64::to_str(u64_val) == ~"18446744073709551615")); + assert!((u64::to_str(u64_val) == ~"18446744073709551615")); u64_val += 1 as u64; - fail_unless!((u64::to_str(u64_val) == ~"0")); + assert!((u64::to_str(u64_val) == ~"0")); } #[test] fn test_uint_from_str_overflow() { let mut u8_val: u8 = 255_u8; - fail_unless!((u8::from_str(~"255") == Some(u8_val))); - fail_unless!((u8::from_str(~"256").is_none())); + assert!((u8::from_str(~"255") == Some(u8_val))); + assert!((u8::from_str(~"256").is_none())); u8_val += 1 as u8; - fail_unless!((u8::from_str(~"0") == Some(u8_val))); - fail_unless!((u8::from_str(~"-1").is_none())); + assert!((u8::from_str(~"0") == Some(u8_val))); + assert!((u8::from_str(~"-1").is_none())); let mut u16_val: u16 = 65_535_u16; - fail_unless!((u16::from_str(~"65535") == Some(u16_val))); - fail_unless!((u16::from_str(~"65536").is_none())); + assert!((u16::from_str(~"65535") == Some(u16_val))); + assert!((u16::from_str(~"65536").is_none())); u16_val += 1 as u16; - fail_unless!((u16::from_str(~"0") == Some(u16_val))); - fail_unless!((u16::from_str(~"-1").is_none())); + assert!((u16::from_str(~"0") == Some(u16_val))); + assert!((u16::from_str(~"-1").is_none())); let mut u32_val: u32 = 4_294_967_295_u32; - fail_unless!((u32::from_str(~"4294967295") == Some(u32_val))); - fail_unless!((u32::from_str(~"4294967296").is_none())); + assert!((u32::from_str(~"4294967295") == Some(u32_val))); + assert!((u32::from_str(~"4294967296").is_none())); u32_val += 1 as u32; - fail_unless!((u32::from_str(~"0") == Some(u32_val))); - fail_unless!((u32::from_str(~"-1").is_none())); + assert!((u32::from_str(~"0") == Some(u32_val))); + assert!((u32::from_str(~"-1").is_none())); let mut u64_val: u64 = 18_446_744_073_709_551_615_u64; - fail_unless!((u64::from_str(~"18446744073709551615") == Some(u64_val))); - fail_unless!((u64::from_str(~"18446744073709551616").is_none())); + assert!((u64::from_str(~"18446744073709551615") == Some(u64_val))); + assert!((u64::from_str(~"18446744073709551616").is_none())); u64_val += 1 as u64; - fail_unless!((u64::from_str(~"0") == Some(u64_val))); - fail_unless!((u64::from_str(~"-1").is_none())); + assert!((u64::from_str(~"0") == Some(u64_val))); + assert!((u64::from_str(~"-1").is_none())); } #[test] @@ -372,7 +372,7 @@ pub fn test_ranges() { l.push(i); } - fail_unless!(l == ~[0,1,2, + assert!(l == ~[0,1,2, 13,12,11, 20,22,24, 36,34,32]); @@ -397,11 +397,11 @@ pub fn test_num() { let ten: T = num::cast(10); let two: T = num::cast(2); - fail_unless!((ten.add(&two) == num::cast(12))); - fail_unless!((ten.sub(&two) == num::cast(8))); - fail_unless!((ten.mul(&two) == num::cast(20))); - fail_unless!((ten.div(&two) == num::cast(5))); - fail_unless!((ten.modulo(&two) == num::cast(0))); + assert!((ten.add(&two) == num::cast(12))); + assert!((ten.sub(&two) == num::cast(8))); + assert!((ten.mul(&two) == num::cast(20))); + assert!((ten.div(&two) == num::cast(5))); + assert!((ten.modulo(&two) == num::cast(0))); } #[test] diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs index c73313ac0f34f..7445a43e48645 100644 --- a/src/libcore/num/uint-template/u16.rs +++ b/src/libcore/num/uint-template/u16.rs @@ -45,45 +45,45 @@ impl NumCast for u16 { #[test] fn test_numcast() { - fail_unless!((20u == 20u16.to_uint())); - fail_unless!((20u8 == 20u16.to_u8())); - fail_unless!((20u16 == 20u16.to_u16())); - fail_unless!((20u32 == 20u16.to_u32())); - fail_unless!((20u64 == 20u16.to_u64())); - fail_unless!((20i == 20u16.to_int())); - fail_unless!((20i8 == 20u16.to_i8())); - fail_unless!((20i16 == 20u16.to_i16())); - fail_unless!((20i32 == 20u16.to_i32())); - fail_unless!((20i64 == 20u16.to_i64())); - fail_unless!((20f == 20u16.to_float())); - fail_unless!((20f32 == 20u16.to_f32())); - fail_unless!((20f64 == 20u16.to_f64())); + assert!((20u == 20u16.to_uint())); + assert!((20u8 == 20u16.to_u8())); + assert!((20u16 == 20u16.to_u16())); + assert!((20u32 == 20u16.to_u32())); + assert!((20u64 == 20u16.to_u64())); + assert!((20i == 20u16.to_int())); + assert!((20i8 == 20u16.to_i8())); + assert!((20i16 == 20u16.to_i16())); + assert!((20i32 == 20u16.to_i32())); + assert!((20i64 == 20u16.to_i64())); + assert!((20f == 20u16.to_float())); + assert!((20f32 == 20u16.to_f32())); + assert!((20f64 == 20u16.to_f64())); - fail_unless!((20u16 == NumCast::from(20u))); - fail_unless!((20u16 == NumCast::from(20u8))); - fail_unless!((20u16 == NumCast::from(20u16))); - fail_unless!((20u16 == NumCast::from(20u32))); - fail_unless!((20u16 == NumCast::from(20u64))); - fail_unless!((20u16 == NumCast::from(20i))); - fail_unless!((20u16 == NumCast::from(20i8))); - fail_unless!((20u16 == NumCast::from(20i16))); - fail_unless!((20u16 == NumCast::from(20i32))); - fail_unless!((20u16 == NumCast::from(20i64))); - fail_unless!((20u16 == NumCast::from(20f))); - fail_unless!((20u16 == NumCast::from(20f32))); - fail_unless!((20u16 == NumCast::from(20f64))); + assert!((20u16 == NumCast::from(20u))); + assert!((20u16 == NumCast::from(20u8))); + assert!((20u16 == NumCast::from(20u16))); + assert!((20u16 == NumCast::from(20u32))); + assert!((20u16 == NumCast::from(20u64))); + assert!((20u16 == NumCast::from(20i))); + assert!((20u16 == NumCast::from(20i8))); + assert!((20u16 == NumCast::from(20i16))); + assert!((20u16 == NumCast::from(20i32))); + assert!((20u16 == NumCast::from(20i64))); + assert!((20u16 == NumCast::from(20f))); + assert!((20u16 == NumCast::from(20f32))); + assert!((20u16 == NumCast::from(20f64))); - fail_unless!((20u16 == num::cast(20u))); - fail_unless!((20u16 == num::cast(20u8))); - fail_unless!((20u16 == num::cast(20u16))); - fail_unless!((20u16 == num::cast(20u32))); - fail_unless!((20u16 == num::cast(20u64))); - fail_unless!((20u16 == num::cast(20i))); - fail_unless!((20u16 == num::cast(20i8))); - fail_unless!((20u16 == num::cast(20i16))); - fail_unless!((20u16 == num::cast(20i32))); - fail_unless!((20u16 == num::cast(20i64))); - fail_unless!((20u16 == num::cast(20f))); - fail_unless!((20u16 == num::cast(20f32))); - fail_unless!((20u16 == num::cast(20f64))); + assert!((20u16 == num::cast(20u))); + assert!((20u16 == num::cast(20u8))); + assert!((20u16 == num::cast(20u16))); + assert!((20u16 == num::cast(20u32))); + assert!((20u16 == num::cast(20u64))); + assert!((20u16 == num::cast(20i))); + assert!((20u16 == num::cast(20i8))); + assert!((20u16 == num::cast(20i16))); + assert!((20u16 == num::cast(20i32))); + assert!((20u16 == num::cast(20i64))); + assert!((20u16 == num::cast(20f))); + assert!((20u16 == num::cast(20f32))); + assert!((20u16 == num::cast(20f64))); } diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs index eb63f1a370aec..cfc112be8a6d1 100644 --- a/src/libcore/num/uint-template/u32.rs +++ b/src/libcore/num/uint-template/u32.rs @@ -45,45 +45,45 @@ impl NumCast for u32 { #[test] fn test_numcast() { - fail_unless!((20u == 20u64.to_uint())); - fail_unless!((20u8 == 20u64.to_u8())); - fail_unless!((20u16 == 20u64.to_u16())); - fail_unless!((20u32 == 20u64.to_u32())); - fail_unless!((20u64 == 20u64.to_u64())); - fail_unless!((20i == 20u64.to_int())); - fail_unless!((20i8 == 20u64.to_i8())); - fail_unless!((20i16 == 20u64.to_i16())); - fail_unless!((20i32 == 20u64.to_i32())); - fail_unless!((20i64 == 20u64.to_i64())); - fail_unless!((20f == 20u64.to_float())); - fail_unless!((20f32 == 20u64.to_f32())); - fail_unless!((20f64 == 20u64.to_f64())); + assert!((20u == 20u64.to_uint())); + assert!((20u8 == 20u64.to_u8())); + assert!((20u16 == 20u64.to_u16())); + assert!((20u32 == 20u64.to_u32())); + assert!((20u64 == 20u64.to_u64())); + assert!((20i == 20u64.to_int())); + assert!((20i8 == 20u64.to_i8())); + assert!((20i16 == 20u64.to_i16())); + assert!((20i32 == 20u64.to_i32())); + assert!((20i64 == 20u64.to_i64())); + assert!((20f == 20u64.to_float())); + assert!((20f32 == 20u64.to_f32())); + assert!((20f64 == 20u64.to_f64())); - fail_unless!((20u64 == NumCast::from(20u))); - fail_unless!((20u64 == NumCast::from(20u8))); - fail_unless!((20u64 == NumCast::from(20u16))); - fail_unless!((20u64 == NumCast::from(20u32))); - fail_unless!((20u64 == NumCast::from(20u64))); - fail_unless!((20u64 == NumCast::from(20i))); - fail_unless!((20u64 == NumCast::from(20i8))); - fail_unless!((20u64 == NumCast::from(20i16))); - fail_unless!((20u64 == NumCast::from(20i32))); - fail_unless!((20u64 == NumCast::from(20i64))); - fail_unless!((20u64 == NumCast::from(20f))); - fail_unless!((20u64 == NumCast::from(20f32))); - fail_unless!((20u64 == NumCast::from(20f64))); + assert!((20u64 == NumCast::from(20u))); + assert!((20u64 == NumCast::from(20u8))); + assert!((20u64 == NumCast::from(20u16))); + assert!((20u64 == NumCast::from(20u32))); + assert!((20u64 == NumCast::from(20u64))); + assert!((20u64 == NumCast::from(20i))); + assert!((20u64 == NumCast::from(20i8))); + assert!((20u64 == NumCast::from(20i16))); + assert!((20u64 == NumCast::from(20i32))); + assert!((20u64 == NumCast::from(20i64))); + assert!((20u64 == NumCast::from(20f))); + assert!((20u64 == NumCast::from(20f32))); + assert!((20u64 == NumCast::from(20f64))); - fail_unless!((20u64 == num::cast(20u))); - fail_unless!((20u64 == num::cast(20u8))); - fail_unless!((20u64 == num::cast(20u16))); - fail_unless!((20u64 == num::cast(20u32))); - fail_unless!((20u64 == num::cast(20u64))); - fail_unless!((20u64 == num::cast(20i))); - fail_unless!((20u64 == num::cast(20i8))); - fail_unless!((20u64 == num::cast(20i16))); - fail_unless!((20u64 == num::cast(20i32))); - fail_unless!((20u64 == num::cast(20i64))); - fail_unless!((20u64 == num::cast(20f))); - fail_unless!((20u64 == num::cast(20f32))); - fail_unless!((20u64 == num::cast(20f64))); + assert!((20u64 == num::cast(20u))); + assert!((20u64 == num::cast(20u8))); + assert!((20u64 == num::cast(20u16))); + assert!((20u64 == num::cast(20u32))); + assert!((20u64 == num::cast(20u64))); + assert!((20u64 == num::cast(20i))); + assert!((20u64 == num::cast(20i8))); + assert!((20u64 == num::cast(20i16))); + assert!((20u64 == num::cast(20i32))); + assert!((20u64 == num::cast(20i64))); + assert!((20u64 == num::cast(20f))); + assert!((20u64 == num::cast(20f32))); + assert!((20u64 == num::cast(20f64))); } diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs index 799421dc9767f..4e2f6640d6974 100644 --- a/src/libcore/num/uint-template/u64.rs +++ b/src/libcore/num/uint-template/u64.rs @@ -45,45 +45,45 @@ impl NumCast for u64 { #[test] fn test_numcast() { - fail_unless!((20u == 20u64.to_uint())); - fail_unless!((20u8 == 20u64.to_u8())); - fail_unless!((20u16 == 20u64.to_u16())); - fail_unless!((20u32 == 20u64.to_u32())); - fail_unless!((20u64 == 20u64.to_u64())); - fail_unless!((20i == 20u64.to_int())); - fail_unless!((20i8 == 20u64.to_i8())); - fail_unless!((20i16 == 20u64.to_i16())); - fail_unless!((20i32 == 20u64.to_i32())); - fail_unless!((20i64 == 20u64.to_i64())); - fail_unless!((20f == 20u64.to_float())); - fail_unless!((20f32 == 20u64.to_f32())); - fail_unless!((20f64 == 20u64.to_f64())); + assert!((20u == 20u64.to_uint())); + assert!((20u8 == 20u64.to_u8())); + assert!((20u16 == 20u64.to_u16())); + assert!((20u32 == 20u64.to_u32())); + assert!((20u64 == 20u64.to_u64())); + assert!((20i == 20u64.to_int())); + assert!((20i8 == 20u64.to_i8())); + assert!((20i16 == 20u64.to_i16())); + assert!((20i32 == 20u64.to_i32())); + assert!((20i64 == 20u64.to_i64())); + assert!((20f == 20u64.to_float())); + assert!((20f32 == 20u64.to_f32())); + assert!((20f64 == 20u64.to_f64())); - fail_unless!((20u64 == NumCast::from(20u))); - fail_unless!((20u64 == NumCast::from(20u8))); - fail_unless!((20u64 == NumCast::from(20u16))); - fail_unless!((20u64 == NumCast::from(20u32))); - fail_unless!((20u64 == NumCast::from(20u64))); - fail_unless!((20u64 == NumCast::from(20i))); - fail_unless!((20u64 == NumCast::from(20i8))); - fail_unless!((20u64 == NumCast::from(20i16))); - fail_unless!((20u64 == NumCast::from(20i32))); - fail_unless!((20u64 == NumCast::from(20i64))); - fail_unless!((20u64 == NumCast::from(20f))); - fail_unless!((20u64 == NumCast::from(20f32))); - fail_unless!((20u64 == NumCast::from(20f64))); + assert!((20u64 == NumCast::from(20u))); + assert!((20u64 == NumCast::from(20u8))); + assert!((20u64 == NumCast::from(20u16))); + assert!((20u64 == NumCast::from(20u32))); + assert!((20u64 == NumCast::from(20u64))); + assert!((20u64 == NumCast::from(20i))); + assert!((20u64 == NumCast::from(20i8))); + assert!((20u64 == NumCast::from(20i16))); + assert!((20u64 == NumCast::from(20i32))); + assert!((20u64 == NumCast::from(20i64))); + assert!((20u64 == NumCast::from(20f))); + assert!((20u64 == NumCast::from(20f32))); + assert!((20u64 == NumCast::from(20f64))); - fail_unless!((20u64 == num::cast(20u))); - fail_unless!((20u64 == num::cast(20u8))); - fail_unless!((20u64 == num::cast(20u16))); - fail_unless!((20u64 == num::cast(20u32))); - fail_unless!((20u64 == num::cast(20u64))); - fail_unless!((20u64 == num::cast(20i))); - fail_unless!((20u64 == num::cast(20i8))); - fail_unless!((20u64 == num::cast(20i16))); - fail_unless!((20u64 == num::cast(20i32))); - fail_unless!((20u64 == num::cast(20i64))); - fail_unless!((20u64 == num::cast(20f))); - fail_unless!((20u64 == num::cast(20f32))); - fail_unless!((20u64 == num::cast(20f64))); + assert!((20u64 == num::cast(20u))); + assert!((20u64 == num::cast(20u8))); + assert!((20u64 == num::cast(20u16))); + assert!((20u64 == num::cast(20u32))); + assert!((20u64 == num::cast(20u64))); + assert!((20u64 == num::cast(20i))); + assert!((20u64 == num::cast(20i8))); + assert!((20u64 == num::cast(20i16))); + assert!((20u64 == num::cast(20i32))); + assert!((20u64 == num::cast(20i64))); + assert!((20u64 == num::cast(20f))); + assert!((20u64 == num::cast(20f32))); + assert!((20u64 == num::cast(20f64))); } diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs index b173d29510c04..52bc56b955cc1 100644 --- a/src/libcore/num/uint-template/u8.rs +++ b/src/libcore/num/uint-template/u8.rs @@ -52,45 +52,45 @@ impl NumCast for u8 { #[test] fn test_numcast() { - fail_unless!((20u == 20u8.to_uint())); - fail_unless!((20u8 == 20u8.to_u8())); - fail_unless!((20u16 == 20u8.to_u16())); - fail_unless!((20u32 == 20u8.to_u32())); - fail_unless!((20u64 == 20u8.to_u64())); - fail_unless!((20i == 20u8.to_int())); - fail_unless!((20i8 == 20u8.to_i8())); - fail_unless!((20i16 == 20u8.to_i16())); - fail_unless!((20i32 == 20u8.to_i32())); - fail_unless!((20i64 == 20u8.to_i64())); - fail_unless!((20f == 20u8.to_float())); - fail_unless!((20f32 == 20u8.to_f32())); - fail_unless!((20f64 == 20u8.to_f64())); + assert!((20u == 20u8.to_uint())); + assert!((20u8 == 20u8.to_u8())); + assert!((20u16 == 20u8.to_u16())); + assert!((20u32 == 20u8.to_u32())); + assert!((20u64 == 20u8.to_u64())); + assert!((20i == 20u8.to_int())); + assert!((20i8 == 20u8.to_i8())); + assert!((20i16 == 20u8.to_i16())); + assert!((20i32 == 20u8.to_i32())); + assert!((20i64 == 20u8.to_i64())); + assert!((20f == 20u8.to_float())); + assert!((20f32 == 20u8.to_f32())); + assert!((20f64 == 20u8.to_f64())); - fail_unless!((20u8 == NumCast::from(20u))); - fail_unless!((20u8 == NumCast::from(20u8))); - fail_unless!((20u8 == NumCast::from(20u16))); - fail_unless!((20u8 == NumCast::from(20u32))); - fail_unless!((20u8 == NumCast::from(20u64))); - fail_unless!((20u8 == NumCast::from(20i))); - fail_unless!((20u8 == NumCast::from(20i8))); - fail_unless!((20u8 == NumCast::from(20i16))); - fail_unless!((20u8 == NumCast::from(20i32))); - fail_unless!((20u8 == NumCast::from(20i64))); - fail_unless!((20u8 == NumCast::from(20f))); - fail_unless!((20u8 == NumCast::from(20f32))); - fail_unless!((20u8 == NumCast::from(20f64))); + assert!((20u8 == NumCast::from(20u))); + assert!((20u8 == NumCast::from(20u8))); + assert!((20u8 == NumCast::from(20u16))); + assert!((20u8 == NumCast::from(20u32))); + assert!((20u8 == NumCast::from(20u64))); + assert!((20u8 == NumCast::from(20i))); + assert!((20u8 == NumCast::from(20i8))); + assert!((20u8 == NumCast::from(20i16))); + assert!((20u8 == NumCast::from(20i32))); + assert!((20u8 == NumCast::from(20i64))); + assert!((20u8 == NumCast::from(20f))); + assert!((20u8 == NumCast::from(20f32))); + assert!((20u8 == NumCast::from(20f64))); - fail_unless!((20u8 == num::cast(20u))); - fail_unless!((20u8 == num::cast(20u8))); - fail_unless!((20u8 == num::cast(20u16))); - fail_unless!((20u8 == num::cast(20u32))); - fail_unless!((20u8 == num::cast(20u64))); - fail_unless!((20u8 == num::cast(20i))); - fail_unless!((20u8 == num::cast(20i8))); - fail_unless!((20u8 == num::cast(20i16))); - fail_unless!((20u8 == num::cast(20i32))); - fail_unless!((20u8 == num::cast(20i64))); - fail_unless!((20u8 == num::cast(20f))); - fail_unless!((20u8 == num::cast(20f32))); - fail_unless!((20u8 == num::cast(20f64))); + assert!((20u8 == num::cast(20u))); + assert!((20u8 == num::cast(20u8))); + assert!((20u8 == num::cast(20u16))); + assert!((20u8 == num::cast(20u32))); + assert!((20u8 == num::cast(20u64))); + assert!((20u8 == num::cast(20i))); + assert!((20u8 == num::cast(20i8))); + assert!((20u8 == num::cast(20i16))); + assert!((20u8 == num::cast(20i32))); + assert!((20u8 == num::cast(20i64))); + assert!((20u8 == num::cast(20f))); + assert!((20u8 == num::cast(20f32))); + assert!((20u8 == num::cast(20f64))); } diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs index 741e0f36a333b..16e53eb4b6c97 100644 --- a/src/libcore/num/uint-template/uint.rs +++ b/src/libcore/num/uint-template/uint.rs @@ -143,61 +143,61 @@ pub mod inst { #[test] fn test_next_power_of_two() { - fail_unless!((next_power_of_two(0u) == 0u)); - fail_unless!((next_power_of_two(1u) == 1u)); - fail_unless!((next_power_of_two(2u) == 2u)); - fail_unless!((next_power_of_two(3u) == 4u)); - fail_unless!((next_power_of_two(4u) == 4u)); - fail_unless!((next_power_of_two(5u) == 8u)); - fail_unless!((next_power_of_two(6u) == 8u)); - fail_unless!((next_power_of_two(7u) == 8u)); - fail_unless!((next_power_of_two(8u) == 8u)); - fail_unless!((next_power_of_two(9u) == 16u)); - fail_unless!((next_power_of_two(10u) == 16u)); - fail_unless!((next_power_of_two(11u) == 16u)); - fail_unless!((next_power_of_two(12u) == 16u)); - fail_unless!((next_power_of_two(13u) == 16u)); - fail_unless!((next_power_of_two(14u) == 16u)); - fail_unless!((next_power_of_two(15u) == 16u)); - fail_unless!((next_power_of_two(16u) == 16u)); - fail_unless!((next_power_of_two(17u) == 32u)); - fail_unless!((next_power_of_two(18u) == 32u)); - fail_unless!((next_power_of_two(19u) == 32u)); - fail_unless!((next_power_of_two(20u) == 32u)); - fail_unless!((next_power_of_two(21u) == 32u)); - fail_unless!((next_power_of_two(22u) == 32u)); - fail_unless!((next_power_of_two(23u) == 32u)); - fail_unless!((next_power_of_two(24u) == 32u)); - fail_unless!((next_power_of_two(25u) == 32u)); - fail_unless!((next_power_of_two(26u) == 32u)); - fail_unless!((next_power_of_two(27u) == 32u)); - fail_unless!((next_power_of_two(28u) == 32u)); - fail_unless!((next_power_of_two(29u) == 32u)); - fail_unless!((next_power_of_two(30u) == 32u)); - fail_unless!((next_power_of_two(31u) == 32u)); - fail_unless!((next_power_of_two(32u) == 32u)); - fail_unless!((next_power_of_two(33u) == 64u)); - fail_unless!((next_power_of_two(34u) == 64u)); - fail_unless!((next_power_of_two(35u) == 64u)); - fail_unless!((next_power_of_two(36u) == 64u)); - fail_unless!((next_power_of_two(37u) == 64u)); - fail_unless!((next_power_of_two(38u) == 64u)); - fail_unless!((next_power_of_two(39u) == 64u)); + assert!((next_power_of_two(0u) == 0u)); + assert!((next_power_of_two(1u) == 1u)); + assert!((next_power_of_two(2u) == 2u)); + assert!((next_power_of_two(3u) == 4u)); + assert!((next_power_of_two(4u) == 4u)); + assert!((next_power_of_two(5u) == 8u)); + assert!((next_power_of_two(6u) == 8u)); + assert!((next_power_of_two(7u) == 8u)); + assert!((next_power_of_two(8u) == 8u)); + assert!((next_power_of_two(9u) == 16u)); + assert!((next_power_of_two(10u) == 16u)); + assert!((next_power_of_two(11u) == 16u)); + assert!((next_power_of_two(12u) == 16u)); + assert!((next_power_of_two(13u) == 16u)); + assert!((next_power_of_two(14u) == 16u)); + assert!((next_power_of_two(15u) == 16u)); + assert!((next_power_of_two(16u) == 16u)); + assert!((next_power_of_two(17u) == 32u)); + assert!((next_power_of_two(18u) == 32u)); + assert!((next_power_of_two(19u) == 32u)); + assert!((next_power_of_two(20u) == 32u)); + assert!((next_power_of_two(21u) == 32u)); + assert!((next_power_of_two(22u) == 32u)); + assert!((next_power_of_two(23u) == 32u)); + assert!((next_power_of_two(24u) == 32u)); + assert!((next_power_of_two(25u) == 32u)); + assert!((next_power_of_two(26u) == 32u)); + assert!((next_power_of_two(27u) == 32u)); + assert!((next_power_of_two(28u) == 32u)); + assert!((next_power_of_two(29u) == 32u)); + assert!((next_power_of_two(30u) == 32u)); + assert!((next_power_of_two(31u) == 32u)); + assert!((next_power_of_two(32u) == 32u)); + assert!((next_power_of_two(33u) == 64u)); + assert!((next_power_of_two(34u) == 64u)); + assert!((next_power_of_two(35u) == 64u)); + assert!((next_power_of_two(36u) == 64u)); + assert!((next_power_of_two(37u) == 64u)); + assert!((next_power_of_two(38u) == 64u)); + assert!((next_power_of_two(39u) == 64u)); } #[test] fn test_overflows() { use uint; - fail_unless!((uint::max_value > 0u)); - fail_unless!((uint::min_value <= 0u)); - fail_unless!((uint::min_value + uint::max_value + 1u == 0u)); + assert!((uint::max_value > 0u)); + assert!((uint::min_value <= 0u)); + assert!((uint::min_value + uint::max_value + 1u == 0u)); } #[test] fn test_div() { - fail_unless!((div_floor(3u, 4u) == 0u)); - fail_unless!((div_ceil(3u, 4u) == 1u)); - fail_unless!((div_round(3u, 4u) == 1u)); + assert!((div_floor(3u, 4u) == 0u)); + assert!((div_ceil(3u, 4u) == 1u)); + assert!((div_round(3u, 4u) == 1u)); } #[test] @@ -206,7 +206,7 @@ pub mod inst { let ten = 10 as uint; let mut accum = 0; for ten.times { accum += 1; } - fail_unless!((accum == 10)); + assert!((accum == 10)); } } @@ -236,45 +236,45 @@ impl NumCast for uint { #[test] fn test_numcast() { - fail_unless!((20u == 20u.to_uint())); - fail_unless!((20u8 == 20u.to_u8())); - fail_unless!((20u16 == 20u.to_u16())); - fail_unless!((20u32 == 20u.to_u32())); - fail_unless!((20u64 == 20u.to_u64())); - fail_unless!((20i == 20u.to_int())); - fail_unless!((20i8 == 20u.to_i8())); - fail_unless!((20i16 == 20u.to_i16())); - fail_unless!((20i32 == 20u.to_i32())); - fail_unless!((20i64 == 20u.to_i64())); - fail_unless!((20f == 20u.to_float())); - fail_unless!((20f32 == 20u.to_f32())); - fail_unless!((20f64 == 20u.to_f64())); + assert!((20u == 20u.to_uint())); + assert!((20u8 == 20u.to_u8())); + assert!((20u16 == 20u.to_u16())); + assert!((20u32 == 20u.to_u32())); + assert!((20u64 == 20u.to_u64())); + assert!((20i == 20u.to_int())); + assert!((20i8 == 20u.to_i8())); + assert!((20i16 == 20u.to_i16())); + assert!((20i32 == 20u.to_i32())); + assert!((20i64 == 20u.to_i64())); + assert!((20f == 20u.to_float())); + assert!((20f32 == 20u.to_f32())); + assert!((20f64 == 20u.to_f64())); - fail_unless!((20u == NumCast::from(20u))); - fail_unless!((20u == NumCast::from(20u8))); - fail_unless!((20u == NumCast::from(20u16))); - fail_unless!((20u == NumCast::from(20u32))); - fail_unless!((20u == NumCast::from(20u64))); - fail_unless!((20u == NumCast::from(20i))); - fail_unless!((20u == NumCast::from(20i8))); - fail_unless!((20u == NumCast::from(20i16))); - fail_unless!((20u == NumCast::from(20i32))); - fail_unless!((20u == NumCast::from(20i64))); - fail_unless!((20u == NumCast::from(20f))); - fail_unless!((20u == NumCast::from(20f32))); - fail_unless!((20u == NumCast::from(20f64))); + assert!((20u == NumCast::from(20u))); + assert!((20u == NumCast::from(20u8))); + assert!((20u == NumCast::from(20u16))); + assert!((20u == NumCast::from(20u32))); + assert!((20u == NumCast::from(20u64))); + assert!((20u == NumCast::from(20i))); + assert!((20u == NumCast::from(20i8))); + assert!((20u == NumCast::from(20i16))); + assert!((20u == NumCast::from(20i32))); + assert!((20u == NumCast::from(20i64))); + assert!((20u == NumCast::from(20f))); + assert!((20u == NumCast::from(20f32))); + assert!((20u == NumCast::from(20f64))); - fail_unless!((20u == num::cast(20u))); - fail_unless!((20u == num::cast(20u8))); - fail_unless!((20u == num::cast(20u16))); - fail_unless!((20u == num::cast(20u32))); - fail_unless!((20u == num::cast(20u64))); - fail_unless!((20u == num::cast(20i))); - fail_unless!((20u == num::cast(20i8))); - fail_unless!((20u == num::cast(20i16))); - fail_unless!((20u == num::cast(20i32))); - fail_unless!((20u == num::cast(20i64))); - fail_unless!((20u == num::cast(20f))); - fail_unless!((20u == num::cast(20f32))); - fail_unless!((20u == num::cast(20f64))); + assert!((20u == num::cast(20u))); + assert!((20u == num::cast(20u8))); + assert!((20u == num::cast(20u16))); + assert!((20u == num::cast(20u32))); + assert!((20u == num::cast(20u64))); + assert!((20u == num::cast(20i))); + assert!((20u == num::cast(20i8))); + assert!((20u == num::cast(20i16))); + assert!((20u == num::cast(20i32))); + assert!((20u == num::cast(20i64))); + assert!((20u == num::cast(20f))); + assert!((20u == num::cast(20f32))); + assert!((20u == num::cast(20f64))); } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 59c836eba653f..cd34d7ab0c0bb 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -356,7 +356,7 @@ fn test_unwrap_ptr() { let opt = Some(x); let y = opt.unwrap(); let addr_y = ptr::addr_of(&(*y)); - fail_unless!(addr_x == addr_y); + assert!(addr_x == addr_y); } #[test] @@ -366,7 +366,7 @@ fn test_unwrap_str() { let opt = Some(x); let y = opt.unwrap(); let addr_y = str::as_buf(y, |buf, _len| buf); - fail_unless!(addr_x == addr_y); + assert!(addr_x == addr_y); } #[test] @@ -392,7 +392,7 @@ fn test_unwrap_resource() { let opt = Some(x); let _y = opt.unwrap(); } - fail_unless!(*i == 1); + assert!(*i == 1); } #[test] @@ -403,8 +403,8 @@ fn test_option_dance() { for x.each |_x| { y2 = y.swap_unwrap(); } - fail_unless!(y2 == 5); - fail_unless!(y.is_none()); + assert!(y2 == 5); + assert!(y.is_none()); } #[test] #[should_fail] #[ignore(cfg(windows))] fn test_option_too_much_dance() { @@ -424,15 +424,15 @@ fn test_option_while_some() { None } } - fail_unless!(i == 11); + assert!(i == 11); } #[test] fn test_get_or_zero() { let some_stuff = Some(42); - fail_unless!(some_stuff.get_or_zero() == 42); + assert!(some_stuff.get_or_zero() == 42); let no_stuff: Option = None; - fail_unless!(no_stuff.get_or_zero() == 0); + assert!(no_stuff.get_or_zero() == 0); } // Local Variables: diff --git a/src/libcore/os.rs b/src/libcore/os.rs index fa10f39c90d08..7dbc177399413 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -222,7 +222,7 @@ pub fn env() -> ~[(~str,~str)] { for str::each_splitn_char(*p, '=', 1) |s| { vs.push(s.to_owned()) } debug!("splitting: len: %u", vs.len()); - fail_unless!(vs.len() == 2); + assert!(vs.len() == 2); pairs.push((copy vs[0], copy vs[1])); } pairs @@ -366,7 +366,7 @@ pub fn waitpid(pid: pid_t) -> c_int { use libc::funcs::posix01::wait::*; let mut status = 0 as c_int; - fail_unless!((waitpid(pid, &mut status, 0 as c_int) != + assert!((waitpid(pid, &mut status, 0 as c_int) != (-1 as c_int))); return status; } @@ -380,7 +380,7 @@ pub fn pipe() -> Pipe { unsafe { let mut fds = Pipe {in: 0 as c_int, out: 0 as c_int }; - fail_unless!((libc::pipe(&mut fds.in) == (0 as c_int))); + assert!((libc::pipe(&mut fds.in) == (0 as c_int))); return Pipe {in: fds.in, out: fds.out}; } } @@ -399,9 +399,9 @@ pub fn pipe() -> Pipe { out: 0 as c_int }; let res = libc::pipe(&mut fds.in, 1024 as ::libc::c_uint, (libc::O_BINARY | libc::O_NOINHERIT) as c_int); - fail_unless!((res == 0 as c_int)); - fail_unless!((fds.in != -1 as c_int && fds.in != 0 as c_int)); - fail_unless!((fds.out != -1 as c_int && fds.in != 0 as c_int)); + assert!((res == 0 as c_int)); + assert!((fds.in != -1 as c_int && fds.in != 0 as c_int)); + assert!((fds.out != -1 as c_int && fds.in != 0 as c_int)); return Pipe {in: fds.in, out: fds.out}; } } @@ -1277,13 +1277,13 @@ mod tests { #[test] pub fn test_args() { let a = real_args(); - fail_unless!(a.len() >= 1); + assert!(a.len() >= 1); } fn make_rand_name() -> ~str { let rng: @rand::Rng = rand::Rng(); let n = ~"TEST" + rng.gen_str(10u); - fail_unless!(getenv(n).is_none()); + assert!(getenv(n).is_none()); n } @@ -1291,7 +1291,7 @@ mod tests { fn test_setenv() { let n = make_rand_name(); setenv(n, ~"VALUE"); - fail_unless!(getenv(n) == option::Some(~"VALUE")); + assert!(getenv(n) == option::Some(~"VALUE")); } #[test] @@ -1301,9 +1301,9 @@ mod tests { let n = make_rand_name(); setenv(n, ~"1"); setenv(n, ~"2"); - fail_unless!(getenv(n) == option::Some(~"2")); + assert!(getenv(n) == option::Some(~"2")); setenv(n, ~""); - fail_unless!(getenv(n) == option::Some(~"")); + assert!(getenv(n) == option::Some(~"")); } // Windows GetEnvironmentVariable requires some extra work to make sure @@ -1318,25 +1318,25 @@ mod tests { let n = make_rand_name(); setenv(n, s); debug!(copy s); - fail_unless!(getenv(n) == option::Some(s)); + assert!(getenv(n) == option::Some(s)); } #[test] fn test_self_exe_path() { let path = os::self_exe_path(); - fail_unless!(path.is_some()); + assert!(path.is_some()); let path = path.get(); debug!(copy path); // Hard to test this function - fail_unless!(path.is_absolute); + assert!(path.is_absolute); } #[test] #[ignore] fn test_env_getenv() { let e = env(); - fail_unless!(vec::len(e) > 0u); + assert!(vec::len(e) > 0u); for vec::each(e) |p| { let (n, v) = copy *p; debug!(copy n); @@ -1344,7 +1344,7 @@ mod tests { // MingW seems to set some funky environment variables like // "=C:=C:\MinGW\msys\1.0\bin" and "!::=::\" that are returned // from env() but not visible from getenv(). - fail_unless!(v2.is_none() || v2 == option::Some(v)); + assert!(v2.is_none() || v2 == option::Some(v)); } } @@ -1354,15 +1354,15 @@ mod tests { let mut e = env(); setenv(n, ~"VALUE"); - fail_unless!(!vec::contains(e, &(copy n, ~"VALUE"))); + assert!(!vec::contains(e, &(copy n, ~"VALUE"))); e = env(); - fail_unless!(vec::contains(e, &(n, ~"VALUE"))); + assert!(vec::contains(e, &(n, ~"VALUE"))); } #[test] fn test() { - fail_unless!((!Path("test-path").is_absolute)); + assert!((!Path("test-path").is_absolute)); debug!(~"Current working directory: " + getcwd().to_str()); @@ -1376,10 +1376,10 @@ mod tests { let oldhome = getenv(~"HOME"); setenv(~"HOME", ~"/home/MountainView"); - fail_unless!(os::homedir() == Some(Path("/home/MountainView"))); + assert!(os::homedir() == Some(Path("/home/MountainView"))); setenv(~"HOME", ~""); - fail_unless!(os::homedir().is_none()); + assert!(os::homedir().is_none()); for oldhome.each |s| { setenv(~"HOME", *s) } } @@ -1394,19 +1394,19 @@ mod tests { setenv(~"HOME", ~""); setenv(~"USERPROFILE", ~""); - fail_unless!(os::homedir().is_none()); + assert!(os::homedir().is_none()); setenv(~"HOME", ~"/home/MountainView"); - fail_unless!(os::homedir() == Some(Path("/home/MountainView"))); + assert!(os::homedir() == Some(Path("/home/MountainView"))); setenv(~"HOME", ~""); setenv(~"USERPROFILE", ~"/home/MountainView"); - fail_unless!(os::homedir() == Some(Path("/home/MountainView"))); + assert!(os::homedir() == Some(Path("/home/MountainView"))); setenv(~"HOME", ~"/home/MountainView"); setenv(~"USERPROFILE", ~"/home/PaloAlto"); - fail_unless!(os::homedir() == Some(Path("/home/MountainView"))); + assert!(os::homedir() == Some(Path("/home/MountainView"))); oldhome.each(|s| {setenv(~"HOME", *s);true}); olduserprofile.each(|s| {setenv(~"USERPROFILE", *s);true}); @@ -1414,7 +1414,7 @@ mod tests { #[test] fn tmpdir() { - fail_unless!(!str::is_empty(os::tmpdir().to_str())); + assert!(!str::is_empty(os::tmpdir().to_str())); } // Issue #712 @@ -1427,7 +1427,7 @@ mod tests { fn list_dir() { let dirs = os::list_dir(&Path(".")); // Just assuming that we've got some contents in the current directory - fail_unless!((vec::len(dirs) > 0u)); + assert!((vec::len(dirs) > 0u)); for vec::each(dirs) |dir| { debug!(copy *dir); @@ -1436,22 +1436,22 @@ mod tests { #[test] fn path_is_dir() { - fail_unless!((os::path_is_dir(&Path(".")))); - fail_unless!((!os::path_is_dir(&Path("test/stdtest/fs.rs")))); + assert!((os::path_is_dir(&Path(".")))); + assert!((!os::path_is_dir(&Path("test/stdtest/fs.rs")))); } #[test] fn path_exists() { - fail_unless!((os::path_exists(&Path(".")))); - fail_unless!((!os::path_exists(&Path( + assert!((os::path_exists(&Path(".")))); + assert!((!os::path_exists(&Path( "test/nonexistent-bogus-path")))); } #[test] fn copy_file_does_not_exist() { - fail_unless!(!os::copy_file(&Path("test/nonexistent-bogus-path"), + assert!(!os::copy_file(&Path("test/nonexistent-bogus-path"), &Path("test/other-bogus-path"))); - fail_unless!(!os::path_exists(&Path("test/other-bogus-path"))); + assert!(!os::path_exists(&Path("test/other-bogus-path"))); } #[test] @@ -1459,7 +1459,7 @@ mod tests { unsafe { let tempdir = getcwd(); // would like to use $TMPDIR, // doesn't seem to work on Linux - fail_unless!((str::len(tempdir.to_str()) > 0u)); + assert!((str::len(tempdir.to_str()) > 0u)); let in = tempdir.push("in.txt"); let out = tempdir.push("out.txt"); @@ -1469,24 +1469,24 @@ mod tests { libc::fopen(fromp, modebuf) } }; - fail_unless!((ostream as uint != 0u)); + assert!((ostream as uint != 0u)); let s = ~"hello"; let mut buf = str::to_bytes(s) + ~[0 as u8]; do vec::as_mut_buf(buf) |b, _len| { - fail_unless!((libc::fwrite(b as *c_void, 1u as size_t, + assert!((libc::fwrite(b as *c_void, 1u as size_t, (str::len(s) + 1u) as size_t, ostream) == buf.len() as size_t)) } - fail_unless!((libc::fclose(ostream) == (0u as c_int))); + assert!((libc::fclose(ostream) == (0u as c_int))); let rs = os::copy_file(&in, &out); if (!os::path_exists(&in)) { fail!(fmt!("%s doesn't exist", in.to_str())); } - fail_unless!((rs)); + assert!((rs)); let rslt = run::run_program(~"diff", ~[in.to_str(), out.to_str()]); - fail_unless!((rslt == 0)); - fail_unless!((remove_file(&in))); - fail_unless!((remove_file(&out))); + assert!((rslt == 0)); + assert!((remove_file(&in))); + assert!((remove_file(&out))); } } } diff --git a/src/libcore/path.rs b/src/libcore/path.rs index 3d06809a4523e..7de0f355dd21d 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -440,7 +440,7 @@ impl GenericPath for PosixPath { fn with_filename(&self, f: &str) -> PosixPath { unsafe { - fail_unless!(! str::any(f, |c| windows::is_sep(c as u8))); + assert!(! str::any(f, |c| windows::is_sep(c as u8))); self.dir_path().push(f) } } @@ -485,7 +485,7 @@ impl GenericPath for PosixPath { } fn push_rel(&self, other: &PosixPath) -> PosixPath { - fail_unless!(!other.is_absolute); + assert!(!other.is_absolute); self.push_many(other.components) } @@ -657,7 +657,7 @@ impl GenericPath for WindowsPath { } fn with_filename(&self, f: &str) -> WindowsPath { - fail_unless!(! str::any(f, |c| windows::is_sep(c as u8))); + assert!(! str::any(f, |c| windows::is_sep(c as u8))); self.dir_path().push(f) } @@ -704,7 +704,7 @@ impl GenericPath for WindowsPath { } fn push_rel(&self, other: &WindowsPath) -> WindowsPath { - fail_unless!(!other.is_absolute); + assert!(!other.is_absolute); self.push_many(other.components) } @@ -891,30 +891,30 @@ mod tests { let path = PosixPath("tmp/"); let path = path.push("/hmm"); let path = path.normalize(); - fail_unless!(~"tmp/hmm" == path.to_str()); + assert!(~"tmp/hmm" == path.to_str()); let path = WindowsPath("tmp/"); let path = path.push("/hmm"); let path = path.normalize(); - fail_unless!(~"tmp\\hmm" == path.to_str()); + assert!(~"tmp\\hmm" == path.to_str()); } #[test] fn test_filetype_foo_bar() { let wp = PosixPath("foo.bar"); - fail_unless!(wp.filetype() == Some(~".bar")); + assert!(wp.filetype() == Some(~".bar")); let wp = WindowsPath("foo.bar"); - fail_unless!(wp.filetype() == Some(~".bar")); + assert!(wp.filetype() == Some(~".bar")); } #[test] fn test_filetype_foo() { let wp = PosixPath("foo"); - fail_unless!(wp.filetype() == None); + assert!(wp.filetype() == None); let wp = WindowsPath("foo"); - fail_unless!(wp.filetype() == None); + assert!(wp.filetype() == None); } #[test] @@ -925,7 +925,7 @@ mod tests { if (ss != sss) { debug!("got %s", ss); debug!("expected %s", sss); - fail_unless!(ss == sss); + assert!(ss == sss); } } @@ -983,7 +983,7 @@ mod tests { if (ss != sss) { debug!("got %s", ss); debug!("expected %s", sss); - fail_unless!(ss == sss); + assert!(ss == sss); } } @@ -999,42 +999,42 @@ mod tests { #[test] fn test_extract_unc_prefixes() { - fail_unless!(windows::extract_unc_prefix("\\\\").is_none()); - fail_unless!(windows::extract_unc_prefix("//").is_none()); - fail_unless!(windows::extract_unc_prefix("\\\\hi").is_none()); - fail_unless!(windows::extract_unc_prefix("//hi").is_none()); - fail_unless!(windows::extract_unc_prefix("\\\\hi\\") == + assert!(windows::extract_unc_prefix("\\\\").is_none()); + assert!(windows::extract_unc_prefix("//").is_none()); + assert!(windows::extract_unc_prefix("\\\\hi").is_none()); + assert!(windows::extract_unc_prefix("//hi").is_none()); + assert!(windows::extract_unc_prefix("\\\\hi\\") == Some((~"hi", ~"\\"))); - fail_unless!(windows::extract_unc_prefix("//hi\\") == + assert!(windows::extract_unc_prefix("//hi\\") == Some((~"hi", ~"\\"))); - fail_unless!(windows::extract_unc_prefix("\\\\hi\\there") == + assert!(windows::extract_unc_prefix("\\\\hi\\there") == Some((~"hi", ~"\\there"))); - fail_unless!(windows::extract_unc_prefix("//hi/there") == + assert!(windows::extract_unc_prefix("//hi/there") == Some((~"hi", ~"/there"))); - fail_unless!(windows::extract_unc_prefix( + assert!(windows::extract_unc_prefix( "\\\\hi\\there\\friends.txt") == Some((~"hi", ~"\\there\\friends.txt"))); - fail_unless!(windows::extract_unc_prefix( + assert!(windows::extract_unc_prefix( "//hi\\there\\friends.txt") == Some((~"hi", ~"\\there\\friends.txt"))); } #[test] fn test_extract_drive_prefixes() { - fail_unless!(windows::extract_drive_prefix("c").is_none()); - fail_unless!(windows::extract_drive_prefix("c:") == + assert!(windows::extract_drive_prefix("c").is_none()); + assert!(windows::extract_drive_prefix("c:") == Some((~"c", ~""))); - fail_unless!(windows::extract_drive_prefix("d:") == + assert!(windows::extract_drive_prefix("d:") == Some((~"d", ~""))); - fail_unless!(windows::extract_drive_prefix("z:") == + assert!(windows::extract_drive_prefix("z:") == Some((~"z", ~""))); - fail_unless!(windows::extract_drive_prefix("c:\\hi") == + assert!(windows::extract_drive_prefix("c:\\hi") == Some((~"c", ~"\\hi"))); - fail_unless!(windows::extract_drive_prefix("d:hi") == + assert!(windows::extract_drive_prefix("d:hi") == Some((~"d", ~"hi"))); - fail_unless!(windows::extract_drive_prefix("c:hi\\there.txt") == + assert!(windows::extract_drive_prefix("c:hi\\there.txt") == Some((~"c", ~"hi\\there.txt"))); - fail_unless!(windows::extract_drive_prefix("c:\\hi\\there.txt") == + assert!(windows::extract_drive_prefix("c:\\hi\\there.txt") == Some((~"c", ~"\\hi\\there.txt"))); } @@ -1046,7 +1046,7 @@ mod tests { if (ss != sss) { debug!("got %s", ss); debug!("expected %s", sss); - fail_unless!(ss == sss); + assert!(ss == sss); } } @@ -1131,9 +1131,9 @@ mod tests { #[test] fn test_windows_path_restrictions() { - fail_unless!(WindowsPath("hi").is_restricted() == false); - fail_unless!(WindowsPath("C:\\NUL").is_restricted() == true); - fail_unless!(WindowsPath("C:\\COM1.TXT").is_restricted() == true); - fail_unless!(WindowsPath("c:\\prn.exe").is_restricted() == true); + assert!(WindowsPath("hi").is_restricted() == false); + assert!(WindowsPath("C:\\NUL").is_restricted() == true); + assert!(WindowsPath("C:\\COM1.TXT").is_restricted() == true); + assert!(WindowsPath("c:\\prn.exe").is_restricted() == true); } } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 132ac11566d6f..18f8030d5b84e 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -153,7 +153,7 @@ pub impl PacketHeader { unsafe fn mark_blocked(&self, this: *rust_task) -> State { rustrt::rust_task_ref(this); let old_task = swap_task(&mut self.blocked_task, this); - fail_unless!(old_task.is_null()); + assert!(old_task.is_null()); swap_state_acq(&mut self.state, Blocked) } @@ -175,7 +175,7 @@ pub impl PacketHeader { // continuum. It ends making multiple unique pointers to the same // thing. You'll proobably want to forget them when you're done. unsafe fn buf_header(&self) -> ~BufferHeader { - fail_unless!(self.buffer.is_not_null()); + assert!(self.buffer.is_not_null()); reinterpret_cast(&self.buffer) } @@ -379,8 +379,8 @@ pub fn send(p: SendPacketBuffered, payload: T) -> bool { let header = p.header(); let p_ = p.unwrap(); let p = unsafe { &*p_ }; - fail_unless!(ptr::addr_of(&(p.header)) == header); - fail_unless!(p.payload.is_none()); + assert!(ptr::addr_of(&(p.header)) == header); + assert!(p.payload.is_none()); p.payload = Some(payload); let old_state = swap_state_rel(&mut p.header.state, Full); match old_state { @@ -482,7 +482,7 @@ pub fn try_recv(p: RecvPacketBuffered) debug!("blocked = %x this = %x old_task = %x", p.header.blocked_task as uint, this as uint, old_task as uint); - fail_unless!(old_task.is_null()); + assert!(old_task.is_null()); let mut first = true; let mut count = SPIN_COUNT; loop { @@ -527,7 +527,7 @@ pub fn try_recv(p: RecvPacketBuffered) Terminated => { // This assert detects when we've accidentally unsafely // casted too big of a number to a state. - fail_unless!(old_state == Terminated); + assert!(old_state == Terminated); let old_task = swap_task(&mut p.header.blocked_task, ptr::null()); if !old_task.is_null() { @@ -576,7 +576,7 @@ fn sender_terminate(p: *Packet) { fail!(~"you dun goofed") } Terminated => { - fail_unless!(p.header.blocked_task.is_null()); + assert!(p.header.blocked_task.is_null()); // I have to clean up, use drop_glue } } @@ -587,7 +587,7 @@ fn receiver_terminate(p: *Packet) { let p = unsafe { &*p }; match swap_state_rel(&mut p.header.state, Terminated) { Empty => { - fail_unless!(p.header.blocked_task.is_null()); + assert!(p.header.blocked_task.is_null()); // the sender will clean up } Blocked => { @@ -595,12 +595,12 @@ fn receiver_terminate(p: *Packet) { if !old_task.is_null() { unsafe { rustrt::rust_task_deref(old_task); - fail_unless!(old_task == rustrt::rust_get_task()); + assert!(old_task == rustrt::rust_get_task()); } } } Terminated | Full => { - fail_unless!(p.header.blocked_task.is_null()); + assert!(p.header.blocked_task.is_null()); // I have to clean up, use drop_glue } } @@ -663,7 +663,7 @@ pub fn wait_many(pkts: &[T]) -> uint { debug!("%?, %?", ready_packet, pkts[ready_packet]); unsafe { - fail_unless!((*pkts[ready_packet].header()).state == Full + assert!((*pkts[ready_packet].header()).state == Full || (*pkts[ready_packet].header()).state == Terminated); } @@ -995,6 +995,6 @@ pub mod test { let _chan = chan; } - fail_unless!(!port.peek()); + assert!(!port.peek()); } } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index ecc60f61e1835..fc95e320013e6 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -352,29 +352,29 @@ pub fn test() { let mut p = Pair {fst: 10, snd: 20}; let pptr: *mut Pair = &mut p; let iptr: *mut int = cast::reinterpret_cast(&pptr); - fail_unless!((*iptr == 10));; + assert!((*iptr == 10));; *iptr = 30; - fail_unless!((*iptr == 30)); - fail_unless!((p.fst == 30));; + assert!((*iptr == 30)); + assert!((p.fst == 30));; *pptr = Pair {fst: 50, snd: 60}; - fail_unless!((*iptr == 50)); - fail_unless!((p.fst == 50)); - fail_unless!((p.snd == 60)); + assert!((*iptr == 50)); + assert!((p.fst == 50)); + assert!((p.snd == 60)); let mut v0 = ~[32000u16, 32001u16, 32002u16]; let mut v1 = ~[0u16, 0u16, 0u16]; copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 1u), offset(vec::raw::to_ptr(v0), 1u), 1u); - fail_unless!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16)); + assert!((v1[0] == 0u16 && v1[1] == 32001u16 && v1[2] == 0u16)); copy_memory(vec::raw::to_mut_ptr(v1), offset(vec::raw::to_ptr(v0), 2u), 1u); - fail_unless!((v1[0] == 32002u16 && v1[1] == 32001u16 && + assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 0u16)); copy_memory(mut_offset(vec::raw::to_mut_ptr(v1), 2u), vec::raw::to_ptr(v0), 1u); - fail_unless!((v1[0] == 32002u16 && v1[1] == 32001u16 && + assert!((v1[0] == 32002u16 && v1[1] == 32001u16 && v1[2] == 32000u16)); } } @@ -386,11 +386,11 @@ pub fn test_position() { let s = ~"hello"; unsafe { - fail_unless!(2u == as_c_str(s, |p| position(p, + assert!(2u == as_c_str(s, |p| position(p, |c| *c == 'l' as c_char))); - fail_unless!(4u == as_c_str(s, |p| position(p, + assert!(4u == as_c_str(s, |p| position(p, |c| *c == 'o' as c_char))); - fail_unless!(5u == as_c_str(s, |p| position(p, + assert!(5u == as_c_str(s, |p| position(p, |c| *c == 0 as c_char))); } } @@ -405,8 +405,8 @@ pub fn test_buf_len() { do str::as_c_str(s2) |p2| { let v = ~[p0, p1, p2, null()]; do vec::as_imm_buf(v) |vp, len| { - fail_unless!(unsafe { buf_len(vp) } == 3u); - fail_unless!(len == 4u); + assert!(unsafe { buf_len(vp) } == 3u); + assert!(len == 4u); } } } @@ -416,20 +416,20 @@ pub fn test_buf_len() { #[test] pub fn test_is_null() { let p: *int = null(); - fail_unless!(p.is_null()); - fail_unless!(!p.is_not_null()); + assert!(p.is_null()); + assert!(!p.is_not_null()); let q = offset(p, 1u); - fail_unless!(!q.is_null()); - fail_unless!(q.is_not_null()); + assert!(!q.is_null()); + assert!(q.is_not_null()); let mp: *mut int = mut_null(); - fail_unless!(mp.is_null()); - fail_unless!(!mp.is_not_null()); + assert!(mp.is_null()); + assert!(!mp.is_not_null()); let mq = mp.offset(1u); - fail_unless!(!mq.is_null()); - fail_unless!(mq.is_not_null()); + assert!(!mq.is_null()); + assert!(mq.is_not_null()); } #[cfg(test)] @@ -462,11 +462,11 @@ pub mod ptr_tests { debug!( "test_ptr_array_each e: %s, a: %s", expected, actual); - fail_unless!(actual == expected); + assert!(actual == expected); ctr += 1; iteration_count += 1; }); - fail_unless!(iteration_count == 3u); + assert!(iteration_count == 3u); } } #[test] @@ -494,11 +494,11 @@ pub mod ptr_tests { debug!( "test_ptr_array_each e: %s, a: %s", expected, actual); - fail_unless!(actual == expected); + assert!(actual == expected); ctr += 1; iteration_count += 1; }); - fail_unless!(iteration_count == 3); + assert!(iteration_count == 3); } } #[test] diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs index 687d9030d45e7..a4e53418fc88e 100644 --- a/src/libcore/rand.rs +++ b/src/libcore/rand.rs @@ -240,7 +240,7 @@ impl RngUtil for @Rng { * failing if start >= end */ fn gen_int_range(&self, start: int, end: int) -> int { - fail_unless!(start < end); + assert!(start < end); start + int::abs(self.gen_int() % (end - start)) } @@ -274,7 +274,7 @@ impl RngUtil for @Rng { * failing if start >= end */ fn gen_uint_range(&self, start: uint, end: uint) -> uint { - fail_unless!(start < end); + assert!(start < end); start + (self.gen_uint() % (end - start)) } @@ -326,7 +326,7 @@ impl RngUtil for @Rng { * Return a char randomly chosen from chars, failing if chars is empty */ fn gen_char_from(&self, chars: &str) -> char { - fail_unless!(!chars.is_empty()); + assert!(!chars.is_empty()); let mut cs = ~[]; for str::each_char(chars) |c| { cs.push(c) } self.choose(cs) @@ -582,7 +582,7 @@ pub mod tests { let seed = rand::seed(); let ra = rand::seeded_rng(seed); let rb = rand::seeded_rng(seed); - fail_unless!(ra.gen_str(100u) == rb.gen_str(100u)); + assert!(ra.gen_str(100u) == rb.gen_str(100u)); } #[test] @@ -591,7 +591,7 @@ pub mod tests { let seed = [2u8, 32u8, 4u8, 32u8, 51u8]; let ra = rand::seeded_rng(seed); let rb = rand::seeded_rng(seed); - fail_unless!(ra.gen_str(100u) == rb.gen_str(100u)); + assert!(ra.gen_str(100u) == rb.gen_str(100u)); } #[test] @@ -601,7 +601,7 @@ pub mod tests { // Regression test that isaac is actually using the above vector let r = ra.next(); error!("%?", r); - fail_unless!(r == 890007737u32 // on x86_64 + assert!(r == 890007737u32 // on x86_64 || r == 2935188040u32); // on x86 } @@ -609,9 +609,9 @@ pub mod tests { pub fn gen_int_range() { let r = rand::Rng(); let a = r.gen_int_range(-3, 42); - fail_unless!(a >= -3 && a < 42); - fail_unless!(r.gen_int_range(0, 1) == 0); - fail_unless!(r.gen_int_range(-12, -11) == -12); + assert!(a >= -3 && a < 42); + assert!(r.gen_int_range(0, 1) == 0); + assert!(r.gen_int_range(-12, -11) == -12); } #[test] @@ -625,9 +625,9 @@ pub mod tests { pub fn gen_uint_range() { let r = rand::Rng(); let a = r.gen_uint_range(3u, 42u); - fail_unless!(a >= 3u && a < 42u); - fail_unless!(r.gen_uint_range(0u, 1u) == 0u); - fail_unless!(r.gen_uint_range(12u, 13u) == 12u); + assert!(a >= 3u && a < 42u); + assert!(r.gen_uint_range(0u, 1u) == 0u); + assert!(r.gen_uint_range(12u, 13u) == 12u); } #[test] @@ -648,8 +648,8 @@ pub mod tests { #[test] pub fn gen_weighted_bool() { let r = rand::Rng(); - fail_unless!(r.gen_weighted_bool(0u) == true); - fail_unless!(r.gen_weighted_bool(1u) == true); + assert!(r.gen_weighted_bool(0u) == true); + assert!(r.gen_weighted_bool(1u) == true); } #[test] @@ -658,40 +658,40 @@ pub mod tests { debug!(r.gen_str(10u)); debug!(r.gen_str(10u)); debug!(r.gen_str(10u)); - fail_unless!(r.gen_str(0u).len() == 0u); - fail_unless!(r.gen_str(10u).len() == 10u); - fail_unless!(r.gen_str(16u).len() == 16u); + assert!(r.gen_str(0u).len() == 0u); + assert!(r.gen_str(10u).len() == 10u); + assert!(r.gen_str(16u).len() == 16u); } #[test] pub fn gen_bytes() { let r = rand::Rng(); - fail_unless!(r.gen_bytes(0u).len() == 0u); - fail_unless!(r.gen_bytes(10u).len() == 10u); - fail_unless!(r.gen_bytes(16u).len() == 16u); + assert!(r.gen_bytes(0u).len() == 0u); + assert!(r.gen_bytes(10u).len() == 10u); + assert!(r.gen_bytes(16u).len() == 16u); } #[test] pub fn choose() { let r = rand::Rng(); - fail_unless!(r.choose([1, 1, 1]) == 1); + assert!(r.choose([1, 1, 1]) == 1); } #[test] pub fn choose_option() { let r = rand::Rng(); let x: Option = r.choose_option([]); - fail_unless!(x.is_none()); - fail_unless!(r.choose_option([1, 1, 1]) == Some(1)); + assert!(x.is_none()); + assert!(r.choose_option([1, 1, 1]) == Some(1)); } #[test] pub fn choose_weighted() { let r = rand::Rng(); - fail_unless!(r.choose_weighted(~[ + assert!(r.choose_weighted(~[ rand::Weighted { weight: 1u, item: 42 }, ]) == 42); - fail_unless!(r.choose_weighted(~[ + assert!(r.choose_weighted(~[ rand::Weighted { weight: 0u, item: 42 }, rand::Weighted { weight: 1u, item: 43 }, ]) == 43); @@ -700,23 +700,23 @@ pub mod tests { #[test] pub fn choose_weighted_option() { let r = rand::Rng(); - fail_unless!(r.choose_weighted_option(~[ + assert!(r.choose_weighted_option(~[ rand::Weighted { weight: 1u, item: 42 }, ]) == Some(42)); - fail_unless!(r.choose_weighted_option(~[ + assert!(r.choose_weighted_option(~[ rand::Weighted { weight: 0u, item: 42 }, rand::Weighted { weight: 1u, item: 43 }, ]) == Some(43)); let v: Option = r.choose_weighted_option([]); - fail_unless!(v.is_none()); + assert!(v.is_none()); } #[test] pub fn weighted_vec() { let r = rand::Rng(); let empty: ~[int] = ~[]; - fail_unless!(r.weighted_vec(~[]) == empty); - fail_unless!(r.weighted_vec(~[ + assert!(r.weighted_vec(~[]) == empty); + assert!(r.weighted_vec(~[ rand::Weighted { weight: 0u, item: 3u }, rand::Weighted { weight: 1u, item: 2u }, rand::Weighted { weight: 2u, item: 1u }, @@ -727,16 +727,16 @@ pub mod tests { pub fn shuffle() { let r = rand::Rng(); let empty: ~[int] = ~[]; - fail_unless!(r.shuffle(~[]) == empty); - fail_unless!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]); + assert!(r.shuffle(~[]) == empty); + assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]); } #[test] pub fn task_rng() { let r = rand::task_rng(); r.gen_int(); - fail_unless!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]); - fail_unless!(r.gen_uint_range(0u, 1u) == 0u); + assert!(r.shuffle(~[1, 1, 1]) == ~[1, 1, 1]); + assert!(r.gen_uint_range(0u, 1u) == 0u); } #[test] diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs index de3c81b5361ed..a51f874f3712c 100644 --- a/src/libcore/repr.rs +++ b/src/libcore/repr.rs @@ -229,7 +229,7 @@ pub impl ReprVisitor { } else if mtbl == 1 { // skip, this is ast::m_imm } else { - fail_unless!(mtbl == 2); + assert!(mtbl == 2); self.writer.write_str("const "); } } @@ -591,7 +591,7 @@ fn test_repr() { error!("expected '%s', got '%s'", e, s); } - fail_unless!(s == e); + assert!(s == e); } exact_test(&10, "10"); diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 0a2c803ff0714..24822f52e1e84 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -294,7 +294,7 @@ pub impl Result { * else { return ok(x+1u); } * } * map(~[1u, 2u, 3u], inc_conditionally).chain {|incd| - * fail_unless!(incd == ~[2u, 3u, 4u]); + * assert!(incd == ~[2u, 3u, 4u]); * } */ #[inline(always)] @@ -337,7 +337,7 @@ pub fn map_opt( pub fn map_vec2(ss: &[S], ts: &[T], op: &fn(&S,&T) -> Result) -> Result<~[V],U> { - fail_unless!(vec::same_length(ss, ts)); + assert!(vec::same_length(ss, ts)); let n = vec::len(ts); let mut vs = vec::with_capacity(n); let mut i = 0u; @@ -360,7 +360,7 @@ pub fn map_vec2(ss: &[S], ts: &[T], pub fn iter_vec2(ss: &[S], ts: &[T], op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> { - fail_unless!(vec::same_length(ss, ts)); + assert!(vec::same_length(ss, ts)); let n = vec::len(ts); let mut i = 0u; while i < n { @@ -407,50 +407,50 @@ mod tests { #[test] pub fn chain_success() { - fail_unless!(get(&chain(op1(), op2)) == 667u); + assert!(get(&chain(op1(), op2)) == 667u); } #[test] pub fn chain_failure() { - fail_unless!(get_err(&chain(op3(), op2)) == ~"sadface"); + assert!(get_err(&chain(op3(), op2)) == ~"sadface"); } #[test] pub fn test_impl_iter() { let mut valid = false; Ok::<~str, ~str>(~"a").iter(|_x| valid = true); - fail_unless!(valid); + assert!(valid); Err::<~str, ~str>(~"b").iter(|_x| valid = false); - fail_unless!(valid); + assert!(valid); } #[test] pub fn test_impl_iter_err() { let mut valid = true; Ok::<~str, ~str>(~"a").iter_err(|_x| valid = false); - fail_unless!(valid); + assert!(valid); valid = false; Err::<~str, ~str>(~"b").iter_err(|_x| valid = true); - fail_unless!(valid); + assert!(valid); } #[test] pub fn test_impl_map() { - fail_unless!(Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b")); - fail_unless!(Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a")); + assert!(Ok::<~str, ~str>(~"a").map(|_x| ~"b") == Ok(~"b")); + assert!(Err::<~str, ~str>(~"a").map(|_x| ~"b") == Err(~"a")); } #[test] pub fn test_impl_map_err() { - fail_unless!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a")); - fail_unless!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b")); + assert!(Ok::<~str, ~str>(~"a").map_err(|_x| ~"b") == Ok(~"a")); + assert!(Err::<~str, ~str>(~"a").map_err(|_x| ~"b") == Err(~"b")); } #[test] pub fn test_get_ref_method() { let foo: Result = Ok(100); - fail_unless!(*foo.get_ref() == 100); + assert!(*foo.get_ref() == 100); } } diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs index 5034ffa3c6045..46ea5713e2af3 100644 --- a/src/libcore/rt/sched.rs +++ b/src/libcore/rt/sched.rs @@ -93,7 +93,7 @@ pub impl Scheduler { // That will be important for embedding the runtime into external // event loops. fn run(~self) -> ~Scheduler { - fail_unless!(!self.in_task_context()); + assert!(!self.in_task_context()); // Give ownership of the scheduler (self) to the thread do self.install |scheduler| { @@ -129,7 +129,7 @@ pub impl Scheduler { // * Scheduler-context operations fn resume_task_from_queue(&mut self) -> bool { - fail_unless!(!self.in_task_context()); + assert!(!self.in_task_context()); let mut self = self; match self.task_queue.pop_front() { @@ -145,7 +145,7 @@ pub impl Scheduler { } fn resume_task_immediately(&mut self, task: ~Task) { - fail_unless!(!self.in_task_context()); + assert!(!self.in_task_context()); rtdebug!("scheduling a task"); @@ -153,7 +153,7 @@ pub impl Scheduler { self.current_task = Some(task); self.swap_in_task(); // The running task should have passed ownership elsewhere - fail_unless!(self.current_task.is_none()); + assert!(self.current_task.is_none()); // Running tasks may have asked us to do some cleanup self.run_cleanup_jobs(); @@ -165,7 +165,7 @@ pub impl Scheduler { /// Called by a running task to end execution, after which it will /// be recycled by the scheduler for reuse in a new task. fn terminate_current_task(&mut self) { - fail_unless!(self.in_task_context()); + assert!(self.in_task_context()); rtdebug!("ending running task"); @@ -184,7 +184,7 @@ pub impl Scheduler { /// running task. It gets transmuted to the scheduler's lifetime /// and called while the task is blocked. fn block_running_task_and_then(&mut self, f: &fn(&mut Scheduler, ~Task)) { - fail_unless!(self.in_task_context()); + assert!(self.in_task_context()); rtdebug!("blocking task"); @@ -203,7 +203,7 @@ pub impl Scheduler { /// You would want to think hard about doing this, e.g. if there are /// pending I/O events it would be a bad idea. fn resume_task_from_running_task_direct(&mut self, next_task: ~Task) { - fail_unless!(self.in_task_context()); + assert!(self.in_task_context()); rtdebug!("switching tasks"); @@ -255,7 +255,7 @@ pub impl Scheduler { } fn run_cleanup_jobs(&mut self) { - fail_unless!(!self.in_task_context()); + assert!(!self.in_task_context()); rtdebug!("running cleanup jobs"); while !self.cleanup_jobs.is_empty() { @@ -273,7 +273,7 @@ pub impl Scheduler { // XXX: Hack. This should return &'self mut but I don't know how to // make the borrowcheck happy fn task_from_last_cleanup_job(&mut self) -> &mut Task { - fail_unless!(!self.cleanup_jobs.is_empty()); + assert!(!self.cleanup_jobs.is_empty()); let last_job: &'self mut CleanupJob = &mut self.cleanup_jobs[0]; let last_task: &'self Task = match last_job { &RescheduleTask(~ref task) => task, @@ -358,7 +358,7 @@ impl ThreadLocalScheduler { unsafe { let key = match self { &ThreadLocalScheduler(key) => key }; let mut value: *mut c_void = tls::get(key); - fail_unless!(value.is_not_null()); + assert!(value.is_not_null()); { let value_ptr = &mut value; let sched: &mut ~Scheduler = { @@ -374,7 +374,7 @@ impl ThreadLocalScheduler { unsafe { let key = match self { &ThreadLocalScheduler(key) => key }; let value: *mut c_void = tls::get(key); - fail_unless!(value.is_not_null()); + assert!(value.is_not_null()); let sched = transmute(value); tls::set(key, mut_null()); return sched; @@ -430,7 +430,7 @@ fn test_simple_scheduling() { }; sched.task_queue.push_back(task); sched.run(); - fail_unless!(task_ran); + assert!(task_ran); } } @@ -449,7 +449,7 @@ fn test_several_tasks() { sched.task_queue.push_back(task); } sched.run(); - fail_unless!(task_count == total); + assert!(task_count == total); } } @@ -473,7 +473,7 @@ fn test_swap_tasks() { }; sched.task_queue.push_back(task1); sched.run(); - fail_unless!(count == 3); + assert!(count == 3); } } @@ -492,7 +492,7 @@ fn test_run_a_lot_of_tasks_queued() { sched.task_queue.push_back(start_task); sched.run(); - fail_unless!(count == MAX); + assert!(count == MAX); fn run_task(count_ptr: *mut int) { do Scheduler::local |sched| { @@ -525,7 +525,7 @@ fn test_run_a_lot_of_tasks_direct() { sched.task_queue.push_back(start_task); sched.run(); - fail_unless!(count == MAX); + assert!(count == MAX); fn run_task(count_ptr: *mut int) { do Scheduler::local |sched| { @@ -550,9 +550,9 @@ fn test_block_task() { let mut sched = ~UvEventLoop::new_scheduler(); let task = ~do Task::new(&mut sched.stack_pool) { do Scheduler::local |sched| { - fail_unless!(sched.in_task_context()); + assert!(sched.in_task_context()); do sched.block_running_task_and_then() |sched, task| { - fail_unless!(!sched.in_task_context()); + assert!(!sched.in_task_context()); sched.task_queue.push_back(task); } } diff --git a/src/libcore/rt/thread_local_storage.rs b/src/libcore/rt/thread_local_storage.rs index 80635560380ab..76111328b3ade 100644 --- a/src/libcore/rt/thread_local_storage.rs +++ b/src/libcore/rt/thread_local_storage.rs @@ -21,12 +21,12 @@ pub type Key = pthread_key_t; #[cfg(unix)] pub unsafe fn create(key: &mut Key) { - unsafe { fail_unless!(0 == pthread_key_create(key, null())); } + unsafe { assert!(0 == pthread_key_create(key, null())); } } #[cfg(unix)] pub unsafe fn set(key: Key, value: *mut c_void) { - unsafe { fail_unless!(0 == pthread_setspecific(key, value)); } + unsafe { assert!(0 == pthread_setspecific(key, value)); } } #[cfg(unix)] @@ -58,12 +58,12 @@ pub type Key = DWORD; pub unsafe fn create(key: &mut Key) { static TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF; *key = unsafe { TlsAlloc() }; - fail_unless!(*key != TLS_OUT_OF_INDEXES); + assert!(*key != TLS_OUT_OF_INDEXES); } #[cfg(windows)] pub unsafe fn set(key: Key, value: *mut c_void) { - unsafe { fail_unless!(0 != TlsSetValue(key, value)) } + unsafe { assert!(0 != TlsSetValue(key, value)) } } #[cfg(windows)] @@ -88,10 +88,10 @@ fn tls_smoke_test() { create(&mut key); set(key, transmute(value)); let value: ~int = transmute(get(key)); - fail_unless!(value == ~20); + assert!(value == ~20); let value = ~30; set(key, transmute(value)); let value: ~int = transmute(get(key)); - fail_unless!(value == ~30); + assert!(value == ~30); } } diff --git a/src/libcore/rt/uv/file.rs b/src/libcore/rt/uv/file.rs index 7df06f87dfe41..a4aef7485d737 100644 --- a/src/libcore/rt/uv/file.rs +++ b/src/libcore/rt/uv/file.rs @@ -25,7 +25,7 @@ impl Request for FsRequest; impl FsRequest { fn new() -> FsRequest { let fs_req = unsafe { malloc_req(UV_FS) }; - fail_unless!(fs_req.is_not_null()); + assert!(fs_req.is_not_null()); let fs_req = fs_req as *uvll::uv_write_t; unsafe { uvll::set_data_for_req(fs_req, null::<()>()); } NativeHandle::from_native_handle(fs_req) diff --git a/src/libcore/rt/uv/mod.rs b/src/libcore/rt/uv/mod.rs index 2bd5023f22fa5..32757d6376e73 100644 --- a/src/libcore/rt/uv/mod.rs +++ b/src/libcore/rt/uv/mod.rs @@ -89,7 +89,7 @@ pub struct Loop { pub impl Loop { fn new() -> Loop { let handle = unsafe { uvll::loop_new() }; - fail_unless!(handle.is_not_null()); + assert!(handle.is_not_null()); NativeHandle::from_native_handle(handle) } @@ -126,8 +126,8 @@ pub impl IdleWatcher { fn new(loop_: &mut Loop) -> IdleWatcher { unsafe { let handle = uvll::idle_new(); - fail_unless!(handle.is_not_null()); - fail_unless!(0 == uvll::idle_init(loop_.native_handle(), handle)); + assert!(handle.is_not_null()); + assert!(0 == uvll::idle_init(loop_.native_handle(), handle)); uvll::set_data_for_uv_handle(handle, null::<()>()); NativeHandle::from_native_handle(handle) } @@ -137,7 +137,7 @@ pub impl IdleWatcher { set_watcher_callback(self, cb); unsafe { - fail_unless!(0 == uvll::idle_start(self.native_handle(), idle_cb)) + assert!(0 == uvll::idle_start(self.native_handle(), idle_cb)) }; extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) { @@ -149,7 +149,7 @@ pub impl IdleWatcher { } fn stop(&mut self) { - unsafe { fail_unless!(0 == uvll::idle_stop(self.native_handle())); } + unsafe { assert!(0 == uvll::idle_stop(self.native_handle())); } } fn close(self) { @@ -183,7 +183,7 @@ pub impl UvError { unsafe { let inner = match self { &UvError(ref a) => a }; let name_str = uvll::err_name(inner); - fail_unless!(name_str.is_not_null()); + assert!(name_str.is_not_null()); from_c_str(name_str) } } @@ -192,7 +192,7 @@ pub impl UvError { unsafe { let inner = match self { &UvError(ref a) => a }; let desc_str = uvll::strerror(inner); - fail_unless!(desc_str.is_not_null()); + assert!(desc_str.is_not_null()); from_c_str(desc_str) } } @@ -208,7 +208,7 @@ impl ToStr for UvError { fn error_smoke_test() { let err = uvll::uv_err_t { code: 1, sys_errno_: 1 }; let err: UvError = UvError(err); - fail_unless!(err.to_str() == ~"EOF: end of file"); + assert!(err.to_str() == ~"EOF: end of file"); } @@ -274,7 +274,7 @@ pub fn borrow_callback_from_watcher, unsafe { let handle = watcher.native_handle(); let handle_data: *c_void = uvll::get_data_for_uv_handle(handle); - fail_unless!(handle_data.is_not_null()); + assert!(handle_data.is_not_null()); let cb = transmute::<&*c_void, &~CB>(&handle_data); return &**cb; } @@ -287,7 +287,7 @@ pub fn take_callback_from_watcher, CB: Callback unsafe { let handle = watcher.native_handle(); let handle_data: *c_void = uvll::get_data_for_uv_handle(handle); - fail_unless!(handle_data.is_not_null()); + assert!(handle_data.is_not_null()); uvll::set_data_for_uv_handle(handle, null::<()>()); let cb: ~CB = transmute::<*c_void, ~CB>(handle_data); let cb = match cb { ~cb => cb }; @@ -341,7 +341,7 @@ fn test_slice_to_uv_buf() { let slice = [0, .. 20]; let buf = slice_to_uv_buf(slice); - fail_unless!(buf.len == 20); + assert!(buf.len == 20); unsafe { let base = transmute::<*u8, *mut u8>(buf.base); @@ -349,8 +349,8 @@ fn test_slice_to_uv_buf() { (*ptr::mut_offset(base, 1)) = 2; } - fail_unless!(slice[0] == 1); - fail_unless!(slice[1] == 2); + assert!(slice[0] == 1); + assert!(slice[1] == 2); } /// The uv buffer type @@ -367,7 +367,7 @@ pub fn slice_to_uv_buf(v: &[u8]) -> Buf { /// Transmute an owned vector to a Buf pub fn vec_to_uv_buf(v: ~[u8]) -> Buf { let data = unsafe { malloc(v.len() as size_t) } as *u8; - fail_unless!(data.is_not_null()); + assert!(data.is_not_null()); do vec::as_imm_buf(v) |b, l| { let data = data as *mut u8; unsafe { ptr::copy_memory(data, b, l) } @@ -416,7 +416,7 @@ fn idle_smoke_test() { let count_ptr: *mut int = &mut count; do idle_watcher.start |idle_watcher, status| { let mut idle_watcher = idle_watcher; - fail_unless!(status.is_none()); + assert!(status.is_none()); if unsafe { *count_ptr == 10 } { idle_watcher.stop(); idle_watcher.close(); @@ -426,7 +426,7 @@ fn idle_smoke_test() { } loop_.run(); loop_.close(); - fail_unless!(count == 10); + assert!(count == 10); } } @@ -437,10 +437,10 @@ fn idle_start_stop_start() { let mut idle_watcher = { IdleWatcher::new(&mut loop_) }; do idle_watcher.start |idle_watcher, status| { let mut idle_watcher = idle_watcher; - fail_unless!(status.is_none()); + assert!(status.is_none()); idle_watcher.stop(); do idle_watcher.start |idle_watcher, status| { - fail_unless!(status.is_none()); + assert!(status.is_none()); let mut idle_watcher = idle_watcher; idle_watcher.stop(); idle_watcher.close(); diff --git a/src/libcore/rt/uv/net.rs b/src/libcore/rt/uv/net.rs index 697b4ad94c1df..edd3b379fbcc4 100644 --- a/src/libcore/rt/uv/net.rs +++ b/src/libcore/rt/uv/net.rs @@ -104,7 +104,7 @@ pub impl StreamWatcher { fn write(&mut self, msg: ~[u8], cb: ConnectionCallback) { // XXX: Borrowck let data = get_watcher_data(unsafe { transmute_mut_region(self) }); - fail_unless!(data.write_cb.is_none()); + assert!(data.write_cb.is_none()); data.write_cb = Some(cb); let req = WriteRequest::new(); @@ -112,7 +112,7 @@ pub impl StreamWatcher { // XXX: Allocation let bufs = ~[buf]; unsafe { - fail_unless!(0 == uvll::write(req.native_handle(), + assert!(0 == uvll::write(req.native_handle(), self.native_handle(), &bufs, write_cb)); } @@ -133,7 +133,7 @@ pub impl StreamWatcher { let self_handle = self.native_handle() as *c_void; let stream_handle = stream.native_handle() as *c_void; unsafe { - fail_unless!(0 == uvll::accept(self_handle, stream_handle)); + assert!(0 == uvll::accept(self_handle, stream_handle)); } } @@ -141,7 +141,7 @@ pub impl StreamWatcher { { let mut self = self; let data = get_watcher_data(&mut self); - fail_unless!(data.close_cb.is_none()); + assert!(data.close_cb.is_none()); data.close_cb = Some(cb); } @@ -184,8 +184,8 @@ pub impl TcpWatcher { fn new(loop_: &mut Loop) -> TcpWatcher { unsafe { let handle = malloc_handle(UV_TCP); - fail_unless!(handle.is_not_null()); - fail_unless!(0 == uvll::tcp_init(loop_.native_handle(), handle)); + assert!(handle.is_not_null()); + assert!(0 == uvll::tcp_init(loop_.native_handle(), handle)); let mut watcher = NativeHandle::from_native_handle(handle); install_watcher_data(&mut watcher); return watcher; @@ -200,7 +200,7 @@ pub impl TcpWatcher { uvll::tcp_bind(self.native_handle(), addr) }; // XXX: bind is likely to fail. need real error handling - fail_unless!(result == 0); + assert!(result == 0); } } _ => fail!() @@ -209,7 +209,7 @@ pub impl TcpWatcher { fn connect(&mut self, address: IpAddr, cb: ConnectionCallback) { unsafe { - fail_unless!(get_watcher_data(self).connect_cb.is_none()); + assert!(get_watcher_data(self).connect_cb.is_none()); get_watcher_data(self).connect_cb = Some(cb); let mut connect_watcher = ConnectRequest::new(); @@ -218,7 +218,7 @@ pub impl TcpWatcher { Ipv4(*) => { do ip4_as_uv_ip4(address) |addr| { rtdebug!("connect_t: %x", connect_handle as uint); - fail_unless!(0 == uvll::tcp_connect(connect_handle, + assert!(0 == uvll::tcp_connect(connect_handle, self.native_handle(), addr, connect_cb)); } @@ -244,13 +244,13 @@ pub impl TcpWatcher { fn listen(&mut self, cb: ConnectionCallback) { // XXX: Borrowck let data = get_watcher_data(unsafe { transmute_mut_region(self) }); - fail_unless!(data.connect_cb.is_none()); + assert!(data.connect_cb.is_none()); data.connect_cb = Some(cb); unsafe { static BACKLOG: c_int = 128; // XXX should be configurable // XXX: This can probably fail - fail_unless!(0 == uvll::listen(self.native_handle(), + assert!(0 == uvll::listen(self.native_handle(), BACKLOG, connection_cb)); } @@ -291,7 +291,7 @@ impl ConnectRequest { let connect_handle = unsafe { malloc_req(UV_CONNECT) }; - fail_unless!(connect_handle.is_not_null()); + assert!(connect_handle.is_not_null()); let connect_handle = connect_handle as *uvll::uv_connect_t; ConnectRequest(connect_handle) } @@ -328,7 +328,7 @@ pub impl WriteRequest { let write_handle = unsafe { malloc_req(UV_WRITE) }; - fail_unless!(write_handle.is_not_null()); + assert!(write_handle.is_not_null()); let write_handle = write_handle as *uvll::uv_write_t; WriteRequest(write_handle) } @@ -365,8 +365,8 @@ fn connect_close() { let addr = Ipv4(127, 0, 0, 1, 2923); do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("tcp_watcher.connect!"); - fail_unless!(status.is_some()); - fail_unless!(status.get().name() == ~"ECONNREFUSED"); + assert!(status.is_some()); + assert!(status.get().name() == ~"ECONNREFUSED"); stream_watcher.close(||()); } loop_.run(); @@ -384,7 +384,7 @@ fn connect_read() { do tcp_watcher.connect(addr) |stream_watcher, status| { let mut stream_watcher = stream_watcher; rtdebug!("tcp_watcher.connect!"); - fail_unless!(status.is_none()); + assert!(status.is_none()); let alloc: AllocCallback = |size| { vec_to_uv_buf(vec::from_elem(size, 0)) }; @@ -421,7 +421,7 @@ fn listen() { rtdebug!("listening"); do server_tcp_watcher.listen |server_stream_watcher, status| { rtdebug!("listened!"); - fail_unless!(status.is_none()); + assert!(status.is_none()); let mut server_stream_watcher = server_stream_watcher; let mut loop_ = loop_; let mut client_tcp_watcher = TcpWatcher::new(&mut loop_); @@ -443,12 +443,12 @@ fn listen() { rtdebug!("got %d bytes", nread); let buf = buf.unwrap(); for buf.slice(0, nread as uint).each |byte| { - fail_unless!(*byte == count as u8); + assert!(*byte == count as u8); rtdebug!("%u", *byte as uint); count += 1; } } else { - fail_unless!(count == MAX); + assert!(count == MAX); do stream_watcher.close { server_stream_watcher.close(||()); } @@ -463,12 +463,12 @@ fn listen() { let mut tcp_watcher = { TcpWatcher::new(&mut loop_) }; do tcp_watcher.connect(addr) |stream_watcher, status| { rtdebug!("connecting"); - fail_unless!(status.is_none()); + assert!(status.is_none()); let mut stream_watcher = stream_watcher; let msg = ~[0, 1, 2, 3, 4, 5, 6 ,7 ,8, 9]; do stream_watcher.write(msg) |stream_watcher, status| { rtdebug!("writing"); - fail_unless!(status.is_none()); + assert!(status.is_none()); stream_watcher.close(||()); } } diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs index bcad67c0c94ff..37f29d1a5c0fe 100644 --- a/src/libcore/rt/uvio.rs +++ b/src/libcore/rt/uvio.rs @@ -59,7 +59,7 @@ impl EventLoop for UvEventLoop { fn callback(&mut self, f: ~fn()) { let mut idle_watcher = IdleWatcher::new(self.uvio.uv_loop()); do idle_watcher.start |idle_watcher, status| { - fail_unless!(status.is_none()); + assert!(status.is_none()); let mut idle_watcher = idle_watcher; idle_watcher.stop(); idle_watcher.close(); @@ -82,7 +82,7 @@ fn test_callback_run_once() { unsafe { *count_ptr += 1 } } event_loop.run(); - fail_unless!(count == 1); + assert!(count == 1); } } @@ -105,13 +105,13 @@ impl IoFactory for UvIoFactory { let result_cell_ptr: *Cell> = &result_cell; do Scheduler::local |scheduler| { - fail_unless!(scheduler.in_task_context()); + assert!(scheduler.in_task_context()); // Block this task and take ownership, switch to scheduler context do scheduler.block_running_task_and_then |scheduler, task| { rtdebug!("connect: entered scheduler context"); - fail_unless!(!scheduler.in_task_context()); + assert!(!scheduler.in_task_context()); let mut tcp_watcher = TcpWatcher::new(self.uv_loop()); let task_cell = Cell(task); @@ -138,7 +138,7 @@ impl IoFactory for UvIoFactory { } } - fail_unless!(!result_cell.is_empty()); + assert!(!result_cell.is_empty()); return result_cell.take(); } @@ -179,7 +179,7 @@ impl TcpListener for UvTcpListener { let server_tcp_watcher = self.watcher(); do Scheduler::local |scheduler| { - fail_unless!(scheduler.in_task_context()); + assert!(scheduler.in_task_context()); do scheduler.block_running_task_and_then |_, task| { let task_cell = Cell(task); @@ -208,7 +208,7 @@ impl TcpListener for UvTcpListener { } } - fail_unless!(!result_cell.is_empty()); + assert!(!result_cell.is_empty()); return result_cell.take(); } } @@ -244,12 +244,12 @@ impl Stream for UvStream { let result_cell_ptr: *Cell> = &result_cell; do Scheduler::local |scheduler| { - fail_unless!(scheduler.in_task_context()); + assert!(scheduler.in_task_context()); let watcher = self.watcher(); let buf_ptr: *&mut [u8] = &buf; do scheduler.block_running_task_and_then |scheduler, task| { rtdebug!("read: entered scheduler context"); - fail_unless!(!scheduler.in_task_context()); + assert!(!scheduler.in_task_context()); let mut watcher = watcher; let task_cell = Cell(task); // XXX: We shouldn't reallocate these callbacks every @@ -267,7 +267,7 @@ impl Stream for UvStream { watcher.read_stop(); let result = if status.is_none() { - fail_unless!(nread >= 0); + assert!(nread >= 0); Ok(nread as uint) } else { Err(()) @@ -282,7 +282,7 @@ impl Stream for UvStream { } } - fail_unless!(!result_cell.is_empty()); + assert!(!result_cell.is_empty()); return result_cell.take(); } @@ -290,7 +290,7 @@ impl Stream for UvStream { let result_cell = empty_cell(); let result_cell_ptr: *Cell> = &result_cell; do Scheduler::local |scheduler| { - fail_unless!(scheduler.in_task_context()); + assert!(scheduler.in_task_context()); let watcher = self.watcher(); let buf_ptr: *&[u8] = &buf; do scheduler.block_running_task_and_then |_, task| { @@ -315,7 +315,7 @@ impl Stream for UvStream { } } - fail_unless!(!result_cell.is_empty()); + assert!(!result_cell.is_empty()); return result_cell.take(); } } @@ -330,7 +330,7 @@ fn test_simple_io_no_connect() { let io = sched.event_loop.io().unwrap(); let addr = Ipv4(127, 0, 0, 1, 2926); let maybe_chan = io.connect(addr); - fail_unless!(maybe_chan.is_none()); + assert!(maybe_chan.is_none()); } }; sched.task_queue.push_back(task); @@ -361,10 +361,10 @@ fn test_simple_tcp_server_and_client() { let mut stream = listener.listen().unwrap(); let mut buf = [0, .. 2048]; let nread = stream.read(buf).unwrap(); - fail_unless!(nread == 8); + assert!(nread == 8); for uint::range(0, nread) |i| { rtdebug!("%u", buf[i] as uint); - fail_unless!(buf[i] == i as u8); + assert!(buf[i] == i as u8); } stream.close(); listener.close(); @@ -411,7 +411,7 @@ fn test_read_and_block() { let nread = stream.read(buf).unwrap(); for uint::range(0, nread) |i| { let val = buf[i] as uint; - fail_unless!(val == current % 8); + assert!(val == current % 8); current += 1; } reads += 1; @@ -427,7 +427,7 @@ fn test_read_and_block() { } // Make sure we had multiple reads - fail_unless!(reads > 1); + assert!(reads > 1); stream.close(); listener.close(); diff --git a/src/libcore/rt/uvll.rs b/src/libcore/rt/uvll.rs index 4eaf9dcf40a76..640a69743ba6a 100644 --- a/src/libcore/rt/uvll.rs +++ b/src/libcore/rt/uvll.rs @@ -97,10 +97,10 @@ pub enum uv_req_type { } pub unsafe fn malloc_handle(handle: uv_handle_type) -> *c_void { - fail_unless!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX); + assert!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX); let size = unsafe { rust_uv_handle_size(handle as uint) }; let p = malloc(size); - fail_unless!(p.is_not_null()); + assert!(p.is_not_null()); return p; } @@ -109,10 +109,10 @@ pub unsafe fn free_handle(v: *c_void) { } pub unsafe fn malloc_req(req: uv_req_type) -> *c_void { - fail_unless!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX); + assert!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX); let size = unsafe { rust_uv_req_size(req as uint) }; let p = malloc(size); - fail_unless!(p.is_not_null()); + assert!(p.is_not_null()); return p; } @@ -123,14 +123,14 @@ pub unsafe fn free_req(v: *c_void) { #[test] fn handle_sanity_check() { unsafe { - fail_unless!(UV_HANDLE_TYPE_MAX as uint == rust_uv_handle_type_max()); + assert!(UV_HANDLE_TYPE_MAX as uint == rust_uv_handle_type_max()); } } #[test] fn request_sanity_check() { unsafe { - fail_unless!(UV_REQ_TYPE_MAX as uint == rust_uv_req_type_max()); + assert!(UV_REQ_TYPE_MAX as uint == rust_uv_req_type_max()); } } diff --git a/src/libcore/run.rs b/src/libcore/run.rs index 959ab23a46193..8116ea952e425 100644 --- a/src/libcore/run.rs +++ b/src/libcore/run.rs @@ -495,7 +495,7 @@ mod tests { debug!(copy expected); debug!(copy actual); - fail_unless!((expected == actual)); + assert!((expected == actual)); } #[test] @@ -504,7 +504,7 @@ mod tests { &None, &None, 0i32, 0i32, 0i32); let status = run::waitpid(pid); - fail_unless!(status == 1); + assert!(status == 1); } } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index f73202e16ede4..c54a1048c4603 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -45,7 +45,7 @@ Section: Creating a string * Fails if invalid UTF-8 */ pub fn from_bytes(vv: &const [u8]) -> ~str { - fail_unless!(is_utf8(vv)); + assert!(is_utf8(vv)); return unsafe { raw::from_bytes(vv) }; } @@ -75,7 +75,7 @@ impl ToStr for @str { * Fails if invalid UTF-8 */ pub fn from_byte(b: u8) -> ~str { - fail_unless!(b < 128u8); + assert!(b < 128u8); unsafe { ::cast::transmute(~[b, 0u8]) } } @@ -264,7 +264,7 @@ Section: Adding to and removing from a string */ pub fn pop_char(s: &mut ~str) -> char { let end = len(*s); - fail_unless!(end > 0u); + assert!(end > 0u); let CharRange {ch, next} = char_range_at_reverse(*s, end); unsafe { raw::set_len(s, next); } return ch; @@ -429,8 +429,8 @@ pub fn substr<'a>(s: &'a str, begin: uint, n: uint) -> &'a str { * the last character of the string */ pub fn slice<'a>(s: &'a str, begin: uint, end: uint) -> &'a str { - fail_unless!(is_char_boundary(s, begin)); - fail_unless!(is_char_boundary(s, end)); + assert!(is_char_boundary(s, begin)); + assert!(is_char_boundary(s, end)); unsafe { raw::slice_bytes(s, begin, end) } } @@ -554,7 +554,7 @@ fn each_split_inner<'a>(s: &'a str, // See Issue #1932 for why this is a naive search fn iter_matches<'a,'b>(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) { let sep_len = len(sep), l = len(s); - fail_unless!(sep_len > 0u); + assert!(sep_len > 0u); let mut i = 0u, match_start = 0u, match_i = 0u; while i < l { @@ -598,7 +598,7 @@ fn iter_between_matches<'a,'b>(s: &'a str, * ~~~ * let mut v = ~[]; * for each_split_str(".XXX.YYY.", ".") |subs| { v.push(subs); } - * fail_unless!(v == ["", "XXX", "YYY", ""]); + * assert!(v == ["", "XXX", "YYY", ""]); * ~~~ */ pub fn each_split_str<'a,'b>(s: &'a str, @@ -1179,8 +1179,8 @@ pub fn find_char_from(s: &str, c: char, start: uint) -> Option { pub fn find_char_between(s: &str, c: char, start: uint, end: uint) -> Option { if c < 128u as char { - fail_unless!(start <= end); - fail_unless!(end <= len(s)); + assert!(start <= end); + assert!(end <= len(s)); let mut i = start; let b = c as u8; while i < end { @@ -1257,8 +1257,8 @@ pub fn rfind_char_from(s: &str, c: char, start: uint) -> Option { */ pub fn rfind_char_between(s: &str, c: char, start: uint, end: uint) -> Option { if c < 128u as char { - fail_unless!(start >= end); - fail_unless!(start <= len(s)); + assert!(start >= end); + assert!(start <= len(s)); let mut i = start; let b = c as u8; while i > end { @@ -1337,9 +1337,9 @@ pub fn find_from(s: &str, start: uint, f: &fn(char) * boundary, as defined by `is_char_boundary`. */ pub fn find_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) -> Option { - fail_unless!(start <= end); - fail_unless!(end <= len(s)); - fail_unless!(is_char_boundary(s, start)); + assert!(start <= end); + assert!(end <= len(s)); + assert!(is_char_boundary(s, start)); let mut i = start; while i < end { let CharRange {ch, next} = char_range_at(s, i); @@ -1414,9 +1414,9 @@ pub fn rfind_from(s: &str, start: uint, f: &fn(char) -> bool) -> Option { * boundary, as defined by `is_char_boundary` */ pub fn rfind_between(s: &str, start: uint, end: uint, f: &fn(char) -> bool) -> Option { - fail_unless!(start >= end); - fail_unless!(start <= len(s)); - fail_unless!(is_char_boundary(s, start)); + assert!(start >= end); + assert!(start <= len(s)); + assert!(is_char_boundary(s, start)); let mut i = start; while i > end { let CharRange {ch, next: prev} = char_range_at_reverse(s, i); @@ -1502,7 +1502,7 @@ pub fn find_str_between<'a,'b>(haystack: &'a str, end:uint) -> Option { // See Issue #1932 for why this is a naive search - fail_unless!(end <= len(haystack)); + assert!(end <= len(haystack)); let needle_len = len(needle); if needle_len == 0u { return Some(start); } if needle_len > end { return None; } @@ -1664,11 +1664,11 @@ pub fn to_utf16(s: &str) -> ~[u16] { if (ch & 0xFFFF_u32) == ch { // The BMP falls through (assuming non-surrogate, as it // should) - fail_unless!(ch <= 0xD7FF_u32 || ch >= 0xE000_u32); + assert!(ch <= 0xD7FF_u32 || ch >= 0xE000_u32); u.push(ch as u16) } else { // Supplementary planes break into surrogates. - fail_unless!(ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32); + assert!(ch >= 0x1_0000_u32 && ch <= 0x10_FFFF_u32); ch -= 0x1_0000_u32; let w1 = 0xD800_u16 | ((ch >> 10) as u16); let w2 = 0xDC00_u16 | ((ch as u16) & 0x3FF_u16); @@ -1691,8 +1691,8 @@ pub fn utf16_chars(v: &[u16], f: &fn(char)) { } else { let u2 = v[i+1u]; - fail_unless!(u >= 0xD800_u16 && u <= 0xDBFF_u16); - fail_unless!(u2 >= 0xDC00_u16 && u2 <= 0xDFFF_u16); + assert!(u >= 0xD800_u16 && u <= 0xDBFF_u16); + assert!(u2 >= 0xDC00_u16 && u2 <= 0xDFFF_u16); let mut c = (u - 0xD800_u16) as char; c = c << 10; c |= (u2 - 0xDC00_u16) as char; @@ -1732,8 +1732,8 @@ pub fn with_capacity(capacity: uint) -> ~str { * The number of Unicode characters in `s` between the given indices. */ pub fn count_chars(s: &str, start: uint, end: uint) -> uint { - fail_unless!(is_char_boundary(s, start)); - fail_unless!(is_char_boundary(s, end)); + assert!(is_char_boundary(s, start)); + assert!(is_char_boundary(s, end)); let mut i = start, len = 0u; while i < end { let next = char_range_at(s, i).next; @@ -1745,11 +1745,11 @@ pub fn count_chars(s: &str, start: uint, end: uint) -> uint { /// Counts the number of bytes taken by the `n` in `s` starting from `start`. pub fn count_bytes<'b>(s: &'b str, start: uint, n: uint) -> uint { - fail_unless!(is_char_boundary(s, start)); + assert!(is_char_boundary(s, start)); let mut end = start, cnt = n; let l = len(s); while cnt > 0u { - fail_unless!(end < l); + assert!(end < l); let next = char_range_at(s, end).next; cnt -= 1u; end = next; @@ -1832,14 +1832,14 @@ pub fn is_char_boundary(s: &str, index: uint) -> bool { pub fn char_range_at(s: &str, i: uint) -> CharRange { let b0 = s[i]; let w = utf8_char_width(b0); - fail_unless!((w != 0u)); + assert!((w != 0u)); if w == 1u { return CharRange {ch: b0 as char, next: i + 1u}; } let mut val = 0u; let end = i + w; let mut i = i + 1u; while i < end { let byte = s[i]; - fail_unless!((byte & 192u8 == tag_cont_u8)); + assert!((byte & 192u8 == tag_cont_u8)); val <<= 6u; val += (byte & 63u8) as uint; i += 1u; @@ -1910,7 +1910,7 @@ pub fn char_at_reverse(s: &str, i: uint) -> char { */ pub fn all_between(s: &str, start: uint, end: uint, it: &fn(char) -> bool) -> bool { - fail_unless!(is_char_boundary(s, start)); + assert!(is_char_boundary(s, start)); let mut i = start; while i < end { let CharRange {ch, next} = char_range_at(s, i); @@ -2010,7 +2010,7 @@ pub fn as_bytes_slice<'a>(s: &'a str) -> &'a [u8] { pub fn as_c_str(s: &str, f: &fn(*libc::c_char) -> T) -> T { do as_buf(s) |buf, len| { // NB: len includes the trailing null. - fail_unless!(len > 0); + assert!(len > 0); if unsafe { *(ptr::offset(buf,len-1)) != 0 } { as_c_str(from_slice(s), f) } else { @@ -2090,7 +2090,7 @@ pub fn reserve_at_least(s: &mut ~str, n: uint) { pub fn capacity(s: &const ~str) -> uint { do as_bytes(s) |buf| { let vcap = vec::capacity(buf); - fail_unless!(vcap > 0u); + assert!(vcap > 0u); vcap - 1u } } @@ -2147,7 +2147,7 @@ pub mod raw { vec::raw::set_len(&mut v, len); v.push(0u8); - fail_unless!(is_utf8(v)); + assert!(is_utf8(v)); return ::cast::transmute(v); } @@ -2175,7 +2175,7 @@ pub mod raw { pub unsafe fn buf_as_slice(buf: *u8, len: uint, f: &fn(v: &str) -> T) -> T { let v = (buf, len + 1); - fail_unless!(is_utf8(::cast::reinterpret_cast(&v))); + assert!(is_utf8(::cast::reinterpret_cast(&v))); f(::cast::transmute(v)) } @@ -2191,8 +2191,8 @@ pub mod raw { */ pub unsafe fn slice_bytes_unique(s: &str, begin: uint, end: uint) -> ~str { do as_buf(s) |sbuf, n| { - fail_unless!((begin <= end)); - fail_unless!((end <= n)); + assert!((begin <= end)); + assert!((end <= n)); let mut v = vec::with_capacity(end - begin + 1u); unsafe { @@ -2221,8 +2221,8 @@ pub mod raw { #[inline] pub unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> &str { do as_buf(s) |sbuf, n| { - fail_unless!((begin <= end)); - fail_unless!((end <= n)); + assert!((begin <= end)); + assert!((end <= n)); let tuple = (ptr::offset(sbuf, begin), end - begin + 1); ::cast::reinterpret_cast(&tuple) @@ -2250,7 +2250,7 @@ pub mod raw { /// Removes the last byte from a string and returns it. (Not UTF-8 safe). pub unsafe fn pop_byte(s: &mut ~str) -> u8 { let len = len(*s); - fail_unless!((len > 0u)); + assert!((len > 0u)); let b = s[len - 1u]; unsafe { set_len(s, len - 1u) }; return b; @@ -2259,7 +2259,7 @@ pub mod raw { /// Removes the first byte from a string and returns it. (Not UTF-8 safe). pub unsafe fn shift_byte(s: &mut ~str) -> u8 { let len = len(*s); - fail_unless!((len > 0u)); + assert!((len > 0u)); let b = s[0]; *s = unsafe { raw::slice_bytes_unique(*s, 1u, len) }; return b; @@ -2281,7 +2281,7 @@ pub mod raw { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let b = vec::raw::to_ptr(a); let c = from_buf_len(b, 3u); - fail_unless!((c == ~"AAA")); + assert!((c == ~"AAA")); } } @@ -2572,69 +2572,69 @@ mod tests { #[test] fn test_eq() { - fail_unless!((eq(&~"", &~""))); - fail_unless!((eq(&~"foo", &~"foo"))); - fail_unless!((!eq(&~"foo", &~"bar"))); + assert!((eq(&~"", &~""))); + assert!((eq(&~"foo", &~"foo"))); + assert!((!eq(&~"foo", &~"bar"))); } #[test] fn test_eq_slice() { - fail_unless!((eq_slice(slice("foobar", 0, 3), "foo"))); - fail_unless!((eq_slice(slice("barfoo", 3, 6), "foo"))); - fail_unless!((!eq_slice("foo1", "foo2"))); + assert!((eq_slice(slice("foobar", 0, 3), "foo"))); + assert!((eq_slice(slice("barfoo", 3, 6), "foo"))); + assert!((!eq_slice("foo1", "foo2"))); } #[test] fn test_le() { - fail_unless!((le(&"", &""))); - fail_unless!((le(&"", &"foo"))); - fail_unless!((le(&"foo", &"foo"))); - fail_unless!((!eq(&~"foo", &~"bar"))); + assert!((le(&"", &""))); + assert!((le(&"", &"foo"))); + assert!((le(&"foo", &"foo"))); + assert!((!eq(&~"foo", &~"bar"))); } #[test] fn test_len() { - fail_unless!((len(~"") == 0u)); - fail_unless!((len(~"hello world") == 11u)); - fail_unless!((len(~"\x63") == 1u)); - fail_unless!((len(~"\xa2") == 2u)); - fail_unless!((len(~"\u03c0") == 2u)); - fail_unless!((len(~"\u2620") == 3u)); - fail_unless!((len(~"\U0001d11e") == 4u)); + assert!((len(~"") == 0u)); + assert!((len(~"hello world") == 11u)); + assert!((len(~"\x63") == 1u)); + assert!((len(~"\xa2") == 2u)); + assert!((len(~"\u03c0") == 2u)); + assert!((len(~"\u2620") == 3u)); + assert!((len(~"\U0001d11e") == 4u)); - fail_unless!((char_len(~"") == 0u)); - fail_unless!((char_len(~"hello world") == 11u)); - fail_unless!((char_len(~"\x63") == 1u)); - fail_unless!((char_len(~"\xa2") == 1u)); - fail_unless!((char_len(~"\u03c0") == 1u)); - fail_unless!((char_len(~"\u2620") == 1u)); - fail_unless!((char_len(~"\U0001d11e") == 1u)); - fail_unless!((char_len(~"ประเทศไทย中华Việt Nam") == 19u)); + assert!((char_len(~"") == 0u)); + assert!((char_len(~"hello world") == 11u)); + assert!((char_len(~"\x63") == 1u)); + assert!((char_len(~"\xa2") == 1u)); + assert!((char_len(~"\u03c0") == 1u)); + assert!((char_len(~"\u2620") == 1u)); + assert!((char_len(~"\U0001d11e") == 1u)); + assert!((char_len(~"ประเทศไทย中华Việt Nam") == 19u)); } #[test] fn test_rfind_char() { - fail_unless!(rfind_char(~"hello", 'l') == Some(3u)); - fail_unless!(rfind_char(~"hello", 'o') == Some(4u)); - fail_unless!(rfind_char(~"hello", 'h') == Some(0u)); - fail_unless!(rfind_char(~"hello", 'z').is_none()); - fail_unless!(rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u)); + assert!(rfind_char(~"hello", 'l') == Some(3u)); + assert!(rfind_char(~"hello", 'o') == Some(4u)); + assert!(rfind_char(~"hello", 'h') == Some(0u)); + assert!(rfind_char(~"hello", 'z').is_none()); + assert!(rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u)); } #[test] fn test_pop_char() { let mut data = ~"ประเทศไทย中华"; let cc = pop_char(&mut data); - fail_unless!(~"ประเทศไทย中" == data); - fail_unless!('华' == cc); + assert!(~"ประเทศไทย中" == data); + assert!('华' == cc); } #[test] fn test_pop_char_2() { let mut data2 = ~"华"; let cc2 = pop_char(&mut data2); - fail_unless!(~"" == data2); - fail_unless!('华' == cc2); + assert!(~"" == data2); + assert!('华' == cc2); } #[test] @@ -2652,7 +2652,7 @@ mod tests { let mut v = ~[]; for each_split_char(s, c) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]); t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]); @@ -2670,7 +2670,7 @@ mod tests { let mut v = ~[]; for each_split_char(s, c) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } let data = ~"ประเทศไทย中华Việt Nam"; t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]); @@ -2685,7 +2685,7 @@ mod tests { for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); debug!("comparing vs. %?", u); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"abc.hello.there", '.', 0u, ~[~"abc.hello.there"]); t(~"abc.hello.there", '.', 1u, ~[~"abc", ~"hello.there"]); @@ -2712,7 +2712,7 @@ mod tests { for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); debug!("comparing vs. %?", u); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"ประเทศไทย中华Việt Nam", '华', 1u, ~[~"ประเทศไทย中", ~"Việt Nam"]); @@ -2731,7 +2731,7 @@ mod tests { for each_splitn_char(s, c, n) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); debug!("comparing vs. %?", u); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } let data = ~"ประเทศไทย中华Việt Nam"; t(data, 'V', 1u, ~[~"ประเทศไทย中华", ~"iệt Nam"]); @@ -2745,7 +2745,7 @@ mod tests { let mut v = ~[]; for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"abc.hello.there", '.', ~[~"abc", ~"hello", ~"there"]); t(~".hello.there", '.', ~[~"", ~"hello", ~"there"]); @@ -2764,7 +2764,7 @@ mod tests { let mut v = ~[]; for each_split_char_no_trailing(s, c) |s| { v.push(s.to_owned()) } debug!("split_byte to: %?", v); - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } let data = ~"ประเทศไทย中华Việt Nam"; t(data, 'V', ~[~"ประเทศไทย中华", ~"iệt Nam"]); @@ -2776,7 +2776,7 @@ mod tests { fn t<'a>(s: &str, sep: &'a str, u: &[~str]) { let mut v = ~[]; for each_split_str(s, sep) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"--1233345--", ~"12345", ~[~"--1233345--"]); t(~"abc::hello::there", ~"::", ~[~"abc", ~"hello", ~"there"]); @@ -2800,7 +2800,7 @@ mod tests { fn t(s: &str, sepf: &fn(char) -> bool, u: &[~str]) { let mut v = ~[]; for each_split(s, sepf) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]); @@ -2816,7 +2816,7 @@ mod tests { fn t(s: &str, sepf: &fn(char) -> bool, u: &[~str]) { let mut v = ~[]; for each_split_no_trailing(s, sepf) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"ประเทศไทย中华Việt Nam", |cc| cc == '华', ~[~"ประเทศไทย中", ~"Việt Nam"]); @@ -2835,7 +2835,7 @@ mod tests { fn t(s: &str, f: &fn(&str, &fn(&str) -> bool), u: &[~str]) { let mut v = ~[]; for f(s) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(lf, each_line ,~[~"", ~"Mary had a little lamb", ~"Little lamb"]); @@ -2855,7 +2855,7 @@ mod tests { fn t(s: &str, f: &fn(&str, &fn(&str) -> bool), u: &[~str]) { let mut v = ~[]; for f(s) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } let data = ~"\nMary had a little lamb\nLittle lamb\n"; @@ -2869,7 +2869,7 @@ mod tests { fn t(s: &str, i: uint, u: &[~str]) { let mut v = ~[]; for each_split_within(s, i) |s| { v.push(s.to_owned()) } - fail_unless!(vec::all2(v, u, |a,b| a == b)); + assert!(vec::all2(v, u, |a,b| a == b)); } t(~"", 0, ~[]); t(~"", 15, ~[]); @@ -2881,59 +2881,59 @@ mod tests { #[test] fn test_find_str() { // byte positions - fail_unless!(find_str(~"banana", ~"apple pie").is_none()); - fail_unless!(find_str(~"", ~"") == Some(0u)); + assert!(find_str(~"banana", ~"apple pie").is_none()); + assert!(find_str(~"", ~"") == Some(0u)); let data = ~"ประเทศไทย中华Việt Nam"; - fail_unless!(find_str(data, ~"") == Some(0u)); - fail_unless!(find_str(data, ~"ประเ") == Some( 0u)); - fail_unless!(find_str(data, ~"ะเ") == Some( 6u)); - fail_unless!(find_str(data, ~"中华") == Some(27u)); - fail_unless!(find_str(data, ~"ไท华").is_none()); + assert!(find_str(data, ~"") == Some(0u)); + assert!(find_str(data, ~"ประเ") == Some( 0u)); + assert!(find_str(data, ~"ะเ") == Some( 6u)); + assert!(find_str(data, ~"中华") == Some(27u)); + assert!(find_str(data, ~"ไท华").is_none()); } #[test] fn test_find_str_between() { // byte positions - fail_unless!(find_str_between(~"", ~"", 0u, 0u) == Some(0u)); + assert!(find_str_between(~"", ~"", 0u, 0u) == Some(0u)); let data = ~"abcabc"; - fail_unless!(find_str_between(data, ~"ab", 0u, 6u) == Some(0u)); - fail_unless!(find_str_between(data, ~"ab", 2u, 6u) == Some(3u)); - fail_unless!(find_str_between(data, ~"ab", 2u, 4u).is_none()); + assert!(find_str_between(data, ~"ab", 0u, 6u) == Some(0u)); + assert!(find_str_between(data, ~"ab", 2u, 6u) == Some(3u)); + assert!(find_str_between(data, ~"ab", 2u, 4u).is_none()); let mut data = ~"ประเทศไทย中华Việt Nam"; data = data + data; - fail_unless!(find_str_between(data, ~"", 0u, 43u) == Some(0u)); - fail_unless!(find_str_between(data, ~"", 6u, 43u) == Some(6u)); + assert!(find_str_between(data, ~"", 0u, 43u) == Some(0u)); + assert!(find_str_between(data, ~"", 6u, 43u) == Some(6u)); - fail_unless!(find_str_between(data, ~"ประ", 0u, 43u) == Some( 0u)); - fail_unless!(find_str_between(data, ~"ทศไ", 0u, 43u) == Some(12u)); - fail_unless!(find_str_between(data, ~"ย中", 0u, 43u) == Some(24u)); - fail_unless!(find_str_between(data, ~"iệt", 0u, 43u) == Some(34u)); - fail_unless!(find_str_between(data, ~"Nam", 0u, 43u) == Some(40u)); + assert!(find_str_between(data, ~"ประ", 0u, 43u) == Some( 0u)); + assert!(find_str_between(data, ~"ทศไ", 0u, 43u) == Some(12u)); + assert!(find_str_between(data, ~"ย中", 0u, 43u) == Some(24u)); + assert!(find_str_between(data, ~"iệt", 0u, 43u) == Some(34u)); + assert!(find_str_between(data, ~"Nam", 0u, 43u) == Some(40u)); - fail_unless!(find_str_between(data, ~"ประ", 43u, 86u) == Some(43u)); - fail_unless!(find_str_between(data, ~"ทศไ", 43u, 86u) == Some(55u)); - fail_unless!(find_str_between(data, ~"ย中", 43u, 86u) == Some(67u)); - fail_unless!(find_str_between(data, ~"iệt", 43u, 86u) == Some(77u)); - fail_unless!(find_str_between(data, ~"Nam", 43u, 86u) == Some(83u)); + assert!(find_str_between(data, ~"ประ", 43u, 86u) == Some(43u)); + assert!(find_str_between(data, ~"ทศไ", 43u, 86u) == Some(55u)); + assert!(find_str_between(data, ~"ย中", 43u, 86u) == Some(67u)); + assert!(find_str_between(data, ~"iệt", 43u, 86u) == Some(77u)); + assert!(find_str_between(data, ~"Nam", 43u, 86u) == Some(83u)); } #[test] fn test_substr() { fn t(a: &str, b: &str, start: int) { - fail_unless!(substr(a, start as uint, len(b)) == b); + assert!(substr(a, start as uint, len(b)) == b); } t("hello", "llo", 2); t("hello", "el", 1); - fail_unless!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u)); + assert!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u)); } #[test] fn test_concat() { fn t(v: &[~str], s: &str) { - fail_unless!(concat(v) == s.to_str()); + assert!(concat(v) == s.to_str()); } t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~"youknowI'mnogood"); let v: ~[~str] = ~[]; @@ -2944,7 +2944,7 @@ mod tests { #[test] fn test_connect() { fn t(v: &[~str], sep: &str, s: &str) { - fail_unless!(connect(v, sep) == s.to_str()); + assert!(connect(v, sep) == s.to_str()); } t(~[~"you", ~"know", ~"I'm", ~"no", ~"good"], ~" ", ~"you know I'm no good"); @@ -2956,7 +2956,7 @@ mod tests { #[test] fn test_connect_slices() { fn t(v: &[&str], sep: &str, s: &str) { - fail_unless!(connect_slices(v, sep) == s.to_str()); + assert!(connect_slices(v, sep) == s.to_str()); } t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good"); @@ -2966,11 +2966,11 @@ mod tests { #[test] fn test_repeat() { - fail_unless!(repeat(~"x", 4) == ~"xxxx"); - fail_unless!(repeat(~"hi", 4) == ~"hihihihi"); - fail_unless!(repeat(~"ไท华", 3) == ~"ไท华ไท华ไท华"); - fail_unless!(repeat(~"", 4) == ~""); - fail_unless!(repeat(~"hi", 0) == ~""); + assert!(repeat(~"x", 4) == ~"xxxx"); + assert!(repeat(~"hi", 4) == ~"hihihihi"); + assert!(repeat(~"ไท华", 3) == ~"ไท华ไท华ไท华"); + assert!(repeat(~"", 4) == ~""); + assert!(repeat(~"hi", 0) == ~""); } #[test] @@ -2982,24 +2982,24 @@ mod tests { let input = ~"abcDEF" + unicode + ~"xyz:.;"; let expected = ~"ABCDEF" + unicode + ~"XYZ:.;"; let actual = to_upper(input); - fail_unless!(expected == actual); + assert!(expected == actual); } #[test] fn test_to_lower() { unsafe { - fail_unless!(~"" == map(~"", + assert!(~"" == map(~"", |c| libc::tolower(c as c_char) as char)); - fail_unless!(~"ymca" == map(~"YMCA", + assert!(~"ymca" == map(~"YMCA", |c| libc::tolower(c as c_char) as char)); } } #[test] fn test_unsafe_slice() { - fail_unless!("ab" == unsafe {raw::slice_bytes("abc", 0, 2)}); - fail_unless!("bc" == unsafe {raw::slice_bytes("abc", 1, 3)}); - fail_unless!("" == unsafe {raw::slice_bytes("abc", 1, 1)}); + assert!("ab" == unsafe {raw::slice_bytes("abc", 0, 2)}); + assert!("bc" == unsafe {raw::slice_bytes("abc", 1, 3)}); + assert!("" == unsafe {raw::slice_bytes("abc", 1, 1)}); fn a_million_letter_a() -> ~str { let mut i = 0; let mut rs = ~""; @@ -3013,44 +3013,44 @@ mod tests { rs } let letters = a_million_letter_a(); - fail_unless!(half_a_million_letter_a() == + assert!(half_a_million_letter_a() == unsafe {raw::slice_bytes(letters, 0u, 500000)}.to_owned()); } #[test] fn test_starts_with() { - fail_unless!((starts_with(~"", ~""))); - fail_unless!((starts_with(~"abc", ~""))); - fail_unless!((starts_with(~"abc", ~"a"))); - fail_unless!((!starts_with(~"a", ~"abc"))); - fail_unless!((!starts_with(~"", ~"abc"))); + assert!((starts_with(~"", ~""))); + assert!((starts_with(~"abc", ~""))); + assert!((starts_with(~"abc", ~"a"))); + assert!((!starts_with(~"a", ~"abc"))); + assert!((!starts_with(~"", ~"abc"))); } #[test] fn test_ends_with() { - fail_unless!((ends_with(~"", ~""))); - fail_unless!((ends_with(~"abc", ~""))); - fail_unless!((ends_with(~"abc", ~"c"))); - fail_unless!((!ends_with(~"a", ~"abc"))); - fail_unless!((!ends_with(~"", ~"abc"))); + assert!((ends_with(~"", ~""))); + assert!((ends_with(~"abc", ~""))); + assert!((ends_with(~"abc", ~"c"))); + assert!((!ends_with(~"a", ~"abc"))); + assert!((!ends_with(~"", ~"abc"))); } #[test] fn test_is_empty() { - fail_unless!((is_empty(~""))); - fail_unless!((!is_empty(~"a"))); + assert!((is_empty(~""))); + assert!((!is_empty(~"a"))); } #[test] fn test_replace() { let a = ~"a"; - fail_unless!(replace(~"", a, ~"b") == ~""); - fail_unless!(replace(~"a", a, ~"b") == ~"b"); - fail_unless!(replace(~"ab", a, ~"b") == ~"bb"); + assert!(replace(~"", a, ~"b") == ~""); + assert!(replace(~"a", a, ~"b") == ~"b"); + assert!(replace(~"ab", a, ~"b") == ~"bb"); let test = ~"test"; - fail_unless!(replace(~" test test ", test, ~"toast") == + assert!(replace(~" test test ", test, ~"toast") == ~" toast toast "); - fail_unless!(replace(~" test test ", test, ~"") == ~" "); + assert!(replace(~" test test ", test, ~"") == ~" "); } #[test] @@ -3060,7 +3060,7 @@ mod tests { let a = ~"ประเ"; let A = ~"دولة الكويتทศไทย中华"; - fail_unless!((replace(data, a, repl) == A)); + assert!((replace(data, a, repl) == A)); } #[test] @@ -3070,7 +3070,7 @@ mod tests { let b = ~"ะเ"; let B = ~"ปรدولة الكويتทศไทย中华"; - fail_unless!((replace(data, b, repl) == B)); + assert!((replace(data, b, repl) == B)); } #[test] @@ -3080,7 +3080,7 @@ mod tests { let c = ~"中华"; let C = ~"ประเทศไทยدولة الكويت"; - fail_unless!((replace(data, c, repl) == C)); + assert!((replace(data, c, repl) == C)); } #[test] @@ -3089,21 +3089,21 @@ mod tests { let repl = ~"دولة الكويت"; let d = ~"ไท华"; - fail_unless!((replace(data, d, repl) == data)); + assert!((replace(data, d, repl) == data)); } #[test] fn test_slice() { - fail_unless!("ab" == slice("abc", 0, 2)); - fail_unless!("bc" == slice("abc", 1, 3)); - fail_unless!("" == slice("abc", 1, 1)); - fail_unless!("\u65e5" == slice("\u65e5\u672c", 0, 3)); + assert!("ab" == slice("abc", 0, 2)); + assert!("bc" == slice("abc", 1, 3)); + assert!("" == slice("abc", 1, 1)); + assert!("\u65e5" == slice("\u65e5\u672c", 0, 3)); let data = "ประเทศไทย中华"; - fail_unless!("ป" == slice(data, 0, 3)); - fail_unless!("ร" == slice(data, 3, 6)); - fail_unless!("" == slice(data, 3, 3)); - fail_unless!("华" == slice(data, 30, 33)); + assert!("ป" == slice(data, 0, 3)); + assert!("ร" == slice(data, 3, 6)); + assert!("" == slice(data, 3, 3)); + assert!("华" == slice(data, 30, 33)); fn a_million_letter_X() -> ~str { let mut i = 0; @@ -3121,7 +3121,7 @@ mod tests { rs } let letters = a_million_letter_X(); - fail_unless!(half_a_million_letter_X() == + assert!(half_a_million_letter_X() == slice(letters, 0u, 3u * 500000u).to_owned()); } @@ -3129,16 +3129,16 @@ mod tests { fn test_slice_2() { let ss = "中华Việt Nam"; - fail_unless!("华" == slice(ss, 3u, 6u)); - fail_unless!("Việt Nam" == slice(ss, 6u, 16u)); + assert!("华" == slice(ss, 3u, 6u)); + assert!("Việt Nam" == slice(ss, 6u, 16u)); - fail_unless!("ab" == slice("abc", 0u, 2u)); - fail_unless!("bc" == slice("abc", 1u, 3u)); - fail_unless!("" == slice("abc", 1u, 1u)); + assert!("ab" == slice("abc", 0u, 2u)); + assert!("bc" == slice("abc", 1u, 3u)); + assert!("" == slice("abc", 1u, 1u)); - fail_unless!("中" == slice(ss, 0u, 3u)); - fail_unless!("华V" == slice(ss, 3u, 7u)); - fail_unless!("" == slice(ss, 3u, 3u)); + assert!("中" == slice(ss, 0u, 3u)); + assert!("华V" == slice(ss, 3u, 7u)); + assert!("" == slice(ss, 3u, 3u)); /*0: 中 3: 华 6: V @@ -3160,101 +3160,101 @@ mod tests { #[test] fn test_trim_left_chars() { - fail_unless!(trim_left_chars(" *** foo *** ", ~[]) == + assert!(trim_left_chars(" *** foo *** ", ~[]) == " *** foo *** "); - fail_unless!(trim_left_chars(" *** foo *** ", ~['*', ' ']) == + assert!(trim_left_chars(" *** foo *** ", ~['*', ' ']) == "foo *** "); - fail_unless!(trim_left_chars(" *** *** ", ~['*', ' ']) == ""); - fail_unless!(trim_left_chars("foo *** ", ~['*', ' ']) == + assert!(trim_left_chars(" *** *** ", ~['*', ' ']) == ""); + assert!(trim_left_chars("foo *** ", ~['*', ' ']) == "foo *** "); } #[test] fn test_trim_right_chars() { - fail_unless!(trim_right_chars(" *** foo *** ", ~[]) == + assert!(trim_right_chars(" *** foo *** ", ~[]) == " *** foo *** "); - fail_unless!(trim_right_chars(" *** foo *** ", ~['*', ' ']) == + assert!(trim_right_chars(" *** foo *** ", ~['*', ' ']) == " *** foo"); - fail_unless!(trim_right_chars(" *** *** ", ~['*', ' ']) == ""); - fail_unless!(trim_right_chars(" *** foo", ~['*', ' ']) == + assert!(trim_right_chars(" *** *** ", ~['*', ' ']) == ""); + assert!(trim_right_chars(" *** foo", ~['*', ' ']) == " *** foo"); } #[test] fn test_trim_chars() { - fail_unless!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** "); - fail_unless!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo"); - fail_unless!(trim_chars(" *** *** ", ~['*', ' ']) == ""); - fail_unless!(trim_chars("foo", ~['*', ' ']) == "foo"); + assert!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** "); + assert!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo"); + assert!(trim_chars(" *** *** ", ~['*', ' ']) == ""); + assert!(trim_chars("foo", ~['*', ' ']) == "foo"); } #[test] fn test_trim_left() { - fail_unless!((trim_left("") == "")); - fail_unless!((trim_left("a") == "a")); - fail_unless!((trim_left(" ") == "")); - fail_unless!((trim_left(" blah") == "blah")); - fail_unless!((trim_left(" \u3000 wut") == "wut")); - fail_unless!((trim_left("hey ") == "hey ")); + assert!((trim_left("") == "")); + assert!((trim_left("a") == "a")); + assert!((trim_left(" ") == "")); + assert!((trim_left(" blah") == "blah")); + assert!((trim_left(" \u3000 wut") == "wut")); + assert!((trim_left("hey ") == "hey ")); } #[test] fn test_trim_right() { - fail_unless!((trim_right("") == "")); - fail_unless!((trim_right("a") == "a")); - fail_unless!((trim_right(" ") == "")); - fail_unless!((trim_right("blah ") == "blah")); - fail_unless!((trim_right("wut \u3000 ") == "wut")); - fail_unless!((trim_right(" hey") == " hey")); + assert!((trim_right("") == "")); + assert!((trim_right("a") == "a")); + assert!((trim_right(" ") == "")); + assert!((trim_right("blah ") == "blah")); + assert!((trim_right("wut \u3000 ") == "wut")); + assert!((trim_right(" hey") == " hey")); } #[test] fn test_trim() { - fail_unless!((trim("") == "")); - fail_unless!((trim("a") == "a")); - fail_unless!((trim(" ") == "")); - fail_unless!((trim(" blah ") == "blah")); - fail_unless!((trim("\nwut \u3000 ") == "wut")); - fail_unless!((trim(" hey dude ") == "hey dude")); + assert!((trim("") == "")); + assert!((trim("a") == "a")); + assert!((trim(" ") == "")); + assert!((trim(" blah ") == "blah")); + assert!((trim("\nwut \u3000 ") == "wut")); + assert!((trim(" hey dude ") == "hey dude")); } #[test] fn test_is_whitespace() { - fail_unless!((is_whitespace(~""))); - fail_unless!((is_whitespace(~" "))); - fail_unless!((is_whitespace(~"\u2009"))); // Thin space - fail_unless!((is_whitespace(~" \n\t "))); - fail_unless!((!is_whitespace(~" _ "))); + assert!((is_whitespace(~""))); + assert!((is_whitespace(~" "))); + assert!((is_whitespace(~"\u2009"))); // Thin space + assert!((is_whitespace(~" \n\t "))); + assert!((!is_whitespace(~" _ "))); } #[test] fn test_is_ascii() { - fail_unless!((is_ascii(~""))); - fail_unless!((is_ascii(~"a"))); - fail_unless!((!is_ascii(~"\u2009"))); + assert!((is_ascii(~""))); + assert!((is_ascii(~"a"))); + assert!((!is_ascii(~"\u2009"))); } #[test] fn test_shift_byte() { let mut s = ~"ABC"; let b = unsafe { raw::shift_byte(&mut s) }; - fail_unless!((s == ~"BC")); - fail_unless!((b == 65u8)); + assert!((s == ~"BC")); + assert!((b == 65u8)); } #[test] fn test_pop_byte() { let mut s = ~"ABC"; let b = unsafe { raw::pop_byte(&mut s) }; - fail_unless!((s == ~"AB")); - fail_unless!((b == 67u8)); + assert!((s == ~"AB")); + assert!((b == 67u8)); } #[test] fn test_unsafe_from_bytes() { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8]; let b = unsafe { raw::from_bytes(a) }; - fail_unless!((b == ~"AAAAAAA")); + assert!((b == ~"AAAAAAA")); } #[test] @@ -3271,7 +3271,7 @@ mod tests { 0x20_u8, 0x4e_u8, 0x61_u8, 0x6d_u8]; - fail_unless!(ss == from_bytes(bb)); + assert!(ss == from_bytes(bb)); } #[test] @@ -3298,7 +3298,7 @@ mod tests { let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let b = vec::raw::to_ptr(a); let c = raw::from_buf(b); - fail_unless!((c == ~"AAAAAAA")); + assert!((c == ~"AAAAAAA")); } } @@ -3314,20 +3314,20 @@ mod tests { fn test_as_buf() { let a = ~"Abcdefg"; let b = as_buf(a, |buf, _l| { - fail_unless!(unsafe { *buf } == 65u8); + assert!(unsafe { *buf } == 65u8); 100 }); - fail_unless!((b == 100)); + assert!((b == 100)); } #[test] fn test_as_buf_small() { let a = ~"A"; let b = as_buf(a, |buf, _l| { - fail_unless!(unsafe { *buf } == 65u8); + assert!(unsafe { *buf } == 65u8); 100 }); - fail_unless!((b == 100)); + assert!((b == 100)); } #[test] @@ -3336,7 +3336,7 @@ mod tests { let s = ~"hello"; let sb = as_buf(s, |b, _l| b); let s_cstr = raw::from_buf(sb); - fail_unless!(s_cstr == s); + assert!(s_cstr == s); } } @@ -3345,11 +3345,11 @@ mod tests { let a = ~"hello"; do as_buf(a) |buf, len| { unsafe { - fail_unless!(a[0] == 'h' as u8); - fail_unless!(*buf == 'h' as u8); - fail_unless!(len == 6u); - fail_unless!(*ptr::offset(buf,4u) == 'o' as u8); - fail_unless!(*ptr::offset(buf,5u) == 0u8); + assert!(a[0] == 'h' as u8); + assert!(*buf == 'h' as u8); + assert!(len == 6u); + assert!(*ptr::offset(buf,4u) == 'o' as u8); + assert!(*ptr::offset(buf,5u) == 0u8); } } } @@ -3363,40 +3363,40 @@ mod tests { let mut i: uint = 0u; let n1: uint = len(s1); let n2: uint = vec::len::(v); - fail_unless!((n1 == n2)); + assert!((n1 == n2)); while i < n1 { let a: u8 = s1[i]; let b: u8 = s2[i]; debug!(a); debug!(b); - fail_unless!((a == b)); + assert!((a == b)); i += 1u; } } #[test] fn test_contains() { - fail_unless!(contains(~"abcde", ~"bcd")); - fail_unless!(contains(~"abcde", ~"abcd")); - fail_unless!(contains(~"abcde", ~"bcde")); - fail_unless!(contains(~"abcde", ~"")); - fail_unless!(contains(~"", ~"")); - fail_unless!(!contains(~"abcde", ~"def")); - fail_unless!(!contains(~"", ~"a")); + assert!(contains(~"abcde", ~"bcd")); + assert!(contains(~"abcde", ~"abcd")); + assert!(contains(~"abcde", ~"bcde")); + assert!(contains(~"abcde", ~"")); + assert!(contains(~"", ~"")); + assert!(!contains(~"abcde", ~"def")); + assert!(!contains(~"", ~"a")); let data = ~"ประเทศไทย中华Việt Nam"; - fail_unless!(contains(data, ~"ประเ")); - fail_unless!(contains(data, ~"ะเ")); - fail_unless!(contains(data, ~"中华")); - fail_unless!(!contains(data, ~"ไท华")); + assert!(contains(data, ~"ประเ")); + assert!(contains(data, ~"ะเ")); + assert!(contains(data, ~"中华")); + assert!(!contains(data, ~"ไท华")); } #[test] fn test_contains_char() { - fail_unless!(contains_char(~"abc", 'b')); - fail_unless!(contains_char(~"a", 'a')); - fail_unless!(!contains_char(~"abc", 'd')); - fail_unless!(!contains_char(~"", 'a')); + assert!(contains_char(~"abc", 'b')); + assert!(contains_char(~"a", 'a')); + assert!(!contains_char(~"abc", 'd')); + assert!(!contains_char(~"", 'a')); } #[test] @@ -3407,10 +3407,10 @@ mod tests { for each_split_char(data, ' ') |xx| { match ii { - 0 => fail_unless!("\nMary" == xx), - 1 => fail_unless!("had" == xx), - 2 => fail_unless!("a" == xx), - 3 => fail_unless!("little" == xx), + 0 => assert!("\nMary" == xx), + 1 => assert!("had" == xx), + 2 => assert!("a" == xx), + 3 => assert!("little" == xx), _ => () } ii += 1; @@ -3425,9 +3425,9 @@ mod tests { for each_splitn_char(data, ' ', 2u) |xx| { match ii { - 0 => fail_unless!("\nMary" == xx), - 1 => fail_unless!("had" == xx), - 2 => fail_unless!("a little lamb\nLittle lamb\n" == xx), + 0 => assert!("\nMary" == xx), + 1 => assert!("had" == xx), + 2 => assert!("a little lamb\nLittle lamb\n" == xx), _ => () } ii += 1; @@ -3442,10 +3442,10 @@ mod tests { for each_word(data) |ww| { match ii { - 0 => fail_unless!("Mary" == ww), - 1 => fail_unless!("had" == ww), - 2 => fail_unless!("a" == ww), - 3 => fail_unless!("little" == ww), + 0 => assert!("Mary" == ww), + 1 => assert!("had" == ww), + 2 => assert!("a" == ww), + 3 => assert!("little" == ww), _ => () } ii += 1; @@ -3462,9 +3462,9 @@ mod tests { for each_line(lf) |x| { match ii { - 0 => fail_unless!("" == x), - 1 => fail_unless!("Mary had a little lamb" == x), - 2 => fail_unless!("Little lamb" == x), + 0 => assert!("" == x), + 1 => assert!("Mary had a little lamb" == x), + 2 => assert!("Little lamb" == x), _ => () } ii += 1; @@ -3474,35 +3474,35 @@ mod tests { #[test] fn test_map() { unsafe { - fail_unless!(~"" == map(~"", |c| + assert!(~"" == map(~"", |c| libc::toupper(c as c_char) as char)); - fail_unless!(~"YMCA" == map(~"ymca", + assert!(~"YMCA" == map(~"ymca", |c| libc::toupper(c as c_char) as char)); } } #[test] fn test_all() { - fail_unless!(true == all(~"", char::is_uppercase)); - fail_unless!(false == all(~"ymca", char::is_uppercase)); - fail_unless!(true == all(~"YMCA", char::is_uppercase)); - fail_unless!(false == all(~"yMCA", char::is_uppercase)); - fail_unless!(false == all(~"YMCy", char::is_uppercase)); + assert!(true == all(~"", char::is_uppercase)); + assert!(false == all(~"ymca", char::is_uppercase)); + assert!(true == all(~"YMCA", char::is_uppercase)); + assert!(false == all(~"yMCA", char::is_uppercase)); + assert!(false == all(~"YMCy", char::is_uppercase)); } #[test] fn test_any() { - fail_unless!(false == any(~"", char::is_uppercase)); - fail_unless!(false == any(~"ymca", char::is_uppercase)); - fail_unless!(true == any(~"YMCA", char::is_uppercase)); - fail_unless!(true == any(~"yMCA", char::is_uppercase)); - fail_unless!(true == any(~"Ymcy", char::is_uppercase)); + assert!(false == any(~"", char::is_uppercase)); + assert!(false == any(~"ymca", char::is_uppercase)); + assert!(true == any(~"YMCA", char::is_uppercase)); + assert!(true == any(~"yMCA", char::is_uppercase)); + assert!(true == any(~"Ymcy", char::is_uppercase)); } #[test] fn test_chars() { let ss = ~"ศไทย中华Việt Nam"; - fail_unless!(~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a', + assert!(~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a', 'm'] == to_chars(ss)); } @@ -3548,10 +3548,10 @@ mod tests { for vec::each(pairs) |p| { let (s, u) = copy *p; - fail_unless!(to_utf16(s) == u); - fail_unless!(from_utf16(u) == s); - fail_unless!(from_utf16(to_utf16(s)) == s); - fail_unless!(to_utf16(from_utf16(u)) == u); + assert!(to_utf16(s) == u); + assert!(from_utf16(u) == s); + assert!(from_utf16(to_utf16(s)) == s); + assert!(to_utf16(from_utf16(u)) == u); } } @@ -3561,7 +3561,7 @@ mod tests { let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; for v.each |ch| { - fail_unless!(s.char_at(pos) == *ch); + assert!(s.char_at(pos) == *ch); pos += from_char(*ch).len(); } } @@ -3572,7 +3572,7 @@ mod tests { let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = s.len(); for v.each_reverse |ch| { - fail_unless!(s.char_at_reverse(pos) == *ch); + assert!(s.char_at_reverse(pos) == *ch); pos -= from_char(*ch).len(); } } @@ -3588,7 +3588,7 @@ mod tests { let mut pos = 0; for s.each |b| { - fail_unless!(b == v[pos]); + assert!(b == v[pos]); pos += 1; } } @@ -3596,7 +3596,7 @@ mod tests { #[test] fn test_each_empty() { for "".each |b| { - fail_unless!(b == 0u8); + assert!(b == 0u8); } } @@ -3611,8 +3611,8 @@ mod tests { let mut pos = 0; for s.eachi |i, b| { - fail_unless!(pos == i); - fail_unless!(b == v[pos]); + assert!(pos == i); + assert!(b == v[pos]); pos += 1; } } @@ -3620,8 +3620,8 @@ mod tests { #[test] fn test_eachi_empty() { for "".eachi |i, b| { - fail_unless!(i == 0); - fail_unless!(b == 0); + assert!(i == 0); + assert!(b == 0); } } @@ -3637,14 +3637,14 @@ mod tests { for s.each_reverse |b| { pos -= 1; - fail_unless!(b == v[pos]); + assert!(b == v[pos]); } } #[test] fn test_each_empty_reverse() { for "".each_reverse |b| { - fail_unless!(b == 0u8); + assert!(b == 0u8); } } @@ -3660,16 +3660,16 @@ mod tests { for s.eachi_reverse |i, b| { pos -= 1; - fail_unless!(pos == i); - fail_unless!(b == v[pos]); + assert!(pos == i); + assert!(b == v[pos]); } } #[test] fn test_eachi_reverse_empty() { for "".eachi_reverse |i, b| { - fail_unless!(i == 0); - fail_unless!(b == 0); + assert!(i == 0); + assert!(b == 0); } } @@ -3679,7 +3679,7 @@ mod tests { let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; for s.each_char |ch| { - fail_unless!(ch == v[pos]); + assert!(ch == v[pos]); pos += 1; } } @@ -3690,8 +3690,8 @@ mod tests { let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; for s.each_chari |i, ch| { - fail_unless!(pos == i); - fail_unless!(ch == v[pos]); + assert!(pos == i); + assert!(ch == v[pos]); pos += 1; } } @@ -3703,7 +3703,7 @@ mod tests { let mut pos = v.len(); for s.each_char_reverse |ch| { pos -= 1; - fail_unless!(ch == v[pos]); + assert!(ch == v[pos]); } } @@ -3714,43 +3714,43 @@ mod tests { let mut pos = v.len(); for s.each_chari_reverse |i, ch| { pos -= 1; - fail_unless!(pos == i); - fail_unless!(ch == v[pos]); + assert!(pos == i); + assert!(ch == v[pos]); } } #[test] fn test_escape_unicode() { - fail_unless!(escape_unicode(~"abc") == ~"\\x61\\x62\\x63"); - fail_unless!(escape_unicode(~"a c") == ~"\\x61\\x20\\x63"); - fail_unless!(escape_unicode(~"\r\n\t") == ~"\\x0d\\x0a\\x09"); - fail_unless!(escape_unicode(~"'\"\\") == ~"\\x27\\x22\\x5c"); - fail_unless!(escape_unicode(~"\x00\x01\xfe\xff") == + assert!(escape_unicode(~"abc") == ~"\\x61\\x62\\x63"); + assert!(escape_unicode(~"a c") == ~"\\x61\\x20\\x63"); + assert!(escape_unicode(~"\r\n\t") == ~"\\x0d\\x0a\\x09"); + assert!(escape_unicode(~"'\"\\") == ~"\\x27\\x22\\x5c"); + assert!(escape_unicode(~"\x00\x01\xfe\xff") == ~"\\x00\\x01\\xfe\\xff"); - fail_unless!(escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff"); - fail_unless!(escape_unicode(~"\U00010000\U0010ffff") == + assert!(escape_unicode(~"\u0100\uffff") == ~"\\u0100\\uffff"); + assert!(escape_unicode(~"\U00010000\U0010ffff") == ~"\\U00010000\\U0010ffff"); - fail_unless!(escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00"); - fail_unless!(escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d"); + assert!(escape_unicode(~"ab\ufb00") == ~"\\x61\\x62\\ufb00"); + assert!(escape_unicode(~"\U0001d4ea\r") == ~"\\U0001d4ea\\x0d"); } #[test] fn test_escape_default() { - fail_unless!(escape_default(~"abc") == ~"abc"); - fail_unless!(escape_default(~"a c") == ~"a c"); - fail_unless!(escape_default(~"\r\n\t") == ~"\\r\\n\\t"); - fail_unless!(escape_default(~"'\"\\") == ~"\\'\\\"\\\\"); - fail_unless!(escape_default(~"\u0100\uffff") == ~"\\u0100\\uffff"); - fail_unless!(escape_default(~"\U00010000\U0010ffff") == + assert!(escape_default(~"abc") == ~"abc"); + assert!(escape_default(~"a c") == ~"a c"); + assert!(escape_default(~"\r\n\t") == ~"\\r\\n\\t"); + assert!(escape_default(~"'\"\\") == ~"\\'\\\"\\\\"); + assert!(escape_default(~"\u0100\uffff") == ~"\\u0100\\uffff"); + assert!(escape_default(~"\U00010000\U0010ffff") == ~"\\U00010000\\U0010ffff"); - fail_unless!(escape_default(~"ab\ufb00") == ~"ab\\ufb00"); - fail_unless!(escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r"); + assert!(escape_default(~"ab\ufb00") == ~"ab\\ufb00"); + assert!(escape_default(~"\U0001d4ea\r") == ~"\\U0001d4ea\\r"); } #[test] fn test_to_managed() { - fail_unless!((~"abc").to_managed() == @"abc"); - fail_unless!(slice("abcdef", 1, 5).to_managed() == @"bcde"); + assert!((~"abc").to_managed() == @"abc"); + assert!(slice("abcdef", 1, 5).to_managed() == @"bcde"); } #[test] diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index f8905e4faa796..338893d2388b7 100644 --- a/src/libcore/sys.rs +++ b/src/libcore/sys.rs @@ -170,10 +170,10 @@ pub mod tests { #[test] pub fn size_of_basic() { - fail_unless!(size_of::() == 1u); - fail_unless!(size_of::() == 2u); - fail_unless!(size_of::() == 4u); - fail_unless!(size_of::() == 8u); + assert!(size_of::() == 1u); + assert!(size_of::() == 2u); + assert!(size_of::() == 4u); + assert!(size_of::() == 8u); } #[test] @@ -181,30 +181,30 @@ pub mod tests { #[cfg(target_arch = "arm")] #[cfg(target_arch = "mips")] pub fn size_of_32() { - fail_unless!(size_of::() == 4u); - fail_unless!(size_of::<*uint>() == 4u); + assert!(size_of::() == 4u); + assert!(size_of::<*uint>() == 4u); } #[test] #[cfg(target_arch = "x86_64")] pub fn size_of_64() { - fail_unless!(size_of::() == 8u); - fail_unless!(size_of::<*uint>() == 8u); + assert!(size_of::() == 8u); + assert!(size_of::<*uint>() == 8u); } #[test] pub fn nonzero_size_of_basic() { type Z = [i8, ..0]; - fail_unless!(size_of::() == 0u); - fail_unless!(nonzero_size_of::() == 1u); - fail_unless!(nonzero_size_of::() == size_of::()); + assert!(size_of::() == 0u); + assert!(nonzero_size_of::() == 1u); + assert!(nonzero_size_of::() == size_of::()); } #[test] pub fn align_of_basic() { - fail_unless!(pref_align_of::() == 1u); - fail_unless!(pref_align_of::() == 2u); - fail_unless!(pref_align_of::() == 4u); + assert!(pref_align_of::() == 1u); + assert!(pref_align_of::() == 2u); + assert!(pref_align_of::() == 4u); } #[test] @@ -212,15 +212,15 @@ pub mod tests { #[cfg(target_arch = "arm")] #[cfg(target_arch = "mips")] pub fn align_of_32() { - fail_unless!(pref_align_of::() == 4u); - fail_unless!(pref_align_of::<*uint>() == 4u); + assert!(pref_align_of::() == 4u); + assert!(pref_align_of::<*uint>() == 4u); } #[test] #[cfg(target_arch = "x86_64")] pub fn align_of_64() { - fail_unless!(pref_align_of::() == 8u); - fail_unless!(pref_align_of::<*uint>() == 8u); + assert!(pref_align_of::() == 8u); + assert!(pref_align_of::<*uint>() == 8u); } #[test] @@ -229,7 +229,7 @@ pub mod tests { let x = 10; let f: &fn(int) -> int = |y| x + y; - fail_unless!(f(20) == 30); + assert!(f(20) == 30); let original_closure: Closure = cast::transmute(f); @@ -242,7 +242,7 @@ pub mod tests { }; let new_f: &fn(int) -> int = cast::transmute(new_closure); - fail_unless!(new_f(20) == 30); + assert!(new_f(20) == 30); } } } diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs index e386f93a42900..261671f6de9ae 100644 --- a/src/libcore/task/local_data.rs +++ b/src/libcore/task/local_data.rs @@ -92,17 +92,17 @@ fn test_tls_multitask() { do task::spawn { unsafe { // TLS shouldn't carry over. - fail_unless!(local_data_get(my_key).is_none()); + assert!(local_data_get(my_key).is_none()); local_data_set(my_key, @~"child data"); - fail_unless!(*(local_data_get(my_key).get()) == + assert!(*(local_data_get(my_key).get()) == ~"child data"); // should be cleaned up for us } } // Must work multiple times - fail_unless!(*(local_data_get(my_key).get()) == ~"parent data"); - fail_unless!(*(local_data_get(my_key).get()) == ~"parent data"); - fail_unless!(*(local_data_get(my_key).get()) == ~"parent data"); + assert!(*(local_data_get(my_key).get()) == ~"parent data"); + assert!(*(local_data_get(my_key).get()) == ~"parent data"); + assert!(*(local_data_get(my_key).get()) == ~"parent data"); } } @@ -112,7 +112,7 @@ fn test_tls_overwrite() { fn my_key(_x: @~str) { } local_data_set(my_key, @~"first data"); local_data_set(my_key, @~"next data"); // Shouldn't leak. - fail_unless!(*(local_data_get(my_key).get()) == ~"next data"); + assert!(*(local_data_get(my_key).get()) == ~"next data"); } } @@ -121,9 +121,9 @@ fn test_tls_pop() { unsafe { fn my_key(_x: @~str) { } local_data_set(my_key, @~"weasel"); - fail_unless!(*(local_data_pop(my_key).get()) == ~"weasel"); + assert!(*(local_data_pop(my_key).get()) == ~"weasel"); // Pop must remove the data from the map. - fail_unless!(local_data_pop(my_key).is_none()); + assert!(local_data_pop(my_key).is_none()); } } @@ -144,7 +144,7 @@ fn test_tls_modify() { None => fail!(~"missing value") } }); - fail_unless!(*(local_data_pop(my_key).get()) == ~"next data"); + assert!(*(local_data_pop(my_key).get()) == ~"next data"); } } diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs index a4fd18ec09430..43f5fa4654bc7 100644 --- a/src/libcore/task/local_data_priv.rs +++ b/src/libcore/task/local_data_priv.rs @@ -41,7 +41,7 @@ type TaskLocalMap = @mut ~[Option]; extern fn cleanup_task_local_map(map_ptr: *libc::c_void) { unsafe { - fail_unless!(!map_ptr.is_null()); + assert!(!map_ptr.is_null()); // Get and keep the single reference that was created at the // beginning. let _map: TaskLocalMap = cast::reinterpret_cast(&map_ptr); diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs index 0cd78d4b847d1..ee454312e0443 100644 --- a/src/libcore/task/mod.rs +++ b/src/libcore/task/mod.rs @@ -840,14 +840,14 @@ fn test_add_wrapper() { fn test_future_result() { let mut result = None; do task().future_result(|+r| { result = Some(r); }).spawn { } - fail_unless!(result.unwrap().recv() == Success); + assert!(result.unwrap().recv() == Success); result = None; do task().future_result(|+r| { result = Some(r); }).unlinked().spawn { fail!(); } - fail_unless!(result.unwrap().recv() == Failure); + assert!(result.unwrap().recv() == Failure); } #[test] #[should_fail] #[ignore(cfg(windows))] @@ -893,7 +893,7 @@ fn test_spawn_sched() { do spawn_sched(SingleThreaded) { let child_sched_id = unsafe { rt::rust_get_sched_id() }; - fail_unless!(parent_sched_id != child_sched_id); + assert!(parent_sched_id != child_sched_id); if (i == 0) { ch.send(()); @@ -921,8 +921,8 @@ fn test_spawn_sched_childs_on_default_sched() { do spawn { let ch = ch.f.swap_unwrap(); let child_sched_id = unsafe { rt::rust_get_sched_id() }; - fail_unless!(parent_sched_id != child_sched_id); - fail_unless!(child_sched_id == default_id); + assert!(parent_sched_id != child_sched_id); + assert!(child_sched_id == default_id); ch.send(()); }; }; @@ -1016,7 +1016,7 @@ fn avoid_copying_the_body(spawnfn: &fn(v: ~fn())) { } let x_in_child = p.recv(); - fail_unless!(x_in_parent == x_in_child); + assert!(x_in_parent == x_in_child); } #[test] @@ -1171,7 +1171,7 @@ fn test_sched_thread_per_core() { unsafe { let cores = rt::rust_num_threads(); let reported_threads = rt::rust_sched_threads(); - fail_unless!((cores as uint == reported_threads as uint)); + assert!((cores as uint == reported_threads as uint)); chan.send(()); } } @@ -1186,9 +1186,9 @@ fn test_spawn_thread_on_demand() { do spawn_sched(ManualThreads(2)) || { unsafe { let max_threads = rt::rust_sched_threads(); - fail_unless!((max_threads as int == 2)); + assert!((max_threads as int == 2)); let running_threads = rt::rust_sched_current_nonlazy_threads(); - fail_unless!((running_threads as int == 1)); + assert!((running_threads as int == 1)); let (port2, chan2) = comm::stream(); @@ -1197,7 +1197,7 @@ fn test_spawn_thread_on_demand() { } let running_threads2 = rt::rust_sched_current_nonlazy_threads(); - fail_unless!((running_threads2 as int == 2)); + assert!((running_threads2 as int == 2)); port2.recv(); chan.send(()); diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index fcd5ac7cdbb6e..39e43ba6fc5e8 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -103,11 +103,11 @@ fn new_taskset() -> TaskSet { } fn taskset_insert(tasks: &mut TaskSet, task: *rust_task) { let didnt_overwrite = tasks.insert(task); - fail_unless!(didnt_overwrite); + assert!(didnt_overwrite); } fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) { let was_present = tasks.remove(&task); - fail_unless!(was_present); + assert!(was_present); } pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) { tasks.each(|k| blk(*k)) @@ -231,7 +231,7 @@ fn each_ancestor(list: &mut AncestorList, // NB: Takes a lock! (this ancestor node) do access_ancestors(ancestor_arc) |nobe| { // Check monotonicity - fail_unless!(last_generation > nobe.generation); + assert!(last_generation > nobe.generation); /*##########################################################* * Step 1: Look at this ancestor group (call iterator block). *##########################################################*/ @@ -423,7 +423,7 @@ fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) { } } for taskset_each(&group.descendants) |child| { - fail_unless!(child != me); + assert!(child != me); rt::rust_task_kill_other(child); } // Only one task should ever do this. @@ -498,7 +498,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool) } None => 0 // the actual value doesn't really matter. }; - fail_unless!(new_generation < uint::max_value); + assert!(new_generation < uint::max_value); // Build a new node in the ancestor list. AncestorList(Some(unstable::exclusive(AncestorNode { generation: new_generation, @@ -545,7 +545,7 @@ pub fn spawn_raw(opts: TaskOpts, f: ~fn()) { DefaultScheduler => rt::new_task(), _ => new_task_in_sched(opts.sched) }; - fail_unless!(!new_task.is_null()); + assert!(!new_task.is_null()); // Getting killed after here would leak the task. let mut notify_chan = if opts.notify_chan.is_none() { None @@ -717,7 +717,7 @@ fn test_spawn_raw_notify_success() { }; do spawn_raw(opts) { } - fail_unless!(notify_po.recv() == Success); + assert!(notify_po.recv() == Success); } #[test] @@ -734,5 +734,5 @@ fn test_spawn_raw_notify_failure() { do spawn_raw(opts) { fail!(); } - fail_unless!(notify_po.recv() == Failure); + assert!(notify_po.recv() == Failure); } diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs index fa4074047b90a..a6004ed124174 100644 --- a/src/libcore/to_str.rs +++ b/src/libcore/to_str.rs @@ -137,31 +137,31 @@ impl ToStr for @[A] { mod tests { #[test] fn test_simple_types() { - fail_unless!(1i.to_str() == ~"1"); - fail_unless!((-1i).to_str() == ~"-1"); - fail_unless!(200u.to_str() == ~"200"); - fail_unless!(2u8.to_str() == ~"2"); - fail_unless!(true.to_str() == ~"true"); - fail_unless!(false.to_str() == ~"false"); - fail_unless!(().to_str() == ~"()"); - fail_unless!((~"hi").to_str() == ~"hi"); - fail_unless!((@"hi").to_str() == ~"hi"); + assert!(1i.to_str() == ~"1"); + assert!((-1i).to_str() == ~"-1"); + assert!(200u.to_str() == ~"200"); + assert!(2u8.to_str() == ~"2"); + assert!(true.to_str() == ~"true"); + assert!(false.to_str() == ~"false"); + assert!(().to_str() == ~"()"); + assert!((~"hi").to_str() == ~"hi"); + assert!((@"hi").to_str() == ~"hi"); } #[test] fn test_tuple_types() { - fail_unless!((1, 2).to_str() == ~"(1, 2)"); - fail_unless!((~"a", ~"b", false).to_str() == ~"(a, b, false)"); - fail_unless!(((), ((), 100)).to_str() == ~"((), ((), 100))"); + assert!((1, 2).to_str() == ~"(1, 2)"); + assert!((~"a", ~"b", false).to_str() == ~"(a, b, false)"); + assert!(((), ((), 100)).to_str() == ~"((), ((), 100))"); } #[test] fn test_vectors() { let x: ~[int] = ~[]; - fail_unless!(x.to_str() == ~"[]"); - fail_unless!((~[1]).to_str() == ~"[1]"); - fail_unless!((~[1, 2, 3]).to_str() == ~"[1, 2, 3]"); - fail_unless!((~[~[], ~[1], ~[1, 1]]).to_str() == + assert!(x.to_str() == ~"[]"); + assert!((~[1]).to_str() == ~"[1]"); + assert!((~[1, 2, 3]).to_str() == ~"[1, 2, 3]"); + assert!((~[~[], ~[1], ~[1, 1]]).to_str() == ~"[[], [1], [1, 1]]"); } } diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs index 52298992bd17f..5d87e2a296d3d 100644 --- a/src/libcore/trie.rs +++ b/src/libcore/trie.rs @@ -354,7 +354,7 @@ fn remove(count: &mut uint, child: &mut Child, key: uint, #[cfg(test)] pub fn check_integrity(trie: &TrieNode) { - fail_unless!(trie.count != 0); + assert!(trie.count != 0); let mut sum = 0; @@ -369,7 +369,7 @@ pub fn check_integrity(trie: &TrieNode) { } } - fail_unless!(sum == trie.count); + assert!(sum == trie.count); } #[cfg(test)] @@ -381,9 +381,9 @@ mod tests { #[test] fn test_find_mut() { let mut m = TrieMap::new(); - fail_unless!(m.insert(1, 12)); - fail_unless!(m.insert(2, 8)); - fail_unless!(m.insert(5, 14)); + assert!(m.insert(1, 12)); + assert!(m.insert(2, 8)); + assert!(m.insert(5, 14)); let new = 100; match m.find_mut(&5) { None => fail!(), Some(x) => *x = new @@ -397,32 +397,32 @@ mod tests { let n = 300; for uint::range_step(1, n, 2) |x| { - fail_unless!(trie.insert(x, x + 1)); - fail_unless!(trie.contains_key(&x)); + assert!(trie.insert(x, x + 1)); + assert!(trie.contains_key(&x)); check_integrity(&trie.root); } for uint::range_step(0, n, 2) |x| { - fail_unless!(!trie.contains_key(&x)); - fail_unless!(trie.insert(x, x + 1)); + assert!(!trie.contains_key(&x)); + assert!(trie.insert(x, x + 1)); check_integrity(&trie.root); } for uint::range(0, n) |x| { - fail_unless!(trie.contains_key(&x)); - fail_unless!(!trie.insert(x, x + 1)); + assert!(trie.contains_key(&x)); + assert!(!trie.insert(x, x + 1)); check_integrity(&trie.root); } for uint::range_step(1, n, 2) |x| { - fail_unless!(trie.remove(&x)); - fail_unless!(!trie.contains_key(&x)); + assert!(trie.remove(&x)); + assert!(!trie.contains_key(&x)); check_integrity(&trie.root); } for uint::range_step(0, n, 2) |x| { - fail_unless!(trie.contains_key(&x)); - fail_unless!(!trie.insert(x, x + 1)); + assert!(trie.contains_key(&x)); + assert!(!trie.insert(x, x + 1)); check_integrity(&trie.root); } } @@ -431,16 +431,16 @@ mod tests { fn test_each() { let mut m = TrieMap::new(); - fail_unless!(m.insert(3, 6)); - fail_unless!(m.insert(0, 0)); - fail_unless!(m.insert(4, 8)); - fail_unless!(m.insert(2, 4)); - fail_unless!(m.insert(1, 2)); + assert!(m.insert(3, 6)); + assert!(m.insert(0, 0)); + assert!(m.insert(4, 8)); + assert!(m.insert(2, 4)); + assert!(m.insert(1, 2)); let mut n = 0; for m.each |&(k, v)| { - fail_unless!(k == n); - fail_unless!(*v == n * 2); + assert!(k == n); + assert!(*v == n * 2); n += 1; } } @@ -456,10 +456,10 @@ mod tests { let mut n = uint::max_value - 9999; for m.each |&(k, v)| { if n == uint::max_value - 5000 { break } - fail_unless!(n < uint::max_value - 5000); + assert!(n < uint::max_value - 5000); - fail_unless!(k == n); - fail_unless!(*v == n / 2); + assert!(k == n); + assert!(*v == n / 2); n += 1; } } @@ -468,16 +468,16 @@ mod tests { fn test_each_reverse() { let mut m = TrieMap::new(); - fail_unless!(m.insert(3, 6)); - fail_unless!(m.insert(0, 0)); - fail_unless!(m.insert(4, 8)); - fail_unless!(m.insert(2, 4)); - fail_unless!(m.insert(1, 2)); + assert!(m.insert(3, 6)); + assert!(m.insert(0, 0)); + assert!(m.insert(4, 8)); + assert!(m.insert(2, 4)); + assert!(m.insert(1, 2)); let mut n = 4; for m.each_reverse |&(k, v)| { - fail_unless!(k == n); - fail_unless!(*v == n * 2); + assert!(k == n); + assert!(*v == n * 2); n -= 1; } } @@ -493,10 +493,10 @@ mod tests { let mut n = uint::max_value; for m.each_reverse |&(k, v)| { if n == uint::max_value - 5000 { break } - fail_unless!(n > uint::max_value - 5000); + assert!(n > uint::max_value - 5000); - fail_unless!(k == n); - fail_unless!(*v == n / 2); + assert!(k == n); + assert!(*v == n / 2); n -= 1; } } @@ -508,17 +508,17 @@ mod tests { let mut trie = TrieSet::new(); - fail_unless!(trie.insert(x)); - fail_unless!(trie.insert(y)); + assert!(trie.insert(x)); + assert!(trie.insert(y)); - fail_unless!(trie.len() == 2); + assert!(trie.len() == 2); let expected = [x, y]; let mut i = 0; for trie.each |x| { - fail_unless!(expected[i] == *x); + assert!(expected[i] == *x); i += 1; } } diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index 6fbcee959cea5..a5c86d592c636 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -240,15 +240,15 @@ impl Ord for (A, B, C) { #[test] fn test_tuple_ref() { let x = (~"foo", ~"bar"); - fail_unless!(x.first_ref() == &~"foo"); - fail_unless!(x.second_ref() == &~"bar"); + assert!(x.first_ref() == &~"foo"); + assert!(x.second_ref() == &~"bar"); } #[test] #[allow(non_implicitly_copyable_typarams)] fn test_tuple() { - fail_unless!((948, 4039.48).first() == 948); - fail_unless!((34.5, ~"foo").second() == ~"foo"); - fail_unless!(('a', 2).swap() == (2, 'a')); + assert!((948, 4039.48).first() == 948); + assert!((34.5, ~"foo").second() == ~"foo"); + assert!(('a', 2).swap() == (2, 'a')); } diff --git a/src/libcore/unstable.rs b/src/libcore/unstable.rs index 6da3dfc262882..665a3e1b6b6d4 100644 --- a/src/libcore/unstable.rs +++ b/src/libcore/unstable.rs @@ -81,7 +81,7 @@ pub fn run_in_bare_thread(f: ~fn()) { fn test_run_in_bare_thread() { let i = 100; do run_in_bare_thread { - fail_unless!(i == 100); + assert!(i == 100); } } @@ -90,7 +90,7 @@ fn test_run_in_bare_thread_exchange() { // Does the exchange heap work without the runtime? let i = ~100; do run_in_bare_thread { - fail_unless!(i == ~100); + assert!(i == ~100); } } @@ -123,7 +123,7 @@ impl Drop for ArcDestruct{ let data: ~ArcData = cast::reinterpret_cast(&self.data); let new_count = intrinsics::atomic_xsub(&mut data.count, 1) - 1; - fail_unless!(new_count >= 0); + assert!(new_count >= 0); if new_count == 0 { // drop glue takes over. } else { @@ -163,7 +163,7 @@ pub unsafe fn get_shared_mutable_state( { unsafe { let ptr: ~ArcData = cast::reinterpret_cast(&(*rc).data); - fail_unless!(ptr.count > 0); + assert!(ptr.count > 0); let r = cast::transmute(ptr.data.get_ref()); cast::forget(ptr); return r; @@ -174,7 +174,7 @@ pub unsafe fn get_shared_immutable_state<'a,T:Owned>( rc: &'a SharedMutableState) -> &'a T { unsafe { let ptr: ~ArcData = cast::reinterpret_cast(&(*rc).data); - fail_unless!(ptr.count > 0); + assert!(ptr.count > 0); // Cast us back into the correct region let r = cast::transmute_region(ptr.data.get_ref()); cast::forget(ptr); @@ -187,7 +187,7 @@ pub unsafe fn clone_shared_mutable_state(rc: &SharedMutableState) unsafe { let ptr: ~ArcData = cast::reinterpret_cast(&(*rc).data); let new_count = intrinsics::atomic_xadd(&mut ptr.count, 1) + 1; - fail_unless!(new_count >= 2); + assert!(new_count >= 2); cast::forget(ptr); } ArcDestruct((*rc).data) @@ -338,7 +338,7 @@ pub mod tests { for futures.each |f| { f.recv() } do total.with |total| { - fail_unless!(**total == num_tasks * count) + assert!(**total == num_tasks * count) }; } @@ -350,11 +350,11 @@ pub mod tests { let x2 = x.clone(); do task::try || { do x2.with |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do x.with |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } } diff --git a/src/libcore/unstable/at_exit.rs b/src/libcore/unstable/at_exit.rs index f85f62011078f..83f0c3695e82f 100644 --- a/src/libcore/unstable/at_exit.rs +++ b/src/libcore/unstable/at_exit.rs @@ -80,7 +80,7 @@ fn test_at_exit() { let i = 10; do at_exit { debug!("at_exit1"); - fail_unless!(i == 10); + assert!(i == 10); } } @@ -90,8 +90,8 @@ fn test_at_exit_many() { for uint::range(20, 100) |j| { do at_exit { debug!("at_exit2"); - fail_unless!(i == 10); - fail_unless!(j > i); + assert!(i == 10); + assert!(j > i); } } } diff --git a/src/libcore/unstable/exchange_alloc.rs b/src/libcore/unstable/exchange_alloc.rs index 7863d5d241c29..fdf99e9dffea6 100644 --- a/src/libcore/unstable/exchange_alloc.rs +++ b/src/libcore/unstable/exchange_alloc.rs @@ -20,11 +20,11 @@ use intrinsic::TyDesc; pub unsafe fn malloc(td: *TypeDesc, size: uint) -> *c_void { unsafe { - fail_unless!(td.is_not_null()); + assert!(td.is_not_null()); let total_size = get_box_size(size, (*td).align); let p = c_malloc(total_size as size_t); - fail_unless!(p.is_not_null()); + assert!(p.is_not_null()); // FIXME #3475: Converting between our two different tydesc types let td: *TyDesc = transmute(td); @@ -57,7 +57,7 @@ pub unsafe fn free(ptr: *c_void) { let exchange_count = &mut *rust_get_exchange_count_ptr(); atomic_xsub(exchange_count, 1); - fail_unless!(ptr.is_not_null()); + assert!(ptr.is_not_null()); c_free(ptr); } ///Thin wrapper around libc::free, as with exchange_alloc::malloc_raw @@ -75,7 +75,7 @@ fn get_box_size(body_size: uint, body_align: uint) -> uint { // Rounds |size| to the nearest |alignment|. Invariant: |alignment| is a power // of two. fn align_to(size: uint, align: uint) -> uint { - fail_unless!(align != 0); + assert!(align != 0); (size + align - 1) & !(align - 1) } diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs index d9fd6d87b726f..be2aecf0c2a3b 100644 --- a/src/libcore/unstable/extfmt.rs +++ b/src/libcore/unstable/extfmt.rs @@ -340,11 +340,11 @@ pub mod ct { parse_count(s, 0, s.len()) == Parsed::new(count, next) } - fail_unless!(test("", CountImplied, 0)); - fail_unless!(test("*", CountIsNextParam, 1)); - fail_unless!(test("*1", CountIsNextParam, 1)); - fail_unless!(test("*1$", CountIsParam(1), 3)); - fail_unless!(test("123", CountIs(123), 3)); + assert!(test("", CountImplied, 0)); + assert!(test("*", CountIsNextParam, 1)); + assert!(test("*1", CountIsNextParam, 1)); + assert!(test("*1$", CountIsParam(1), 3)); + assert!(test("123", CountIs(123), 3)); } #[test] @@ -355,8 +355,8 @@ pub mod ct { fn test(s: &str, flags: &[Flag], next: uint) { let f = parse_flags(s, 0, s.len()); - fail_unless!(pack(f.val) == pack(flags)); - fail_unless!(f.next == next); + assert!(pack(f.val) == pack(flags)); + assert!(f.next == next); } test("", [], 0); @@ -367,7 +367,7 @@ pub mod ct { #[test] fn test_parse_fmt_string() { - fail_unless!(parse_fmt_string("foo %s bar", die) == ~[ + assert!(parse_fmt_string("foo %s bar", die) == ~[ PieceString(~"foo "), PieceConv(Conv { param: None, @@ -378,7 +378,7 @@ pub mod ct { }), PieceString(~" bar")]); - fail_unless!(parse_fmt_string("%s", die) == ~[ + assert!(parse_fmt_string("%s", die) == ~[ PieceConv(Conv { param: None, flags: ~[], @@ -387,7 +387,7 @@ pub mod ct { ty: TyStr, })]); - fail_unless!(parse_fmt_string("%%%%", die) == ~[ + assert!(parse_fmt_string("%%%%", die) == ~[ PieceString(~"%"), PieceString(~"%")]); } @@ -397,10 +397,10 @@ pub mod ct { parse_parameter(s, 0, s.len()) == Parsed::new(param, next) } - fail_unless!(test("", None, 0)); - fail_unless!(test("foo", None, 0)); - fail_unless!(test("123", None, 0)); - fail_unless!(test("123$", Some(123), 4)); + assert!(test("", None, 0)); + assert!(test("foo", None, 0)); + assert!(test("123", None, 0)); + assert!(test("123$", Some(123), 4)); } #[test] @@ -409,12 +409,12 @@ pub mod ct { parse_precision(s, 0, s.len()) == Parsed::new(count, next) } - fail_unless!(test("", CountImplied, 0)); - fail_unless!(test(".", CountIs(0), 1)); - fail_unless!(test(".*", CountIsNextParam, 2)); - fail_unless!(test(".*1", CountIsNextParam, 2)); - fail_unless!(test(".*1$", CountIsParam(1), 4)); - fail_unless!(test(".123", CountIs(123), 4)); + assert!(test("", CountImplied, 0)); + assert!(test(".", CountIs(0), 1)); + assert!(test(".*", CountIsNextParam, 2)); + assert!(test(".*1", CountIsNextParam, 2)); + assert!(test(".*1$", CountIsParam(1), 4)); + assert!(test(".123", CountIs(123), 4)); } #[test] @@ -423,17 +423,17 @@ pub mod ct { parse_type(s, 0, s.len(), die) == Parsed::new(ty, 1) } - fail_unless!(test("b", TyBool)); - fail_unless!(test("c", TyChar)); - fail_unless!(test("d", TyInt(Signed))); - fail_unless!(test("f", TyFloat)); - fail_unless!(test("i", TyInt(Signed))); - fail_unless!(test("o", TyOctal)); - fail_unless!(test("s", TyStr)); - fail_unless!(test("t", TyBits)); - fail_unless!(test("x", TyHex(CaseLower))); - fail_unless!(test("X", TyHex(CaseUpper))); - fail_unless!(test("?", TyPoly)); + assert!(test("b", TyBool)); + assert!(test("c", TyChar)); + assert!(test("d", TyInt(Signed))); + assert!(test("f", TyFloat)); + assert!(test("i", TyInt(Signed))); + assert!(test("o", TyOctal)); + assert!(test("s", TyStr)); + assert!(test("t", TyBits)); + assert!(test("x", TyHex(CaseLower))); + assert!(test("X", TyHex(CaseUpper))); + assert!(test("?", TyPoly)); } #[test] @@ -453,16 +453,16 @@ pub mod ct { #[test] fn test_peek_num() { let s1 = ""; - fail_unless!(peek_num(s1, 0, s1.len()).is_none()); + assert!(peek_num(s1, 0, s1.len()).is_none()); let s2 = "foo"; - fail_unless!(peek_num(s2, 0, s2.len()).is_none()); + assert!(peek_num(s2, 0, s2.len()).is_none()); let s3 = "123"; - fail_unless!(peek_num(s3, 0, s3.len()) == Some(Parsed::new(123, 3))); + assert!(peek_num(s3, 0, s3.len()) == Some(Parsed::new(123, 3))); let s4 = "123foo"; - fail_unless!(peek_num(s4, 0, s4.len()) == Some(Parsed::new(123, 3))); + assert!(peek_num(s4, 0, s4.len()) == Some(Parsed::new(123, 3))); } } diff --git a/src/libcore/unstable/finally.rs b/src/libcore/unstable/finally.rs index 93cc4a4342d8e..4d2daa6f15027 100644 --- a/src/libcore/unstable/finally.rs +++ b/src/libcore/unstable/finally.rs @@ -58,11 +58,11 @@ fn test_success() { do (|| { i = 10; }).finally { - fail_unless!(!failing()); - fail_unless!(i == 10); + assert!(!failing()); + assert!(i == 10); i = 20; } - fail_unless!(i == 20); + assert!(i == 20); } #[test] @@ -74,8 +74,8 @@ fn test_fail() { i = 10; fail!(); }).finally { - fail_unless!(failing()); - fail_unless!(i == 10); + assert!(failing()); + assert!(i == 10); } } @@ -83,7 +83,7 @@ fn test_fail() { fn test_retval() { let closure: &fn() -> int = || 10; let i = do closure.finally { }; - fail_unless!(i == 10); + assert!(i == 10); } #[test] diff --git a/src/libcore/unstable/global.rs b/src/libcore/unstable/global.rs index 794ac0c85af61..ef5970658a192 100644 --- a/src/libcore/unstable/global.rs +++ b/src/libcore/unstable/global.rs @@ -187,7 +187,7 @@ fn get_global_state() -> Exclusive { let prev_i = unsafe { atomic_cxchg(&mut *global_ptr, 0, state_i) }; // Sanity check that we're not trying to reinitialize after shutdown - fail_unless!(prev_i != POISON); + assert!(prev_i != POISON); if prev_i == 0 { // Successfully installed the global pointer @@ -201,7 +201,7 @@ fn get_global_state() -> Exclusive { let prev_i = unsafe { atomic_cxchg(&mut *global_ptr, state_i, POISON) }; - fail_unless!(prev_i == state_i); + assert!(prev_i == state_i); // Capture the global state object in the at_exit closure // so that it is destroyed at the right time @@ -245,7 +245,7 @@ fn test_clone_rc() { ~shared_mutable_state(10) }; - fail_unless!(get_shared_immutable_state(&val) == &10); + assert!(get_shared_immutable_state(&val) == &10); } } } @@ -273,7 +273,7 @@ fn test_modify() { match v { Some(sms) => { let v = get_shared_immutable_state(sms); - fail_unless!(*v == 10); + assert!(*v == 10); None }, _ => fail!() diff --git a/src/libcore/unstable/weak_task.rs b/src/libcore/unstable/weak_task.rs index 6de324f310131..8b24c2fa6f622 100644 --- a/src/libcore/unstable/weak_task.rs +++ b/src/libcore/unstable/weak_task.rs @@ -42,7 +42,7 @@ pub unsafe fn weaken_task(f: &fn(Port)) { let shutdown_port = Cell(shutdown_port); let task = get_task_id(); // Expect the weak task service to be alive - fail_unless!(service.try_send(RegisterWeakTask(task, shutdown_chan))); + assert!(service.try_send(RegisterWeakTask(task, shutdown_chan))); unsafe { rust_dec_kernel_live_count(); } do (|| { f(shutdown_port.take()) @@ -104,7 +104,7 @@ fn run_weak_task_service(port: Port) { RegisterWeakTask(task, shutdown_chan) => { let previously_unregistered = shutdown_map.insert(task, shutdown_chan); - fail_unless!(previously_unregistered); + assert!(previously_unregistered); } UnregisterWeakTask(task) => { match shutdown_map.pop(&task) { diff --git a/src/libcore/util.rs b/src/libcore/util.rs index 739314bf61908..a08e38c021fad 100644 --- a/src/libcore/util.rs +++ b/src/libcore/util.rs @@ -82,7 +82,7 @@ terminate normally, but instead directly return from a function. ~~~ fn choose_weighted_item(v: &[Item]) -> Item { - fail_unless!(!v.is_empty()); + assert!(!v.is_empty()); let mut so_far = 0u; for v.each |item| { so_far += item.weight; @@ -110,23 +110,23 @@ mod tests { pub fn identity_crisis() { // Writing a test for the identity function. How did it come to this? let x = ~[(5, false)]; - //FIXME #3387 fail_unless!(x.eq(id(copy x))); + //FIXME #3387 assert!(x.eq(id(copy x))); let y = copy x; - fail_unless!(x.eq(&id(y))); + assert!(x.eq(&id(y))); } #[test] pub fn test_swap() { let mut x = 31337; let mut y = 42; swap(&mut x, &mut y); - fail_unless!(x == 42); - fail_unless!(y == 31337); + assert!(x == 42); + assert!(y == 31337); } #[test] pub fn test_replace() { let mut x = Some(NonCopyable()); let y = replace(&mut x, None); - fail_unless!(x.is_none()); - fail_unless!(y.is_some()); + assert!(x.is_none()); + assert!(y.is_some()); } } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 6b312c48d15ad..566bceaa86f3f 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -267,8 +267,8 @@ pub fn last_opt<'r,T>(v: &'r [T]) -> Option<&'r T> { /// Return a slice that points into another slice. #[inline(always)] pub fn slice<'r,T>(v: &'r [T], start: uint, end: uint) -> &'r [T] { - fail_unless!(start <= end); - fail_unless!(end <= len(v)); + assert!(start <= end); + assert!(end <= len(v)); do as_imm_buf(v) |p, _len| { unsafe { ::cast::reinterpret_cast( @@ -282,8 +282,8 @@ pub fn slice<'r,T>(v: &'r [T], start: uint, end: uint) -> &'r [T] { #[inline(always)] pub fn mut_slice<'r,T>(v: &'r mut [T], start: uint, end: uint) -> &'r mut [T] { - fail_unless!(start <= end); - fail_unless!(end <= v.len()); + assert!(start <= end); + assert!(end <= v.len()); do as_mut_buf(v) |p, _len| { unsafe { ::cast::reinterpret_cast( @@ -297,8 +297,8 @@ pub fn mut_slice<'r,T>(v: &'r mut [T], start: uint, end: uint) #[inline(always)] pub fn const_slice<'r,T>(v: &'r const [T], start: uint, end: uint) -> &'r const [T] { - fail_unless!(start <= end); - fail_unless!(end <= len(v)); + assert!(start <= end); + assert!(end <= len(v)); do as_const_buf(v) |p, _len| { unsafe { ::cast::reinterpret_cast( @@ -454,7 +454,7 @@ pub fn partitioned(v: &[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) { /// Removes the first element from a vector and return it pub fn shift(v: &mut ~[T]) -> T { unsafe { - fail_unless!(!v.is_empty()); + assert!(!v.is_empty()); if v.len() == 1 { return v.pop() } @@ -471,7 +471,7 @@ pub fn shift(v: &mut ~[T]) -> T { // Save the last element. We're going to overwrite its position let mut work_elt = v.pop(); // We still should have room to work where what last element was - fail_unless!(capacity(v) >= ln); + assert!(capacity(v) >= ln); // Pretend like we have the original length so we can use // the vector copy_memory to overwrite the hole we just made raw::set_len(&mut *v, ln); @@ -517,7 +517,7 @@ pub fn unshift(v: &mut ~[T], x: T) { /// elements after position i one position to the right. pub fn insert(v: &mut ~[T], i: uint, x: T) { let len = v.len(); - fail_unless!(i <= len); + assert!(i <= len); v.push(x); let mut j = len; @@ -531,7 +531,7 @@ pub fn insert(v: &mut ~[T], i: uint, x: T) { /// all elements after position i one position to the left. pub fn remove(v: &mut ~[T], i: uint) -> T { let len = v.len(); - fail_unless!(i < len); + assert!(i < len); let mut j = i; while j < len - 1 { @@ -656,7 +656,7 @@ pub fn push_all_move(v: &mut ~[T], mut rhs: ~[T]) { /// Shorten a vector, dropping excess elements. pub fn truncate(v: &mut ~[T], newlen: uint) { do as_mut_buf(*v) |p, oldlen| { - fail_unless!(newlen <= oldlen); + assert!(newlen <= oldlen); unsafe { // This loop is optimized out for non-drop types. for uint::range(newlen, oldlen) |i| { @@ -1160,8 +1160,8 @@ pub fn position_between(v: &[T], end: uint, f: &fn(t: &T) -> bool) -> Option { - fail_unless!(start <= end); - fail_unless!(end <= len(v)); + assert!(start <= end); + assert!(end <= len(v)); let mut i = start; while i < end { if f(&v[i]) { return Some::(i); } i += 1u; } None @@ -1193,8 +1193,8 @@ pub fn rposition(v: &[T], f: &fn(t: &T) -> bool) -> Option { */ pub fn rposition_between(v: &[T], start: uint, end: uint, f: &fn(t: &T) -> bool) -> Option { - fail_unless!(start <= end); - fail_unless!(end <= len(v)); + assert!(start <= end); + assert!(end <= len(v)); let mut i = end; while i > start { if f(&v[i - 1u]) { return Some::(i - 1u); } @@ -1250,7 +1250,7 @@ pub fn zip_slice(v: &const [T], u: &const [U]) let mut zipped = ~[]; let sz = len(v); let mut i = 0u; - fail_unless!(sz == len(u)); + assert!(sz == len(u)); while i < sz { unsafe { zipped.push((v[i], u[i])); i += 1u; } } @@ -1265,7 +1265,7 @@ pub fn zip_slice(v: &const [T], u: &const [U]) */ pub fn zip(mut v: ~[T], mut u: ~[U]) -> ~[(T, U)] { let mut i = len(v); - fail_unless!(i == len(u)); + assert!(i == len(u)); let mut w = with_capacity(i); while i > 0 { unsafe { w.push((v.pop(),u.pop())); } @@ -1444,7 +1444,7 @@ pub fn eachi_reverse<'r,T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) { */ #[inline] pub fn each2(v1: &[U], v2: &[T], f: &fn(u: &U, t: &T) -> bool) { - fail_unless!(len(v1) == len(v2)); + assert!(len(v1) == len(v2)); for uint::range(0u, len(v1)) |i| { if !f(&v1[i], &v2[i]) { return; @@ -1488,7 +1488,7 @@ pub fn each_permutation(v: &[T], put: &fn(ts: &[T]) -> bool) { pub fn windowed(nn: uint, xx: &[TT]) -> ~[~[TT]] { let mut ww = ~[]; - fail_unless!(1u <= nn); + assert!(1u <= nn); for vec::eachi (xx) |ii, _x| { let len = xx.len(); if ii+nn <= len { @@ -2267,8 +2267,8 @@ pub mod raw { #[inline(always)] pub unsafe fn copy_memory(dst: &mut [T], src: &const [T], count: uint) { - fail_unless!(dst.len() >= count); - fail_unless!(src.len() >= count); + assert!(dst.len() >= count); + assert!(src.len() >= count); do as_mut_buf(dst) |p_dst, _len_dst| { do as_const_buf(src) |p_src, _len_src| { @@ -2604,21 +2604,21 @@ mod tests { let a = ~[1, 2, 3]; let mut ptr = raw::to_ptr(a); let b = from_buf(ptr, 3u); - fail_unless!(b.len() == 3u); - fail_unless!(b[0] == 1); - fail_unless!(b[1] == 2); - fail_unless!(b[2] == 3); + assert!(b.len() == 3u); + assert!(b[0] == 1); + assert!(b[1] == 2); + assert!(b[2] == 3); // Test on-heap copy-from-buf. let c = ~[1, 2, 3, 4, 5]; ptr = raw::to_ptr(c); let d = from_buf(ptr, 5u); - fail_unless!(d.len() == 5u); - fail_unless!(d[0] == 1); - fail_unless!(d[1] == 2); - fail_unless!(d[2] == 3); - fail_unless!(d[3] == 4); - fail_unless!(d[4] == 5); + assert!(d.len() == 5u); + assert!(d[0] == 1); + assert!(d[1] == 2); + assert!(d[2] == 3); + assert!(d[3] == 4); + assert!(d[4] == 5); } } @@ -2626,43 +2626,43 @@ mod tests { fn test_from_fn() { // Test on-stack from_fn. let mut v = from_fn(3u, square); - fail_unless!(v.len() == 3u); - fail_unless!(v[0] == 0u); - fail_unless!(v[1] == 1u); - fail_unless!(v[2] == 4u); + assert!(v.len() == 3u); + assert!(v[0] == 0u); + assert!(v[1] == 1u); + assert!(v[2] == 4u); // Test on-heap from_fn. v = from_fn(5u, square); - fail_unless!(v.len() == 5u); - fail_unless!(v[0] == 0u); - fail_unless!(v[1] == 1u); - fail_unless!(v[2] == 4u); - fail_unless!(v[3] == 9u); - fail_unless!(v[4] == 16u); + assert!(v.len() == 5u); + assert!(v[0] == 0u); + assert!(v[1] == 1u); + assert!(v[2] == 4u); + assert!(v[3] == 9u); + assert!(v[4] == 16u); } #[test] fn test_from_elem() { // Test on-stack from_elem. let mut v = from_elem(2u, 10u); - fail_unless!(v.len() == 2u); - fail_unless!(v[0] == 10u); - fail_unless!(v[1] == 10u); + assert!(v.len() == 2u); + assert!(v[0] == 10u); + assert!(v[1] == 10u); // Test on-heap from_elem. v = from_elem(6u, 20u); - fail_unless!(v[0] == 20u); - fail_unless!(v[1] == 20u); - fail_unless!(v[2] == 20u); - fail_unless!(v[3] == 20u); - fail_unless!(v[4] == 20u); - fail_unless!(v[5] == 20u); + assert!(v[0] == 20u); + assert!(v[1] == 20u); + assert!(v[2] == 20u); + assert!(v[3] == 20u); + assert!(v[4] == 20u); + assert!(v[5] == 20u); } #[test] fn test_is_empty() { - fail_unless!(is_empty::(~[])); - fail_unless!(!is_empty(~[0])); + assert!(is_empty::(~[])); + assert!(!is_empty(~[0])); } #[test] @@ -2671,18 +2671,18 @@ mod tests { let v0 : &[Z] = &[]; let v1 : &[Z] = &[[]]; let v2 : &[Z] = &[[], []]; - fail_unless!(sys::size_of::() == 0); - fail_unless!(v0.len() == 0); - fail_unless!(v1.len() == 1); - fail_unless!(v2.len() == 2); + assert!(sys::size_of::() == 0); + assert!(v0.len() == 0); + assert!(v1.len() == 1); + assert!(v2.len() == 2); } #[test] fn test_head() { let mut a = ~[11]; - fail_unless!(a.head() == &11); + assert!(a.head() == &11); a = ~[11, 12]; - fail_unless!(a.head() == &11); + assert!(a.head() == &11); } #[test] @@ -2696,19 +2696,19 @@ mod tests { #[test] fn test_head_opt() { let mut a = ~[]; - fail_unless!(a.head_opt() == None); + assert!(a.head_opt() == None); a = ~[11]; - fail_unless!(a.head_opt().unwrap() == &11); + assert!(a.head_opt().unwrap() == &11); a = ~[11, 12]; - fail_unless!(a.head_opt().unwrap() == &11); + assert!(a.head_opt().unwrap() == &11); } #[test] fn test_tail() { let mut a = ~[11]; - fail_unless!(a.tail() == &[]); + assert!(a.tail() == &[]); a = ~[11, 12]; - fail_unless!(a.tail() == &[12]); + assert!(a.tail() == &[12]); } #[test] @@ -2722,9 +2722,9 @@ mod tests { #[test] fn test_tailn() { let mut a = ~[11, 12, 13]; - fail_unless!(a.tailn(0) == &[11, 12, 13]); + assert!(a.tailn(0) == &[11, 12, 13]); a = ~[11, 12, 13]; - fail_unless!(a.tailn(2) == &[13]); + assert!(a.tailn(2) == &[13]); } #[test] @@ -2738,9 +2738,9 @@ mod tests { #[test] fn test_init() { let mut a = ~[11]; - fail_unless!(a.init() == &[]); + assert!(a.init() == &[]); a = ~[11, 12]; - fail_unless!(a.init() == &[11]); + assert!(a.init() == &[11]); } #[init] @@ -2754,9 +2754,9 @@ mod tests { #[test] fn test_initn() { let mut a = ~[11, 12, 13]; - fail_unless!(a.initn(0) == &[11, 12, 13]); + assert!(a.initn(0) == &[11, 12, 13]); a = ~[11, 12, 13]; - fail_unless!(a.initn(2) == &[11]); + assert!(a.initn(2) == &[11]); } #[init] @@ -2770,9 +2770,9 @@ mod tests { #[test] fn test_last() { let mut a = ~[11]; - fail_unless!(a.last() == &11); + assert!(a.last() == &11); a = ~[11, 12]; - fail_unless!(a.last() == &12); + assert!(a.last() == &12); } #[test] @@ -2786,11 +2786,11 @@ mod tests { #[test] fn test_last_opt() { let mut a = ~[]; - fail_unless!(a.last_opt() == None); + assert!(a.last_opt() == None); a = ~[11]; - fail_unless!(a.last_opt().unwrap() == &11); + assert!(a.last_opt().unwrap() == &11); a = ~[11, 12]; - fail_unless!(a.last_opt().unwrap() == &12); + assert!(a.last_opt().unwrap() == &12); } #[test] @@ -2798,35 +2798,35 @@ mod tests { // Test fixed length vector. let vec_fixed = [1, 2, 3, 4]; let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_vec(); - fail_unless!(v_a.len() == 3u); - fail_unless!(v_a[0] == 2); - fail_unless!(v_a[1] == 3); - fail_unless!(v_a[2] == 4); + assert!(v_a.len() == 3u); + assert!(v_a[0] == 2); + assert!(v_a[1] == 3); + assert!(v_a[2] == 4); // Test on stack. let vec_stack = &[1, 2, 3]; let v_b = slice(vec_stack, 1u, 3u).to_vec(); - fail_unless!(v_b.len() == 2u); - fail_unless!(v_b[0] == 2); - fail_unless!(v_b[1] == 3); + assert!(v_b.len() == 2u); + assert!(v_b[0] == 2); + assert!(v_b[1] == 3); // Test on managed heap. let vec_managed = @[1, 2, 3, 4, 5]; let v_c = slice(vec_managed, 0u, 3u).to_vec(); - fail_unless!(v_c.len() == 3u); - fail_unless!(v_c[0] == 1); - fail_unless!(v_c[1] == 2); - fail_unless!(v_c[2] == 3); + assert!(v_c.len() == 3u); + assert!(v_c[0] == 1); + assert!(v_c[1] == 2); + assert!(v_c[2] == 3); // Test on exchange heap. let vec_unique = ~[1, 2, 3, 4, 5, 6]; let v_d = slice(vec_unique, 1u, 6u).to_vec(); - fail_unless!(v_d.len() == 5u); - fail_unless!(v_d[0] == 2); - fail_unless!(v_d[1] == 3); - fail_unless!(v_d[2] == 4); - fail_unless!(v_d[3] == 5); - fail_unless!(v_d[4] == 6); + assert!(v_d.len() == 5u); + assert!(v_d[0] == 2); + assert!(v_d[1] == 3); + assert!(v_d[2] == 4); + assert!(v_d[3] == 5); + assert!(v_d[4] == 6); } #[test] @@ -2834,27 +2834,27 @@ mod tests { // Test on-heap pop. let mut v = ~[1, 2, 3, 4, 5]; let e = v.pop(); - fail_unless!(v.len() == 4u); - fail_unless!(v[0] == 1); - fail_unless!(v[1] == 2); - fail_unless!(v[2] == 3); - fail_unless!(v[3] == 4); - fail_unless!(e == 5); + assert!(v.len() == 4u); + assert!(v[0] == 1); + assert!(v[1] == 2); + assert!(v[2] == 3); + assert!(v[3] == 4); + assert!(e == 5); } #[test] fn test_swap_remove() { let mut v = ~[1, 2, 3, 4, 5]; let mut e = v.swap_remove(0); - fail_unless!(v.len() == 4); - fail_unless!(e == 1); - fail_unless!(v[0] == 5); + assert!(v.len() == 4); + assert!(e == 1); + assert!(v[0] == 5); e = v.swap_remove(3); - fail_unless!(v.len() == 3); - fail_unless!(e == 4); - fail_unless!(v[0] == 5); - fail_unless!(v[1] == 2); - fail_unless!(v[2] == 3); + assert!(v.len() == 3); + assert!(e == 4); + assert!(v[0] == 5); + assert!(v[1] == 2); + assert!(v[2] == 3); } #[test] @@ -2863,11 +2863,11 @@ mod tests { let mut v = ~[::unstable::exclusive(()), ::unstable::exclusive(()), ::unstable::exclusive(())]; let mut _e = v.swap_remove(0); - fail_unless!(v.len() == 2); + assert!(v.len() == 2); _e = v.swap_remove(1); - fail_unless!(v.len() == 1); + assert!(v.len() == 1); _e = v.swap_remove(0); - fail_unless!(v.len() == 0); + assert!(v.len() == 0); } #[test] @@ -2875,14 +2875,14 @@ mod tests { // Test on-stack push(). let mut v = ~[]; v.push(1); - fail_unless!(v.len() == 1u); - fail_unless!(v[0] == 1); + assert!(v.len() == 1u); + assert!(v[0] == 1); // Test on-heap push(). v.push(2); - fail_unless!(v.len() == 2u); - fail_unless!(v[0] == 1); - fail_unless!(v[1] == 2); + assert!(v.len() == 2u); + assert!(v[0] == 1); + assert!(v[1] == 2); } #[test] @@ -2890,48 +2890,48 @@ mod tests { // Test on-stack grow(). let mut v = ~[]; v.grow(2u, &1); - fail_unless!(v.len() == 2u); - fail_unless!(v[0] == 1); - fail_unless!(v[1] == 1); + assert!(v.len() == 2u); + assert!(v[0] == 1); + assert!(v[1] == 1); // Test on-heap grow(). v.grow(3u, &2); - fail_unless!(v.len() == 5u); - fail_unless!(v[0] == 1); - fail_unless!(v[1] == 1); - fail_unless!(v[2] == 2); - fail_unless!(v[3] == 2); - fail_unless!(v[4] == 2); + assert!(v.len() == 5u); + assert!(v[0] == 1); + assert!(v[1] == 1); + assert!(v[2] == 2); + assert!(v[3] == 2); + assert!(v[4] == 2); } #[test] fn test_grow_fn() { let mut v = ~[]; v.grow_fn(3u, square); - fail_unless!(v.len() == 3u); - fail_unless!(v[0] == 0u); - fail_unless!(v[1] == 1u); - fail_unless!(v[2] == 4u); + assert!(v.len() == 3u); + assert!(v[0] == 0u); + assert!(v[1] == 1u); + assert!(v[2] == 4u); } #[test] fn test_grow_set() { let mut v = ~[1, 2, 3]; v.grow_set(4u, &4, 5); - fail_unless!(v.len() == 5u); - fail_unless!(v[0] == 1); - fail_unless!(v[1] == 2); - fail_unless!(v[2] == 3); - fail_unless!(v[3] == 4); - fail_unless!(v[4] == 5); + assert!(v.len() == 5u); + assert!(v[0] == 1); + assert!(v[1] == 2); + assert!(v[2] == 3); + assert!(v[3] == 4); + assert!(v[4] == 5); } #[test] fn test_truncate() { let mut v = ~[@6,@5,@4]; v.truncate(1); - fail_unless!(v.len() == 1); - fail_unless!(*(v[0]) == 6); + assert!(v.len() == 1); + assert!(*(v[0]) == 6); // If the unsafe block didn't drop things properly, we blow up here. } @@ -2939,7 +2939,7 @@ mod tests { fn test_clear() { let mut v = ~[@6,@5,@4]; v.clear(); - fail_unless!(v.len() == 0); + assert!(v.len() == 0); // If the unsafe block didn't drop things properly, we blow up here. } @@ -2948,7 +2948,7 @@ mod tests { fn case(a: ~[uint], b: ~[uint]) { let mut v = a; v.dedup(); - fail_unless!(v == b); + assert!(v == b); } case(~[], ~[]); case(~[1], ~[1]); @@ -2993,20 +2993,20 @@ mod tests { // Test on-stack map. let mut v = ~[1u, 2u, 3u]; let mut w = map(v, square_ref); - fail_unless!(w.len() == 3u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 4u); - fail_unless!(w[2] == 9u); + assert!(w.len() == 3u); + assert!(w[0] == 1u); + assert!(w[1] == 4u); + assert!(w[2] == 9u); // Test on-heap map. v = ~[1u, 2u, 3u, 4u, 5u]; w = map(v, square_ref); - fail_unless!(w.len() == 5u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 4u); - fail_unless!(w[2] == 9u); - fail_unless!(w[3] == 16u); - fail_unless!(w[4] == 25u); + assert!(w.len() == 5u); + assert!(w[0] == 1u); + assert!(w[1] == 4u); + assert!(w[2] == 9u); + assert!(w[3] == 16u); + assert!(w[4] == 25u); } #[test] @@ -3017,7 +3017,7 @@ mod tests { let v1 = ~[5, 4, 3, 2, 1]; let u = map2::(v0, v1, f); let mut i = 0; - while i < 5 { fail_unless!(v0[i] * v1[i] == u[i]); i += 1; } + while i < 5 { assert!(v0[i] * v1[i] == u[i]); i += 1; } } #[test] @@ -3025,17 +3025,17 @@ mod tests { // Test on-stack filter-map. let mut v = ~[1u, 2u, 3u]; let mut w = filter_mapped(v, square_if_odd_r); - fail_unless!(w.len() == 2u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 9u); + assert!(w.len() == 2u); + assert!(w[0] == 1u); + assert!(w[1] == 9u); // Test on-heap filter-map. v = ~[1u, 2u, 3u, 4u, 5u]; w = filter_mapped(v, square_if_odd_r); - fail_unless!(w.len() == 3u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 9u); - fail_unless!(w[2] == 25u); + assert!(w.len() == 3u); + assert!(w[0] == 1u); + assert!(w[1] == 9u); + assert!(w[2] == 25u); fn halve(i: &int) -> Option { if *i % 2 == 0 { @@ -3050,11 +3050,11 @@ mod tests { let all_odd2: ~[int] = ~[]; let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3]; let mix_dest: ~[int] = ~[1, 3, 0, 0]; - fail_unless!(filter_mapped(all_even, halve) == + assert!(filter_mapped(all_even, halve) == map(all_even, halve_for_sure)); - fail_unless!(filter_mapped(all_odd1, halve) == ~[]); - fail_unless!(filter_mapped(all_odd2, halve) == ~[]); - fail_unless!(filter_mapped(mix, halve) == mix_dest); + assert!(filter_mapped(all_odd1, halve) == ~[]); + assert!(filter_mapped(all_odd2, halve) == ~[]); + assert!(filter_mapped(mix, halve) == mix_dest); } #[test] @@ -3062,17 +3062,17 @@ mod tests { // Test on-stack filter-map. let mut v = ~[1u, 2u, 3u]; let mut w = filter_map(v, square_if_odd_v); - fail_unless!(w.len() == 2u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 9u); + assert!(w.len() == 2u); + assert!(w[0] == 1u); + assert!(w[1] == 9u); // Test on-heap filter-map. v = ~[1u, 2u, 3u, 4u, 5u]; w = filter_map(v, square_if_odd_v); - fail_unless!(w.len() == 3u); - fail_unless!(w[0] == 1u); - fail_unless!(w[1] == 9u); - fail_unless!(w[2] == 25u); + assert!(w.len() == 3u); + assert!(w[0] == 1u); + assert!(w[1] == 9u); + assert!(w[2] == 25u); fn halve(i: int) -> Option { if i % 2 == 0 { @@ -3088,24 +3088,24 @@ mod tests { let all_odd2: ~[int] = ~[]; let mix: ~[int] = ~[9, 2, 6, 7, 1, 0, 0, 3]; let mix_dest: ~[int] = ~[1, 3, 0, 0]; - fail_unless!(filter_map(all_even, halve) == + assert!(filter_map(all_even, halve) == map(all_even0, halve_for_sure)); - fail_unless!(filter_map(all_odd1, halve) == ~[]); - fail_unless!(filter_map(all_odd2, halve) == ~[]); - fail_unless!(filter_map(mix, halve) == mix_dest); + assert!(filter_map(all_odd1, halve) == ~[]); + assert!(filter_map(all_odd2, halve) == ~[]); + assert!(filter_map(mix, halve) == mix_dest); } #[test] fn test_filter() { - fail_unless!(filter(~[1u, 2u, 3u], is_odd) == ~[1u, 3u]); - fail_unless!(filter(~[1u, 2u, 4u, 8u, 16u], is_three) == ~[]); + assert!(filter(~[1u, 2u, 3u], is_odd) == ~[1u, 3u]); + assert!(filter(~[1u, 2u, 4u, 8u, 16u], is_three) == ~[]); } #[test] fn test_retain() { let mut v = ~[1, 2, 3, 4, 5]; v.retain(is_odd); - fail_unless!(v == ~[1, 3, 5]); + assert!(v == ~[1, 3, 5]); } #[test] @@ -3113,12 +3113,12 @@ mod tests { // Test on-stack fold. let mut v = ~[1u, 2u, 3u]; let mut sum = foldl(0u, v, add); - fail_unless!(sum == 6u); + assert!(sum == 6u); // Test on-heap fold. v = ~[1u, 2u, 3u, 4u, 5u]; sum = foldl(0u, v, add); - fail_unless!(sum == 15u); + assert!(sum == 15u); } #[test] @@ -3128,7 +3128,7 @@ mod tests { } let mut v = ~[1, 2, 3, 4]; let sum = foldl(0, v, sub); - fail_unless!(sum == -10); + assert!(sum == -10); } #[test] @@ -3138,7 +3138,7 @@ mod tests { } let mut v = ~[1, 2, 3, 4]; let sum = foldr(v, 0, sub); - fail_unless!(sum == -2); + assert!(sum == -2); } #[test] @@ -3154,18 +3154,18 @@ mod tests { for each(~[1, 2, 3]) |v| { i += *v; } - fail_unless!(i == 6); + assert!(i == 6); } #[test] fn test_iteri() { let mut i = 0; for eachi(~[1, 2, 3]) |j, v| { - if i == 0 { fail_unless!(*v == 1); } - fail_unless!(j + 1u == *v as uint); + if i == 0 { assert!(*v == 1); } + assert!(j + 1u == *v as uint); i += *v; } - fail_unless!(i == 6); + assert!(i == 6); } #[test] @@ -3180,21 +3180,21 @@ mod tests { fn test_each_reverse_nonempty() { let mut i = 0; for each_reverse(~[1, 2, 3]) |v| { - if i == 0 { fail_unless!(*v == 3); } + if i == 0 { assert!(*v == 3); } i += *v } - fail_unless!(i == 6); + assert!(i == 6); } #[test] fn test_eachi_reverse() { let mut i = 0; for eachi_reverse(~[0, 1, 2]) |j, v| { - if i == 0 { fail_unless!(*v == 2); } - fail_unless!(j == *v as uint); + if i == 0 { assert!(*v == 2); } + assert!(j == *v as uint); i += *v; } - fail_unless!(i == 3); + assert!(i == 3); } #[test] @@ -3211,47 +3211,47 @@ mod tests { results = ~[]; for each_permutation(~[]) |v| { results.push(from_slice(v)); } - fail_unless!(results == ~[~[]]); + assert!(results == ~[~[]]); results = ~[]; for each_permutation(~[7]) |v| { results.push(from_slice(v)); } - fail_unless!(results == ~[~[7]]); + assert!(results == ~[~[7]]); results = ~[]; for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); } - fail_unless!(results == ~[~[1,1],~[1,1]]); + assert!(results == ~[~[1,1],~[1,1]]); results = ~[]; for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); } - fail_unless!(results == + assert!(results == ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]); } #[test] fn test_any_and_all() { - fail_unless!(any(~[1u, 2u, 3u], is_three)); - fail_unless!(!any(~[0u, 1u, 2u], is_three)); - fail_unless!(any(~[1u, 2u, 3u, 4u, 5u], is_three)); - fail_unless!(!any(~[1u, 2u, 4u, 5u, 6u], is_three)); + assert!(any(~[1u, 2u, 3u], is_three)); + assert!(!any(~[0u, 1u, 2u], is_three)); + assert!(any(~[1u, 2u, 3u, 4u, 5u], is_three)); + assert!(!any(~[1u, 2u, 4u, 5u, 6u], is_three)); - fail_unless!(all(~[3u, 3u, 3u], is_three)); - fail_unless!(!all(~[3u, 3u, 2u], is_three)); - fail_unless!(all(~[3u, 3u, 3u, 3u, 3u], is_three)); - fail_unless!(!all(~[3u, 3u, 0u, 1u, 2u], is_three)); + assert!(all(~[3u, 3u, 3u], is_three)); + assert!(!all(~[3u, 3u, 2u], is_three)); + assert!(all(~[3u, 3u, 3u, 3u, 3u], is_three)); + assert!(!all(~[3u, 3u, 0u, 1u, 2u], is_three)); } #[test] fn test_any2_and_all2() { - fail_unless!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal)); - fail_unless!(any2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal)); - fail_unless!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal)); - fail_unless!(any2(~[2u, 4u, 6u], ~[2u, 4u], is_equal)); + assert!(any2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal)); + assert!(any2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal)); + assert!(!any2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal)); + assert!(any2(~[2u, 4u, 6u], ~[2u, 4u], is_equal)); - fail_unless!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal)); - fail_unless!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal)); - fail_unless!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal)); - fail_unless!(!all2(~[2u, 4u, 6u], ~[2u, 4u], is_equal)); + assert!(all2(~[2u, 4u, 6u], ~[2u, 4u, 6u], is_equal)); + assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 3u], is_equal)); + assert!(!all2(~[1u, 2u, 3u], ~[4u, 5u, 6u], is_equal)); + assert!(!all2(~[2u, 4u, 6u], ~[2u, 4u], is_equal)); } #[test] @@ -3261,26 +3261,26 @@ mod tests { let z1 = zip(v1, v2); - fail_unless!((1, 4) == z1[0]); - fail_unless!((2, 5) == z1[1]); - fail_unless!((3, 6) == z1[2]); + assert!((1, 4) == z1[0]); + assert!((2, 5) == z1[1]); + assert!((3, 6) == z1[2]); let (left, right) = unzip(z1); - fail_unless!((1, 4) == (left[0], right[0])); - fail_unless!((2, 5) == (left[1], right[1])); - fail_unless!((3, 6) == (left[2], right[2])); + assert!((1, 4) == (left[0], right[0])); + assert!((2, 5) == (left[1], right[1])); + assert!((3, 6) == (left[2], right[2])); } #[test] fn test_position_elem() { - fail_unless!(position_elem(~[], &1).is_none()); + assert!(position_elem(~[], &1).is_none()); let v1 = ~[1, 2, 3, 3, 2, 5]; - fail_unless!(position_elem(v1, &1) == Some(0u)); - fail_unless!(position_elem(v1, &2) == Some(1u)); - fail_unless!(position_elem(v1, &5) == Some(5u)); - fail_unless!(position_elem(v1, &4).is_none()); + assert!(position_elem(v1, &1) == Some(0u)); + assert!(position_elem(v1, &2) == Some(1u)); + assert!(position_elem(v1, &5) == Some(5u)); + assert!(position_elem(v1, &4).is_none()); } #[test] @@ -3288,178 +3288,178 @@ mod tests { fn less_than_three(i: &int) -> bool { *i < 3 } fn is_eighteen(i: &int) -> bool { *i == 18 } - fail_unless!(position(~[], less_than_three).is_none()); + assert!(position(~[], less_than_three).is_none()); let v1 = ~[5, 4, 3, 2, 1]; - fail_unless!(position(v1, less_than_three) == Some(3u)); - fail_unless!(position(v1, is_eighteen).is_none()); + assert!(position(v1, less_than_three) == Some(3u)); + assert!(position(v1, is_eighteen).is_none()); } #[test] fn test_position_between() { - fail_unless!(position_between(~[], 0u, 0u, f).is_none()); + assert!(position_between(~[], 0u, 0u, f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(position_between(v, 0u, 0u, f).is_none()); - fail_unless!(position_between(v, 0u, 1u, f).is_none()); - fail_unless!(position_between(v, 0u, 2u, f) == Some(1u)); - fail_unless!(position_between(v, 0u, 3u, f) == Some(1u)); - fail_unless!(position_between(v, 0u, 4u, f) == Some(1u)); + assert!(position_between(v, 0u, 0u, f).is_none()); + assert!(position_between(v, 0u, 1u, f).is_none()); + assert!(position_between(v, 0u, 2u, f) == Some(1u)); + assert!(position_between(v, 0u, 3u, f) == Some(1u)); + assert!(position_between(v, 0u, 4u, f) == Some(1u)); - fail_unless!(position_between(v, 1u, 1u, f).is_none()); - fail_unless!(position_between(v, 1u, 2u, f) == Some(1u)); - fail_unless!(position_between(v, 1u, 3u, f) == Some(1u)); - fail_unless!(position_between(v, 1u, 4u, f) == Some(1u)); + assert!(position_between(v, 1u, 1u, f).is_none()); + assert!(position_between(v, 1u, 2u, f) == Some(1u)); + assert!(position_between(v, 1u, 3u, f) == Some(1u)); + assert!(position_between(v, 1u, 4u, f) == Some(1u)); - fail_unless!(position_between(v, 2u, 2u, f).is_none()); - fail_unless!(position_between(v, 2u, 3u, f).is_none()); - fail_unless!(position_between(v, 2u, 4u, f) == Some(3u)); + assert!(position_between(v, 2u, 2u, f).is_none()); + assert!(position_between(v, 2u, 3u, f).is_none()); + assert!(position_between(v, 2u, 4u, f) == Some(3u)); - fail_unless!(position_between(v, 3u, 3u, f).is_none()); - fail_unless!(position_between(v, 3u, 4u, f) == Some(3u)); + assert!(position_between(v, 3u, 3u, f).is_none()); + assert!(position_between(v, 3u, 4u, f) == Some(3u)); - fail_unless!(position_between(v, 4u, 4u, f).is_none()); + assert!(position_between(v, 4u, 4u, f).is_none()); } #[test] fn test_find() { - fail_unless!(find(~[], f).is_none()); + assert!(find(~[], f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(find(v, f) == Some((1, 'b'))); - fail_unless!(find(v, g).is_none()); + assert!(find(v, f) == Some((1, 'b'))); + assert!(find(v, g).is_none()); } #[test] fn test_find_between() { - fail_unless!(find_between(~[], 0u, 0u, f).is_none()); + assert!(find_between(~[], 0u, 0u, f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(find_between(v, 0u, 0u, f).is_none()); - fail_unless!(find_between(v, 0u, 1u, f).is_none()); - fail_unless!(find_between(v, 0u, 2u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 0u, 3u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 0u, 4u, f) == Some((1, 'b'))); + assert!(find_between(v, 0u, 0u, f).is_none()); + assert!(find_between(v, 0u, 1u, f).is_none()); + assert!(find_between(v, 0u, 2u, f) == Some((1, 'b'))); + assert!(find_between(v, 0u, 3u, f) == Some((1, 'b'))); + assert!(find_between(v, 0u, 4u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 1u, 1u, f).is_none()); - fail_unless!(find_between(v, 1u, 2u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 1u, 3u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 1u, 4u, f) == Some((1, 'b'))); + assert!(find_between(v, 1u, 1u, f).is_none()); + assert!(find_between(v, 1u, 2u, f) == Some((1, 'b'))); + assert!(find_between(v, 1u, 3u, f) == Some((1, 'b'))); + assert!(find_between(v, 1u, 4u, f) == Some((1, 'b'))); - fail_unless!(find_between(v, 2u, 2u, f).is_none()); - fail_unless!(find_between(v, 2u, 3u, f).is_none()); - fail_unless!(find_between(v, 2u, 4u, f) == Some((3, 'b'))); + assert!(find_between(v, 2u, 2u, f).is_none()); + assert!(find_between(v, 2u, 3u, f).is_none()); + assert!(find_between(v, 2u, 4u, f) == Some((3, 'b'))); - fail_unless!(find_between(v, 3u, 3u, f).is_none()); - fail_unless!(find_between(v, 3u, 4u, f) == Some((3, 'b'))); + assert!(find_between(v, 3u, 3u, f).is_none()); + assert!(find_between(v, 3u, 4u, f) == Some((3, 'b'))); - fail_unless!(find_between(v, 4u, 4u, f).is_none()); + assert!(find_between(v, 4u, 4u, f).is_none()); } #[test] fn test_rposition() { - fail_unless!(find(~[], f).is_none()); + assert!(find(~[], f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(position(v, f) == Some(1u)); - fail_unless!(position(v, g).is_none()); + assert!(position(v, f) == Some(1u)); + assert!(position(v, g).is_none()); } #[test] fn test_rposition_between() { - fail_unless!(rposition_between(~[], 0u, 0u, f).is_none()); + assert!(rposition_between(~[], 0u, 0u, f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(rposition_between(v, 0u, 0u, f).is_none()); - fail_unless!(rposition_between(v, 0u, 1u, f).is_none()); - fail_unless!(rposition_between(v, 0u, 2u, f) == Some(1u)); - fail_unless!(rposition_between(v, 0u, 3u, f) == Some(1u)); - fail_unless!(rposition_between(v, 0u, 4u, f) == Some(3u)); + assert!(rposition_between(v, 0u, 0u, f).is_none()); + assert!(rposition_between(v, 0u, 1u, f).is_none()); + assert!(rposition_between(v, 0u, 2u, f) == Some(1u)); + assert!(rposition_between(v, 0u, 3u, f) == Some(1u)); + assert!(rposition_between(v, 0u, 4u, f) == Some(3u)); - fail_unless!(rposition_between(v, 1u, 1u, f).is_none()); - fail_unless!(rposition_between(v, 1u, 2u, f) == Some(1u)); - fail_unless!(rposition_between(v, 1u, 3u, f) == Some(1u)); - fail_unless!(rposition_between(v, 1u, 4u, f) == Some(3u)); + assert!(rposition_between(v, 1u, 1u, f).is_none()); + assert!(rposition_between(v, 1u, 2u, f) == Some(1u)); + assert!(rposition_between(v, 1u, 3u, f) == Some(1u)); + assert!(rposition_between(v, 1u, 4u, f) == Some(3u)); - fail_unless!(rposition_between(v, 2u, 2u, f).is_none()); - fail_unless!(rposition_between(v, 2u, 3u, f).is_none()); - fail_unless!(rposition_between(v, 2u, 4u, f) == Some(3u)); + assert!(rposition_between(v, 2u, 2u, f).is_none()); + assert!(rposition_between(v, 2u, 3u, f).is_none()); + assert!(rposition_between(v, 2u, 4u, f) == Some(3u)); - fail_unless!(rposition_between(v, 3u, 3u, f).is_none()); - fail_unless!(rposition_between(v, 3u, 4u, f) == Some(3u)); + assert!(rposition_between(v, 3u, 3u, f).is_none()); + assert!(rposition_between(v, 3u, 4u, f) == Some(3u)); - fail_unless!(rposition_between(v, 4u, 4u, f).is_none()); + assert!(rposition_between(v, 4u, 4u, f).is_none()); } #[test] fn test_rfind() { - fail_unless!(rfind(~[], f).is_none()); + assert!(rfind(~[], f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(rfind(v, f) == Some((3, 'b'))); - fail_unless!(rfind(v, g).is_none()); + assert!(rfind(v, f) == Some((3, 'b'))); + assert!(rfind(v, g).is_none()); } #[test] fn test_rfind_between() { - fail_unless!(rfind_between(~[], 0u, 0u, f).is_none()); + assert!(rfind_between(~[], 0u, 0u, f).is_none()); fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; - fail_unless!(rfind_between(v, 0u, 0u, f).is_none()); - fail_unless!(rfind_between(v, 0u, 1u, f).is_none()); - fail_unless!(rfind_between(v, 0u, 2u, f) == Some((1, 'b'))); - fail_unless!(rfind_between(v, 0u, 3u, f) == Some((1, 'b'))); - fail_unless!(rfind_between(v, 0u, 4u, f) == Some((3, 'b'))); + assert!(rfind_between(v, 0u, 0u, f).is_none()); + assert!(rfind_between(v, 0u, 1u, f).is_none()); + assert!(rfind_between(v, 0u, 2u, f) == Some((1, 'b'))); + assert!(rfind_between(v, 0u, 3u, f) == Some((1, 'b'))); + assert!(rfind_between(v, 0u, 4u, f) == Some((3, 'b'))); - fail_unless!(rfind_between(v, 1u, 1u, f).is_none()); - fail_unless!(rfind_between(v, 1u, 2u, f) == Some((1, 'b'))); - fail_unless!(rfind_between(v, 1u, 3u, f) == Some((1, 'b'))); - fail_unless!(rfind_between(v, 1u, 4u, f) == Some((3, 'b'))); + assert!(rfind_between(v, 1u, 1u, f).is_none()); + assert!(rfind_between(v, 1u, 2u, f) == Some((1, 'b'))); + assert!(rfind_between(v, 1u, 3u, f) == Some((1, 'b'))); + assert!(rfind_between(v, 1u, 4u, f) == Some((3, 'b'))); - fail_unless!(rfind_between(v, 2u, 2u, f).is_none()); - fail_unless!(rfind_between(v, 2u, 3u, f).is_none()); - fail_unless!(rfind_between(v, 2u, 4u, f) == Some((3, 'b'))); + assert!(rfind_between(v, 2u, 2u, f).is_none()); + assert!(rfind_between(v, 2u, 3u, f).is_none()); + assert!(rfind_between(v, 2u, 4u, f) == Some((3, 'b'))); - fail_unless!(rfind_between(v, 3u, 3u, f).is_none()); - fail_unless!(rfind_between(v, 3u, 4u, f) == Some((3, 'b'))); + assert!(rfind_between(v, 3u, 3u, f).is_none()); + assert!(rfind_between(v, 3u, 4u, f) == Some((3, 'b'))); - fail_unless!(rfind_between(v, 4u, 4u, f).is_none()); + assert!(rfind_between(v, 4u, 4u, f).is_none()); } #[test] fn reverse_and_reversed() { let mut v: ~[int] = ~[10, 20]; - fail_unless!(v[0] == 10); - fail_unless!(v[1] == 20); + assert!(v[0] == 10); + assert!(v[1] == 20); reverse(v); - fail_unless!(v[0] == 20); - fail_unless!(v[1] == 10); + assert!(v[0] == 20); + assert!(v[1] == 10); let v2 = reversed::(~[10, 20]); - fail_unless!(v2[0] == 20); - fail_unless!(v2[1] == 10); + assert!(v2[0] == 20); + assert!(v2[1] == 10); v[0] = 30; - fail_unless!(v2[0] == 20); + assert!(v2[0] == 20); // Make sure they work with 0-length vectors too. let v4 = reversed::(~[]); - fail_unless!(v4 == ~[]); + assert!(v4 == ~[]); let mut v3: ~[int] = ~[]; reverse::(v3); } @@ -3467,30 +3467,30 @@ mod tests { #[test] fn reversed_mut() { let mut v2 = reversed::(~[10, 20]); - fail_unless!(v2[0] == 20); - fail_unless!(v2[1] == 10); + assert!(v2[0] == 20); + assert!(v2[1] == 10); } #[test] fn test_split() { fn f(x: &int) -> bool { *x == 3 } - fail_unless!(split(~[], f) == ~[]); - fail_unless!(split(~[1, 2], f) == ~[~[1, 2]]); - fail_unless!(split(~[3, 1, 2], f) == ~[~[], ~[1, 2]]); - fail_unless!(split(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); - fail_unless!(split(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]); + assert!(split(~[], f) == ~[]); + assert!(split(~[1, 2], f) == ~[~[1, 2]]); + assert!(split(~[3, 1, 2], f) == ~[~[], ~[1, 2]]); + assert!(split(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); + assert!(split(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]); } #[test] fn test_splitn() { fn f(x: &int) -> bool { *x == 3 } - fail_unless!(splitn(~[], 1u, f) == ~[]); - fail_unless!(splitn(~[1, 2], 1u, f) == ~[~[1, 2]]); - fail_unless!(splitn(~[3, 1, 2], 1u, f) == ~[~[], ~[1, 2]]); - fail_unless!(splitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); - fail_unless!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) == + assert!(splitn(~[], 1u, f) == ~[]); + assert!(splitn(~[1, 2], 1u, f) == ~[~[1, 2]]); + assert!(splitn(~[3, 1, 2], 1u, f) == ~[~[], ~[1, 2]]); + assert!(splitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); + assert!(splitn(~[1, 2, 3, 4, 3, 5], 1u, f) == ~[~[1, 2], ~[4, 3, 5]]); } @@ -3498,10 +3498,10 @@ mod tests { fn test_rsplit() { fn f(x: &int) -> bool { *x == 3 } - fail_unless!(rsplit(~[], f) == ~[]); - fail_unless!(rsplit(~[1, 2], f) == ~[~[1, 2]]); - fail_unless!(rsplit(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); - fail_unless!(rsplit(~[1, 2, 3, 4, 3, 5], f) == + assert!(rsplit(~[], f) == ~[]); + assert!(rsplit(~[1, 2], f) == ~[~[1, 2]]); + assert!(rsplit(~[1, 2, 3], f) == ~[~[1, 2], ~[]]); + assert!(rsplit(~[1, 2, 3, 4, 3, 5], f) == ~[~[1, 2], ~[4], ~[5]]); } @@ -3509,57 +3509,57 @@ mod tests { fn test_rsplitn() { fn f(x: &int) -> bool { *x == 3 } - fail_unless!(rsplitn(~[], 1u, f) == ~[]); - fail_unless!(rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]); - fail_unless!(rsplitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); - fail_unless!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) == + assert!(rsplitn(~[], 1u, f) == ~[]); + assert!(rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]); + assert!(rsplitn(~[1, 2, 3], 1u, f) == ~[~[1, 2], ~[]]); + assert!(rsplitn(~[1, 2, 3, 4, 3, 5], 1u, f) == ~[~[1, 2, 3, 4], ~[5]]); } #[test] fn test_partition() { // FIXME (#4355 maybe): using v.partition here crashes - fail_unless!(partition(~[], |x: &int| *x < 3) == (~[], ~[])); - fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 4) == + assert!(partition(~[], |x: &int| *x < 3) == (~[], ~[])); + assert!(partition(~[1, 2, 3], |x: &int| *x < 4) == (~[1, 2, 3], ~[])); - fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 2) == + assert!(partition(~[1, 2, 3], |x: &int| *x < 2) == (~[1], ~[2, 3])); - fail_unless!(partition(~[1, 2, 3], |x: &int| *x < 0) == + assert!(partition(~[1, 2, 3], |x: &int| *x < 0) == (~[], ~[1, 2, 3])); } #[test] fn test_partitioned() { - fail_unless!((~[]).partitioned(|x: &int| *x < 3) == (~[], ~[])); - fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) == + assert!((~[]).partitioned(|x: &int| *x < 3) == (~[], ~[])); + assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 4) == (~[1, 2, 3], ~[])); - fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) == + assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 2) == (~[1], ~[2, 3])); - fail_unless!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) == + assert!((~[1, 2, 3]).partitioned(|x: &int| *x < 0) == (~[], ~[1, 2, 3])); } #[test] fn test_concat() { - fail_unless!(concat(~[~[1], ~[2,3]]) == ~[1, 2, 3]); + assert!(concat(~[~[1], ~[2,3]]) == ~[1, 2, 3]); } #[test] fn test_connect() { - fail_unless!(connect(~[], &0) == ~[]); - fail_unless!(connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]); - fail_unless!(connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]); + assert!(connect(~[], &0) == ~[]); + assert!(connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]); + assert!(connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]); } #[test] fn test_windowed () { - fail_unless!(~[~[1u,2u,3u],~[2u,3u,4u],~[3u,4u,5u],~[4u,5u,6u]] + assert!(~[~[1u,2u,3u],~[2u,3u,4u],~[3u,4u,5u],~[4u,5u,6u]] == windowed (3u, ~[1u,2u,3u,4u,5u,6u])); - fail_unless!(~[~[1u,2u,3u,4u],~[2u,3u,4u,5u],~[3u,4u,5u,6u]] + assert!(~[~[1u,2u,3u,4u],~[2u,3u,4u,5u],~[3u,4u,5u,6u]] == windowed (4u, ~[1u,2u,3u,4u,5u,6u])); - fail_unless!(~[] == windowed (7u, ~[1u,2u,3u,4u,5u,6u])); + assert!(~[] == windowed (7u, ~[1u,2u,3u,4u,5u,6u])); } #[test] @@ -3573,26 +3573,26 @@ mod tests { fn test_unshift() { let mut x = ~[1, 2, 3]; x.unshift(0); - fail_unless!(x == ~[0, 1, 2, 3]); + assert!(x == ~[0, 1, 2, 3]); } #[test] fn test_insert() { let mut a = ~[1, 2, 4]; a.insert(2, 3); - fail_unless!(a == ~[1, 2, 3, 4]); + assert!(a == ~[1, 2, 3, 4]); let mut a = ~[1, 2, 3]; a.insert(0, 0); - fail_unless!(a == ~[0, 1, 2, 3]); + assert!(a == ~[0, 1, 2, 3]); let mut a = ~[1, 2, 3]; a.insert(3, 4); - fail_unless!(a == ~[1, 2, 3, 4]); + assert!(a == ~[1, 2, 3, 4]); let mut a = ~[]; a.insert(0, 1); - fail_unless!(a == ~[1]); + assert!(a == ~[1]); } #[test] @@ -3607,15 +3607,15 @@ mod tests { fn test_remove() { let mut a = ~[1, 2, 3, 4]; a.remove(2); - fail_unless!(a == ~[1, 2, 4]); + assert!(a == ~[1, 2, 4]); let mut a = ~[1, 2, 3]; a.remove(0); - fail_unless!(a == ~[2, 3]); + assert!(a == ~[2, 3]); let mut a = ~[1]; a.remove(0); - fail_unless!(a == ~[]); + assert!(a == ~[]); } #[test] @@ -3630,19 +3630,19 @@ mod tests { fn test_capacity() { let mut v = ~[0u64]; reserve(&mut v, 10u); - fail_unless!(capacity(&v) == 10u); + assert!(capacity(&v) == 10u); let mut v = ~[0u32]; reserve(&mut v, 10u); - fail_unless!(capacity(&v) == 10u); + assert!(capacity(&v) == 10u); } #[test] fn test_slice_2() { let v = ~[1, 2, 3, 4, 5]; let v = v.slice(1u, 3u); - fail_unless!(v.len() == 2u); - fail_unless!(v[0] == 2); - fail_unless!(v[1] == 3); + assert!(v.len() == 2u); + assert!(v[0] == 2); + assert!(v[1] == 3); } diff --git a/src/libfuzzer/ast_match.rs b/src/libfuzzer/ast_match.rs index eedd3bebedfc4..806a7aedd3104 100644 --- a/src/libfuzzer/ast_match.rs +++ b/src/libfuzzer/ast_match.rs @@ -29,13 +29,13 @@ fn builtin_equal(&&a: T, &&b: T) -> bool { return a == b; } fn builtin_equal_int(&&a: int, &&b: int) -> bool { return a == b; } fn main() { - fail_unless!((builtin_equal(5, 5))); - fail_unless!((!builtin_equal(5, 4))); - fail_unless!((!vec_equal(~[5, 5], ~[5], bind builtin_equal(_, _)))); - fail_unless!((!vec_equal(~[5, 5], ~[5], builtin_equal_int))); - fail_unless!((!vec_equal(~[5, 5], ~[5, 4], builtin_equal_int))); - fail_unless!((!vec_equal(~[5, 5], ~[4, 5], builtin_equal_int))); - fail_unless!((vec_equal(~[5, 5], ~[5, 5], builtin_equal_int))); + assert!((builtin_equal(5, 5))); + assert!((!builtin_equal(5, 4))); + assert!((!vec_equal(~[5, 5], ~[5], bind builtin_equal(_, _)))); + assert!((!vec_equal(~[5, 5], ~[5], builtin_equal_int))); + assert!((!vec_equal(~[5, 5], ~[5, 4], builtin_equal_int))); + assert!((!vec_equal(~[5, 5], ~[4, 5], builtin_equal_int))); + assert!((vec_equal(~[5, 5], ~[5, 5], builtin_equal_int))); error!("Pass"); } diff --git a/src/libfuzzer/cycles.rs b/src/libfuzzer/cycles.rs index dcf9a493c558a..c18d1f43b5678 100644 --- a/src/libfuzzer/cycles.rs +++ b/src/libfuzzer/cycles.rs @@ -14,12 +14,12 @@ use uint::range; // random uint less than n fn under(r : rand::rng, n : uint) -> uint { - fail_unless!(n != 0u); r.next() as uint % n + assert!(n != 0u); r.next() as uint % n } // random choice from a vec fn choice(r : rand::rng, v : ~[const T]) -> T { - fail_unless!(vec::len(v) != 0u); v[under(r, vec::len(v))] + assert!(vec::len(v) != 0u); v[under(r, vec::len(v))] } // k in n chance of being true diff --git a/src/libfuzzer/fuzzer.rc b/src/libfuzzer/fuzzer.rc index 1c85536d19548..aad48bbb8e636 100644 --- a/src/libfuzzer/fuzzer.rc +++ b/src/libfuzzer/fuzzer.rc @@ -377,13 +377,13 @@ pub fn check_whole_compiler(code: ~str, suggested_filename_prefix: &Path, pub fn removeIfExists(filename: &Path) { // So sketchy! - fail_unless!(!contains(filename.to_str(), ~" ")); + assert!(!contains(filename.to_str(), ~" ")); run::program_output(~"bash", ~[~"-c", ~"rm " + filename.to_str()]); } pub fn removeDirIfExists(filename: &Path) { // So sketchy! - fail_unless!(!contains(filename.to_str(), ~" ")); + assert!(!contains(filename.to_str(), ~" ")); run::program_output(~"bash", ~[~"-c", ~"rm -r " + filename.to_str()]); } diff --git a/src/libfuzzer/rand_util.rs b/src/libfuzzer/rand_util.rs index 25b1669d86f75..2422c146e245f 100644 --- a/src/libfuzzer/rand_util.rs +++ b/src/libfuzzer/rand_util.rs @@ -13,12 +13,12 @@ use std::rand; // random uint less than n fn under(r : rand::rng, n : uint) -> uint { - fail_unless!(n != 0u); r.next() as uint % n + assert!(n != 0u); r.next() as uint % n } // random choice from a vec fn choice(r : rand::rng, v : ~[T]) -> T { - fail_unless!(vec::len(v) != 0u); v[under(r, vec::len(v))] + assert!(vec::len(v) != 0u); v[under(r, vec::len(v))] } // 1 in n chance of being true @@ -49,12 +49,12 @@ fn shuffled(r : rand::rng, v : ~[T]) -> ~[T] { // * weighted_vec is O(total weight) space type weighted = { weight: uint, item: T }; fn weighted_choice(r : rand::rng, v : ~[weighted]) -> T { - fail_unless!(vec::len(v) != 0u); + assert!(vec::len(v) != 0u); let total = 0u; for {weight: weight, item: _} in v { total += weight; } - fail_unless!(total >= 0u); + assert!(total >= 0u); let chosen = under(r, total); let so_far = 0u; for {weight: weight, item: item} in v { diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index 1137b2a2c08a0..6c485df84b484 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -118,7 +118,7 @@ pub fn get_rpath_relative_to_output(os: session::os, -> Path { use core::os; - fail_unless!(not_win32(os)); + assert!(not_win32(os)); // Mac doesn't appear to support $ORIGIN let prefix = match os { @@ -134,8 +134,8 @@ pub fn get_rpath_relative_to_output(os: session::os, // Find the relative path from one file to another pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path { - fail_unless!(abs1.is_absolute); - fail_unless!(abs2.is_absolute); + assert!(abs1.is_absolute); + assert!(abs2.is_absolute); let abs1 = abs1.normalize(); let abs2 = abs2.normalize(); debug!("finding relative path from %s to %s", @@ -144,8 +144,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path { let split2: &[~str] = abs2.components; let len1 = vec::len(split1); let len2 = vec::len(split2); - fail_unless!(len1 > 0); - fail_unless!(len2 > 0); + assert!(len1 > 0); + assert!(len2 > 0); let max_common_path = uint::min(len1, len2) - 1; let mut start_idx = 0; @@ -215,7 +215,7 @@ mod test { pub fn test_rpaths_to_flags() { let flags = rpaths_to_flags(~[Path("path1"), Path("path2")]); - fail_unless!(flags == ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]); + assert!(flags == ~[~"-Wl,-rpath,path1", ~"-Wl,-rpath,path2"]); } #[test] @@ -226,13 +226,13 @@ mod test { debug!("test_prefix_path: %s vs. %s", res.to_str(), d.to_str()); - fail_unless!(str::ends_with(res.to_str(), d.to_str())); + assert!(str::ends_with(res.to_str(), d.to_str())); } #[test] pub fn test_prefix_rpath_abs() { let res = get_install_prefix_rpath("triple"); - fail_unless!(res.is_absolute); + assert!(res.is_absolute); } #[test] @@ -240,7 +240,7 @@ mod test { let res = minimize_rpaths([Path("rpath1"), Path("rpath2"), Path("rpath1")]); - fail_unless!(res == ~[Path("rpath1"), Path("rpath2")]); + assert!(res == ~[Path("rpath1"), Path("rpath2")]); } #[test] @@ -249,7 +249,7 @@ mod test { Path("1a"), Path("4a"),Path("1a"), Path("2"), Path("3"), Path("4a"), Path("3")]); - fail_unless!(res == ~[Path("1a"), Path("2"), Path("4a"), Path("3")]); + assert!(res == ~[Path("1a"), Path("2"), Path("4a"), Path("3")]); } #[test] @@ -257,7 +257,7 @@ mod test { let p1 = Path("/usr/bin/rustc"); let p2 = Path("/usr/lib/mylib"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("../lib")); + assert!(res == Path("../lib")); } #[test] @@ -265,7 +265,7 @@ mod test { let p1 = Path("/usr/bin/rustc"); let p2 = Path("/usr/bin/../lib/mylib"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("../lib")); + assert!(res == Path("../lib")); } #[test] @@ -273,7 +273,7 @@ mod test { let p1 = Path("/usr/bin/whatever/rustc"); let p2 = Path("/usr/lib/whatever/mylib"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("../../lib/whatever")); + assert!(res == Path("../../lib/whatever")); } #[test] @@ -281,7 +281,7 @@ mod test { let p1 = Path("/usr/bin/whatever/../rustc"); let p2 = Path("/usr/lib/whatever/mylib"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("../lib/whatever")); + assert!(res == Path("../lib/whatever")); } #[test] @@ -289,7 +289,7 @@ mod test { let p1 = Path("/usr/bin/whatever/../rustc"); let p2 = Path("/usr/lib/whatever/../mylib"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("../lib")); + assert!(res == Path("../lib")); } #[test] @@ -297,7 +297,7 @@ mod test { let p1 = Path("/1"); let p2 = Path("/2/3"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("2")); + assert!(res == Path("2")); } #[test] @@ -305,7 +305,7 @@ mod test { let p1 = Path("/1/2"); let p2 = Path("/3"); let res = get_relative_to(&p1, &p2); - fail_unless!(res == Path("..")); + assert!(res == Path("..")); } #[test] @@ -318,7 +318,7 @@ mod test { debug!("test_relative_tu8: %s vs. %s", res.to_str(), Path(".").to_str()); - fail_unless!(res == Path(".")); + assert!(res == Path(".")); } #[test] @@ -328,7 +328,7 @@ mod test { let o = session::os_linux; let res = get_rpath_relative_to_output(o, &Path("bin/rustc"), &Path("lib/libstd.so")); - fail_unless!(res.to_str() == ~"$ORIGIN/../lib"); + assert!(res.to_str() == ~"$ORIGIN/../lib"); } #[test] @@ -337,7 +337,7 @@ mod test { let o = session::os_freebsd; let res = get_rpath_relative_to_output(o, &Path("bin/rustc"), &Path("lib/libstd.so")); - fail_unless!(res.to_str() == ~"$ORIGIN/../lib"); + assert!(res.to_str() == ~"$ORIGIN/../lib"); } #[test] @@ -348,7 +348,7 @@ mod test { let res = get_rpath_relative_to_output(o, &Path("bin/rustc"), &Path("lib/libstd.so")); - fail_unless!(res.to_str() == ~"@executable_path/../lib"); + assert!(res.to_str() == ~"@executable_path/../lib"); } #[test] @@ -358,6 +358,6 @@ mod test { res.to_str(), os::make_absolute(&Path("lib")).to_str()); - fail_unless!(res == os::make_absolute(&Path("lib"))); + assert!(res == os::make_absolute(&Path("lib"))); } } diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 3aa0959317a4a..93bc64eafa324 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -899,7 +899,7 @@ pub mod test { ~"rustc", matches, diagnostic::emit); let sess = build_session(sessopts, diagnostic::emit); let cfg = build_configuration(sess, ~"whatever", str_input(~"")); - fail_unless!((attr::contains_name(cfg, ~"test"))); + assert!((attr::contains_name(cfg, ~"test"))); } // When the user supplies --test and --cfg test, don't implicitly add @@ -919,7 +919,7 @@ pub mod test { let sess = build_session(sessopts, diagnostic::emit); let cfg = build_configuration(sess, ~"whatever", str_input(~"")); let test_items = attr::find_meta_items_by_name(cfg, ~"test"); - fail_unless!((vec::len(test_items) == 1u)); + assert!((vec::len(test_items) == 1u)); } } diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index 28ebc3f424ef0..d1f95dbeacca1 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -378,43 +378,43 @@ pub mod test { #[test] pub fn bin_crate_type_attr_results_in_bin_output() { let crate = make_crate(true, false); - fail_unless!(!building_library(unknown_crate, crate, false)); + assert!(!building_library(unknown_crate, crate, false)); } #[test] pub fn lib_crate_type_attr_results_in_lib_output() { let crate = make_crate(false, true); - fail_unless!(building_library(unknown_crate, crate, false)); + assert!(building_library(unknown_crate, crate, false)); } #[test] pub fn bin_option_overrides_lib_crate_type() { let crate = make_crate(false, true); - fail_unless!(!building_library(bin_crate, crate, false)); + assert!(!building_library(bin_crate, crate, false)); } #[test] pub fn lib_option_overrides_bin_crate_type() { let crate = make_crate(true, false); - fail_unless!(building_library(lib_crate, crate, false)); + assert!(building_library(lib_crate, crate, false)); } #[test] pub fn bin_crate_type_is_default() { let crate = make_crate(false, false); - fail_unless!(!building_library(unknown_crate, crate, false)); + assert!(!building_library(unknown_crate, crate, false)); } #[test] pub fn test_option_overrides_lib_crate_type() { let crate = make_crate(false, true); - fail_unless!(!building_library(unknown_crate, crate, true)); + assert!(!building_library(unknown_crate, crate, true)); } #[test] pub fn test_option_does_not_override_requested_lib_type() { let crate = make_crate(false, false); - fail_unless!(building_library(lib_crate, crate, true)); + assert!(building_library(lib_crate, crate, true)); } } diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index fa79217619df6..34678d1803c17 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -1472,8 +1472,8 @@ pub struct TypeNames { } pub fn associate_type(tn: @TypeNames, s: @str, t: TypeRef) { - fail_unless!(tn.type_names.insert(t, s)); - fail_unless!(tn.named_types.insert(s, t)); + assert!(tn.type_names.insert(t, s)); + assert!(tn.named_types.insert(s, t)); } pub fn type_has_name(tn: @TypeNames, t: TypeRef) -> Option<@str> { diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index 3a6e567cdbce5..b8bf27d762799 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -97,7 +97,7 @@ fn warn_if_multiple_versions(e: @mut Env, } })); - fail_unless!(!matches.is_empty()); + assert!(!matches.is_empty()); if matches.len() != 1u { diag.handler().warn( diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 51cc964e460d8..c836538e1e6c8 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -102,7 +102,7 @@ pub fn get_used_crate_files(cstore: &CStore) -> ~[Path] { } pub fn add_used_library(cstore: &mut CStore, lib: @~str) -> bool { - fail_unless!(*lib != ~""); + assert!(*lib != ~""); if cstore.used_libraries.contains(&*lib) { return false; } cstore.used_libraries.push(/*bad*/ copy *lib); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 29161a6db6425..dcea22b09d6d6 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1003,7 +1003,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] { let meta_items = get_meta_items(attr_doc); // Currently it's only possible to have a single meta item on // an attribute - fail_unless!((vec::len(meta_items) == 1u)); + assert!((vec::len(meta_items) == 1u)); let meta_item = meta_items[0]; attrs.push( codemap::spanned { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 8c90ec3f7f393..af9ab7d94f185 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1082,7 +1082,7 @@ fn encode_index(ebml_w: writer::Encoder, buckets: ~[@~[entry]], ebml_w.start_tag(tag_index_buckets_bucket); for vec::each(**bucket) |elt| { ebml_w.start_tag(tag_index_buckets_bucket_elt); - fail_unless!(elt.pos < 0xffff_ffff); + assert!(elt.pos < 0xffff_ffff); writer.write_be_u32(elt.pos as u32); write_fn(writer, elt.val); ebml_w.end_tag(); @@ -1092,7 +1092,7 @@ fn encode_index(ebml_w: writer::Encoder, buckets: ~[@~[entry]], ebml_w.end_tag(); ebml_w.start_tag(tag_index_table); for bucket_locs.each |pos| { - fail_unless!(*pos < 0xffff_ffff); + assert!(*pos < 0xffff_ffff); writer.write_be_u32(*pos as u32); } ebml_w.end_tag(); @@ -1102,7 +1102,7 @@ fn encode_index(ebml_w: writer::Encoder, buckets: ~[@~[entry]], fn write_str(writer: @io::Writer, &&s: ~str) { writer.write_str(s); } fn write_int(writer: @io::Writer, &&n: int) { - fail_unless!(n < 0x7fff_ffff); + assert!(n < 0x7fff_ffff); writer.write_be_u32(n as u32); } @@ -1163,8 +1163,8 @@ fn synthesize_crate_attrs(ecx: @EncodeContext, fn synthesize_link_attr(ecx: @EncodeContext, +items: ~[@meta_item]) -> attribute { - fail_unless!(!ecx.link_meta.name.is_empty()); - fail_unless!(!ecx.link_meta.vers.is_empty()); + assert!(!ecx.link_meta.name.is_empty()); + assert!(!ecx.link_meta.vers.is_empty()); let name_item = attr::mk_name_value_item_str(@~"name", @@ -1230,7 +1230,7 @@ fn encode_crate_deps(ecx: @EncodeContext, // Sanity-check the crate numbers let mut expected_cnum = 1; for deps.each |n| { - fail_unless!((n.cnum == expected_cnum)); + assert!((n.cnum == expected_cnum)); expected_cnum += 1; } diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 823d8e58d1108..e233bf78d789d 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -142,12 +142,12 @@ fn parse_sigil(st: @mut PState) -> ast::Sigil { } fn parse_vstore(st: @mut PState) -> ty::vstore { - fail_unless!(next(st) == '/'); + assert!(next(st) == '/'); let c = peek(st); if '0' <= c && c <= '9' { let n = parse_int(st) as uint; - fail_unless!(next(st) == '|'); + assert!(next(st) == '|'); return ty::vstore_fixed(n); } @@ -174,7 +174,7 @@ fn parse_substs(st: @mut PState, conv: conv_did) -> ty::substs { let self_ty = parse_opt(st, || parse_ty(st, conv) ); - fail_unless!(next(st) == '['); + assert!(next(st) == '['); let mut params: ~[ty::t] = ~[]; while peek(st) != ']' { params.push(parse_ty(st, conv)); } st.pos = st.pos + 1u; @@ -191,13 +191,13 @@ fn parse_bound_region(st: @mut PState) -> ty::bound_region { 's' => ty::br_self, 'a' => { let id = parse_int(st) as uint; - fail_unless!(next(st) == '|'); + assert!(next(st) == '|'); ty::br_anon(id) } '[' => ty::br_named(st.tcx.sess.ident_of(parse_str(st, ']'))), 'c' => { let id = parse_int(st); - fail_unless!(next(st) == '|'); + assert!(next(st) == '|'); ty::br_cap_avoid(id, @parse_bound_region(st)) }, _ => fail!(~"parse_bound_region: bad input") @@ -210,16 +210,16 @@ fn parse_region(st: @mut PState) -> ty::Region { ty::re_bound(parse_bound_region(st)) } 'f' => { - fail_unless!(next(st) == '['); + assert!(next(st) == '['); let id = parse_int(st); - fail_unless!(next(st) == '|'); + assert!(next(st) == '|'); let br = parse_bound_region(st); - fail_unless!(next(st) == ']'); + assert!(next(st) == ']'); ty::re_free(id, br) } 's' => { let id = parse_int(st); - fail_unless!(next(st) == '|'); + assert!(next(st) == '|'); ty::re_scope(id) } 't' => { @@ -271,18 +271,18 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t { } 'c' => return ty::mk_char(st.tcx), 't' => { - fail_unless!((next(st) == '[')); + assert!((next(st) == '[')); let def = parse_def(st, NominalType, conv); let substs = parse_substs(st, conv); - fail_unless!(next(st) == ']'); + assert!(next(st) == ']'); return ty::mk_enum(st.tcx, def, substs); } 'x' => { - fail_unless!(next(st) == '['); + assert!(next(st) == '['); let def = parse_def(st, NominalType, conv); let substs = parse_substs(st, conv); let store = parse_trait_store(st); - fail_unless!(next(st) == ']'); + assert!(next(st) == ']'); return ty::mk_trait(st.tcx, def, substs, store); } 'p' => { @@ -313,7 +313,7 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t { return ty::mk_estr(st.tcx, v); } 'T' => { - fail_unless!((next(st) == '[')); + assert!((next(st) == '[')); let mut params = ~[]; while peek(st) != ']' { params.push(parse_ty(st, conv)); } st.pos = st.pos + 1u; @@ -332,9 +332,9 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t { } '#' => { let pos = parse_hex(st); - fail_unless!((next(st) == ':')); + assert!((next(st) == ':')); let len = parse_hex(st); - fail_unless!((next(st) == '#')); + assert!((next(st) == '#')); let key = ty::creader_cache_key {cnum: st.crate, pos: pos, len: len }; @@ -355,10 +355,10 @@ fn parse_ty(st: @mut PState, conv: conv_did) -> ty::t { } 'B' => ty::mk_opaque_box(st.tcx), 'a' => { - fail_unless!((next(st) == '[')); + assert!((next(st) == '[')); let did = parse_def(st, NominalType, conv); let substs = parse_substs(st, conv); - fail_unless!((next(st) == ']')); + assert!((next(st) == ']')); return ty::mk_struct(st.tcx, did, substs); } c => { error!("unexpected char in type string: %c", c); fail!();} @@ -472,7 +472,7 @@ fn parse_bare_fn_ty(st: @mut PState, conv: conv_did) -> ty::BareFnTy { } fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig { - fail_unless!((next(st) == '[')); + assert!((next(st) == '[')); let mut inputs: ~[ty::arg] = ~[]; while peek(st) != ']' { let mode = parse_mode(st); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 7b7cf01d2b5db..8dcfaf2eb3510 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -175,7 +175,7 @@ pub impl ExtendedDecodeContext { */ // from_id_range should be non-empty - fail_unless!(!ast_util::empty(self.from_id_range)); + assert!(!ast_util::empty(self.from_id_range)); (id - self.from_id_range.min + self.to_id_range.min) } fn tr_def_id(&self, did: ast::def_id) -> ast::def_id { @@ -212,7 +212,7 @@ pub impl ExtendedDecodeContext { * refer to the current crate and to the new, inlined node-id. */ - fail_unless!(did.crate == ast::local_crate); + assert!(did.crate == ast::local_crate); ast::def_id { crate: ast::local_crate, node: self.tr_id(did.node) } } fn tr_span(&self, _span: span) -> span { @@ -1232,7 +1232,7 @@ fn roundtrip(in_item: Option<@ast::item>) { debug!("expected string: %s", exp_str); debug!("actual string : %s", out_str); - fail_unless!(exp_str == out_str); + assert!(exp_str == out_str); } #[test] @@ -1279,7 +1279,7 @@ fn test_simplification() { ).get()); match (item_out, item_exp) { (ast::ii_item(item_out), ast::ii_item(item_exp)) => { - fail_unless!(pprust::item_to_str(item_out, + assert!(pprust::item_to_str(item_out, ext_cx.parse_sess().interner) == pprust::item_to_str(item_exp, ext_cx.parse_sess().interner)); diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 9fb95fd489e45..fdea403cc2a00 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -132,7 +132,7 @@ pub fn raw_pat(p: @pat) -> @pat { } pub fn check_exhaustive(cx: @MatchCheckCtxt, sp: span, pats: ~[@pat]) { - fail_unless!((!pats.is_empty())); + assert!((!pats.is_empty())); let ext = match is_useful(cx, &pats.map(|p| ~[*p]), ~[wild()]) { not_useful => { // This is good, wildcard pattern isn't reachable diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 398b17a65b30c..024d862461d83 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -882,7 +882,7 @@ fn check_item_path_statement(cx: ty::ctxt, it: @ast::item) { fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) { fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool { let ident = cx.sess.str_of(ident); - fail_unless!(!ident.is_empty()); + assert!(!ident.is_empty()); let ident = ident_without_trailing_underscores(*ident); let ident = ident_without_leading_underscores(ident); char::is_uppercase(str::char_at(ident, 0)) && diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 35f2679a3c60e..e9e226d36d1f5 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -733,7 +733,7 @@ pub impl Liveness { fn live_on_entry(&self, ln: LiveNode, var: Variable) -> Option { - fail_unless!(ln.is_valid()); + assert!(ln.is_valid()); let reader = self.users[self.idx(ln, var)].reader; if reader.is_valid() {Some(self.ir.lnk(reader))} else {None} } @@ -748,14 +748,14 @@ pub impl Liveness { } fn used_on_entry(&self, ln: LiveNode, var: Variable) -> bool { - fail_unless!(ln.is_valid()); + assert!(ln.is_valid()); self.users[self.idx(ln, var)].used } fn assigned_on_entry(&self, ln: LiveNode, var: Variable) -> Option { - fail_unless!(ln.is_valid()); + assert!(ln.is_valid()); let writer = self.users[self.idx(ln, var)].writer; if writer.is_valid() {Some(self.ir.lnk(writer))} else {None} } @@ -1465,9 +1465,9 @@ pub impl Liveness { // repeat until fixed point is reached: while self.merge_from_succ(ln, body_ln, first_merge) { first_merge = false; - fail_unless!(cond_ln == self.propagate_through_opt_expr(cond, + assert!(cond_ln == self.propagate_through_opt_expr(cond, ln)); - fail_unless!(body_ln == self.with_loop_nodes(expr.id, succ, ln, + assert!(body_ln == self.with_loop_nodes(expr.id, succ, ln, || { self.propagate_through_block(body, cond_ln) })); diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index f49a37d73018f..f6025548d71c0 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -463,7 +463,7 @@ pub impl DetermineRpCtxt { /// variance `variance`. If `id` was already parameterized, then /// the new variance is joined with the old variance. fn add_rp(&mut self, id: ast::node_id, variance: region_variance) { - fail_unless!(id != 0); + assert!(id != 0); let old_variance = self.region_paramd_items.find(&id). map_consume(|x| *x); let joined_variance = match old_variance { diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 8371a6785d13d..8503fa2e2cdbe 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1407,7 +1407,7 @@ pub impl Resolver { match view_path.node { view_path_simple(_, full_path, _, _) => { let path_len = full_path.idents.len(); - fail_unless!(path_len != 0); + assert!(path_len != 0); for full_path.idents.eachi |i, ident| { if i != path_len - 1 { @@ -2083,7 +2083,7 @@ pub impl Resolver { // Decrement the count of unresolved imports. match resolution_result { Success(()) => { - fail_unless!(self.unresolved_imports >= 1); + assert!(self.unresolved_imports >= 1); self.unresolved_imports -= 1; } _ => { @@ -2099,7 +2099,7 @@ pub impl Resolver { if !resolution_result.indeterminate() { match *import_directive.subclass { GlobImport => { - fail_unless!(module_.glob_count >= 1); + assert!(module_.glob_count >= 1); module_.glob_count -= 1; } SingleImport(*) => { @@ -2266,7 +2266,7 @@ pub impl Resolver { } // We've successfully resolved the import. Write the results in. - fail_unless!(module_.import_resolutions.contains_key(&target)); + assert!(module_.import_resolutions.contains_key(&target)); let import_resolution = module_.import_resolutions.get(&target); match value_result { @@ -2329,7 +2329,7 @@ pub impl Resolver { } } - fail_unless!(import_resolution.outstanding_references >= 1); + assert!(import_resolution.outstanding_references >= 1); import_resolution.outstanding_references -= 1; debug!("(resolving single import) successfully resolved import"); @@ -2359,7 +2359,7 @@ pub impl Resolver { return Indeterminate; } - fail_unless!(containing_module.glob_count == 0); + assert!(containing_module.glob_count == 0); // Add all resolved imports from the containing module. for containing_module.import_resolutions.each @@ -2560,7 +2560,7 @@ pub impl Resolver { span: span) -> ResolveResult<@mut Module> { let module_path_len = module_path.len(); - fail_unless!(module_path_len > 0); + assert!(module_path_len > 0); debug!("(resolving module path for import) processing `%s` rooted at \ `%s`", @@ -2923,7 +2923,7 @@ pub impl Resolver { // If this is a search of all imports, we should be done with glob // resolution at this point. if name_search_type == SearchItemsAndAllImports { - fail_unless!(module_.glob_count == 0); + assert!(module_.glob_count == 0); } // Check the list of resolved imports. diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index f324640ef2cf4..12eaeb77d1103 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -1259,7 +1259,7 @@ pub fn compile_submatch(bcx: block, /* For an empty match, a fall-through case must exist */ - fail_unless!((m.len() > 0u || chk.is_some())); + assert!((m.len() > 0u || chk.is_some())); let _icx = bcx.insn_ctxt("match::compile_submatch"); let mut bcx = bcx; let tcx = bcx.tcx(), dm = tcx.def_map; diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 1564b20e4d23f..b854addf0b1a2 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -139,7 +139,7 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr { CEnum(discrs.min(), discrs.max()) } else if cases.len() == 1 { // Equivalent to a struct/tuple/newtype. - fail_unless!(cases[0].discr == 0); + assert!(cases[0].discr == 0); Univariant(mk_struct(cx, cases[0].tys), false) } else { // The general case. Since there's at least one @@ -191,7 +191,7 @@ fn generic_fields_of(cx: @CrateContext, r: &Repr, sizing: bool) // To get "the" type of a general enum, we pick the case // with the largest alignment (so it will always align // correctly in containing structures) and pad it out. - fail_unless!(sts.len() >= 1); + assert!(sts.len() >= 1); let mut most_aligned = None; let mut largest_align = 0; let mut largest_size = 0; @@ -300,16 +300,16 @@ pub fn trans_case(bcx: block, r: &Repr, discr: int) -> _match::opt_result { pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) { match *r { CEnum(min, max) => { - fail_unless!(min <= discr && discr <= max); + assert!(min <= discr && discr <= max); Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0])) } Univariant(ref st, true) => { - fail_unless!(discr == 0); + assert!(discr == 0); Store(bcx, C_bool(true), GEPi(bcx, val, [0, st.fields.len() - 1])) } Univariant(*) => { - fail_unless!(discr == 0); + assert!(discr == 0); } General(*) => { Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0])) @@ -325,7 +325,7 @@ pub fn num_args(r: &Repr, discr: int) -> uint { match *r { CEnum(*) => 0, Univariant(ref st, dtor) => { - fail_unless!(discr == 0); + assert!(discr == 0); st.fields.len() - (if dtor { 1 } else { 0 }) } General(ref cases) => cases[discr as uint].fields.len() - 1 @@ -343,7 +343,7 @@ pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int, bcx.ccx().sess.bug(~"element access in C-like enum") } Univariant(ref st, _dtor) => { - fail_unless!(discr == 0); + assert!(discr == 0); struct_field_ptr(bcx, st, val, ix, false) } General(ref cases) => { @@ -401,12 +401,12 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int, vals: &[ValueRef]) -> ValueRef { match *r { CEnum(min, max) => { - fail_unless!(vals.len() == 0); - fail_unless!(min <= discr && discr <= max); + assert!(vals.len() == 0); + assert!(min <= discr && discr <= max); C_int(ccx, discr) } Univariant(ref st, _dro) => { - fail_unless!(discr == 0); + assert!(discr == 0); C_struct(build_const_struct(ccx, st, vals)) } General(ref cases) => { @@ -431,7 +431,7 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int, */ fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef]) -> ~[ValueRef] { - fail_unless!(vals.len() == st.fields.len()); + assert!(vals.len() == st.fields.len()); let mut offset = 0; let mut cfields = ~[]; @@ -447,7 +447,7 @@ fn build_const_struct(ccx: @CrateContext, st: &Struct, vals: &[ValueRef]) cfields.push(padding(target_offset - offset)); offset = target_offset; } - fail_unless!(!is_undef(vals[i])); + assert!(!is_undef(vals[i])); // If that assert fails, could change it to wrap in a struct? // (See `const_struct_field` for why real fields must not be undef.) cfields.push(vals[i]); diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 4a28f014a9d83..f1988096a7e0e 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -314,7 +314,7 @@ pub fn non_gc_box_cast(bcx: block, val: ValueRef) -> ValueRef { unsafe { debug!("non_gc_box_cast"); add_comment(bcx, ~"non_gc_box_cast"); - fail_unless!(llvm::LLVMGetPointerAddressSpace(val_ty(val)) == + assert!(llvm::LLVMGetPointerAddressSpace(val_ty(val)) == gc_box_addrspace || bcx.unreachable); let non_gc_t = T_ptr(llvm::LLVMGetElementType(val_ty(val))); PointerCast(bcx, val, non_gc_t) @@ -489,7 +489,7 @@ pub fn get_res_dtor(ccx: @CrateContext, did: ast::def_id, let did = if did.crate != ast::local_crate { inline::maybe_instantiate_inline(ccx, did, true) } else { did }; - fail_unless!(did.crate == ast::local_crate); + assert!(did.crate == ast::local_crate); let (val, _) = monomorphize::monomorphic_fn(ccx, did, substs, None, None, None); @@ -1336,7 +1336,7 @@ pub fn cleanup_and_leave(bcx: block, } cur = match cur.parent { Some(next) => next, - None => { fail_unless!(upto.is_none()); break; } + None => { assert!(upto.is_none()); break; } }; } match leave { @@ -1523,7 +1523,7 @@ pub fn alloc_ty(bcx: block, t: ty::t) -> ValueRef { let ccx = bcx.ccx(); let llty = type_of::type_of(ccx, t); if ty::type_has_params(t) { debug!("%s", ty_to_str(ccx.tcx, t)); } - fail_unless!(!ty::type_has_params(t)); + assert!(!ty::type_has_params(t)); let val = alloca(bcx, llty); return val; } @@ -2471,7 +2471,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { // Want parent_id and not id, because id is the dtor's type let class_ty = ty::lookup_item_type(tcx, parent_id).ty; // This code shouldn't be reached if the class is generic - fail_unless!(!ty::type_has_params(class_ty)); + assert!(!ty::type_has_params(class_ty)); let lldty = unsafe { T_fn(~[ T_ptr(type_of(ccx, ty::mk_nil(tcx))), @@ -2491,7 +2491,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { let llfn; match v.node.kind { ast::tuple_variant_kind(ref args) => { - fail_unless!(args.len() != 0u); + assert!(args.len() != 0u); let pth = vec::append(/*bad*/copy *pth, ~[path_name(enm.ident), path_name((*v).node.name)]); diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index ed6cbc20209c0..ab0e2f38a0b94 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -813,7 +813,7 @@ pub fn Phi(cx: block, Ty: TypeRef, vals: &[ValueRef], bbs: &[BasicBlockRef]) -> ValueRef { unsafe { if cx.unreachable { return llvm::LLVMGetUndef(Ty); } - fail_unless!(vals.len() == bbs.len()); + assert!(vals.len() == bbs.len()); let phi = EmptyPhi(cx, Ty); count_insn(cx, "addincoming"); llvm::LLVMAddIncoming(phi, vec::raw::to_ptr(vals), @@ -1033,7 +1033,7 @@ pub fn Trap(cx: block) { let T: ValueRef = str::as_c_str(~"llvm.trap", |buf| { llvm::LLVMGetNamedFunction(M, buf) }); - fail_unless!((T as int != 0)); + assert!((T as int != 0)); let Args: ~[ValueRef] = ~[]; unsafe { count_insn(cx, "trap"); @@ -1047,7 +1047,7 @@ pub fn LandingPad(cx: block, Ty: TypeRef, PersFn: ValueRef, NumClauses: uint) -> ValueRef { unsafe { check_not_terminated(cx); - fail_unless!(!cx.unreachable); + assert!(!cx.unreachable); count_insn(cx, "landingpad"); return llvm::LLVMBuildLandingPad(B(cx), Ty, PersFn, NumClauses as c_uint, noname()); diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index aef1fb762de73..0377ed15a2d1e 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -133,7 +133,7 @@ pub fn trans(bcx: block, expr: @ast::expr) -> Callee { } ast::def_variant(tid, vid) => { // nullary variants are not callable - fail_unless!(ty::enum_variant_with_id(bcx.tcx(), + assert!(ty::enum_variant_with_id(bcx.tcx(), tid, vid).args.len() > 0u); fn_callee(bcx, trans_fn_ref(bcx, vid, ref_expr.id)) @@ -231,7 +231,7 @@ pub fn trans_fn_ref_with_vtables( vtables); let _indenter = indenter(); - fail_unless!(type_params.all(|t| !ty::type_needs_infer(*t))); + assert!(type_params.all(|t| !ty::type_needs_infer(*t))); // Polytype of the function item (may have type params) let fn_tpt = ty::lookup_item_type(tcx, def_id); @@ -286,7 +286,7 @@ pub fn trans_fn_ref_with_vtables( // Create a monomorphic verison of generic functions if must_monomorphise { // Should be either intra-crate or inlined. - fail_unless!(def_id.crate == ast::local_crate); + assert!(def_id.crate == ast::local_crate); let mut (val, must_cast) = monomorphize::monomorphic_fn(ccx, def_id, type_params, @@ -705,7 +705,7 @@ pub fn trans_arg_expr(bcx: block, // FIXME(#3548) use the adjustments table match autoref_arg { DoAutorefArg => { - fail_unless!(! + assert!(! bcx.ccx().maps.moves_map.contains(&arg_expr.id)); val = arg_datum.to_ref_llval(bcx); } diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 0ea5007ca9146..0ef9d4af60487 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -271,7 +271,7 @@ pub fn build_closure(bcx0: block, let datum = expr::trans_local_var(bcx, cap_var.def); match cap_var.mode { moves::CapRef => { - fail_unless!(sigil == ast::BorrowedSigil); + assert!(sigil == ast::BorrowedSigil); env_vals.push(EnvValue {action: EnvRef, datum: datum}); } diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index b8c0b7f41d59e..e9fc36bbd7d3e 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -255,8 +255,8 @@ pub struct param_substs { pub impl param_substs { fn validate(&self) { - for self.tys.each |t| { fail_unless!(!ty::type_needs_infer(*t)); } - for self.self_ty.each |t| { fail_unless!(!ty::type_needs_infer(*t)); } + for self.tys.each |t| { assert!(!ty::type_needs_infer(*t)); } + for self.self_ty.each |t| { assert!(!ty::type_needs_infer(*t)); } } } @@ -1359,7 +1359,7 @@ pub fn monomorphize_type(bcx: block, t: ty::t) -> ty::t { Some(substs) => { ty::subst_tps(bcx.tcx(), substs.tys, substs.self_ty, t) } - _ => { fail_unless!(!ty::type_has_params(t)); t } + _ => { assert!(!ty::type_has_params(t)); t } } } diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs index a495350a73f37..2443c9998f135 100644 --- a/src/librustc/middle/trans/consts.rs +++ b/src/librustc/middle/trans/consts.rs @@ -74,7 +74,7 @@ pub fn const_lit(cx: @CrateContext, e: @ast::expr, lit: ast::lit) pub fn const_ptrcast(cx: @CrateContext, a: ValueRef, t: TypeRef) -> ValueRef { unsafe { let b = llvm::LLVMConstPointerCast(a, T_ptr(t)); - fail_unless!(cx.const_globals.insert(b as int, a)); + assert!(cx.const_globals.insert(b as int, a)); b } } @@ -116,7 +116,7 @@ fn const_deref_ptr(cx: @CrateContext, v: ValueRef) -> ValueRef { None => v }; unsafe { - fail_unless!(llvm::LLVMIsGlobalConstant(v) == True); + assert!(llvm::LLVMIsGlobalConstant(v) == True); llvm::LLVMGetInitializer(v) } } @@ -131,7 +131,7 @@ fn const_deref(cx: @CrateContext, v: ValueRef, t: ty::t, explicit: bool) -> (ValueRef, ty::t) { match ty::deref(cx.tcx, t, explicit) { Some(ref mt) => { - fail_unless!(mt.mutbl != ast::m_mutbl); + assert!(mt.mutbl != ast::m_mutbl); let dv = match ty::get(t).sty { ty::ty_ptr(*) | ty::ty_rptr(*) => { const_deref_ptr(cx, v) @@ -197,8 +197,8 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef { match adj.autoref { None => { } Some(ref autoref) => { - fail_unless!(autoref.region == ty::re_static); - fail_unless!(autoref.mutbl != ast::m_mutbl); + assert!(autoref.region == ty::re_static); + assert!(autoref.mutbl != ast::m_mutbl); // Don't copy data to do a deref+ref. let llptr = match maybe_ptr { Some(ptr) => ptr, @@ -211,8 +211,8 @@ pub fn const_expr(cx: @CrateContext, e: @ast::expr) -> ValueRef { ty::AutoBorrowVec => { let size = machine::llsize_of(cx, val_ty(llconst)); - fail_unless!(abi::slice_elt_base == 0); - fail_unless!(abi::slice_elt_len == 1); + assert!(abi::slice_elt_base == 0); + assert!(abi::slice_elt_len == 1); llconst = C_struct(~[llptr, size]); } _ => { @@ -375,7 +375,7 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { let len = llvm::LLVMConstIntGetZExtValue(len) as u64; let len = match ty::get(bt).sty { - ty::ty_estr(*) => {fail_unless!(len > 0); len - 1}, + ty::ty_estr(*) => {assert!(len > 0); len - 1}, _ => len }; if iv >= len { @@ -494,14 +494,14 @@ fn const_expr_unadjusted(cx: @CrateContext, e: @ast::expr) -> ValueRef { } } ast::expr_path(pth) => { - fail_unless!(pth.types.len() == 0); + assert!(pth.types.len() == 0); match cx.tcx.def_map.find(&e.id) { Some(&ast::def_fn(def_id, _purity)) => { if !ast_util::is_local(def_id) { let ty = csearch::get_type(cx.tcx, def_id).ty; base::trans_external_path(cx, def_id, ty) } else { - fail_unless!(ast_util::is_local(def_id)); + assert!(ast_util::is_local(def_id)); base::get_item_val(cx, def_id.node) } } diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs index 1c201d0def69b..c2235b763e230 100644 --- a/src/librustc/middle/trans/controlflow.rs +++ b/src/librustc/middle/trans/controlflow.rs @@ -47,7 +47,7 @@ pub fn trans_block(bcx: block, b: &ast::blk, dest: expr::Dest) -> block { bcx = expr::trans_into(bcx, e, dest); } None => { - fail_unless!(dest == expr::Ignore || bcx.unreachable); + assert!(dest == expr::Ignore || bcx.unreachable); } } return bcx; diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 164f6fe44fc6d..869fdc20a6558 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -247,19 +247,19 @@ pub impl Datum { action: CopyAction, datum: Datum) -> block { debug!("store_to_datum(self=%s, action=%?, datum=%s)", self.to_str(bcx.ccx()), action, datum.to_str(bcx.ccx())); - fail_unless!(datum.mode.is_by_ref()); + assert!(datum.mode.is_by_ref()); self.store_to(bcx, id, action, datum.val) } fn move_to_datum(&self, bcx: block, action: CopyAction, datum: Datum) -> block { - fail_unless!(datum.mode.is_by_ref()); + assert!(datum.mode.is_by_ref()); self.move_to(bcx, action, datum.val) } fn copy_to_datum(&self, bcx: block, action: CopyAction, datum: Datum) -> block { - fail_unless!(datum.mode.is_by_ref()); + assert!(datum.mode.is_by_ref()); self.copy_to(bcx, action, datum.val) } @@ -372,7 +372,7 @@ pub impl Datum { * Schedules this datum for cleanup in `bcx`. The datum * must be an rvalue. */ - fail_unless!(self.source == RevokeClean); + assert!(self.source == RevokeClean); match self.mode { ByValue => { add_clean_temp_immediate(bcx, self.val, self.ty); @@ -393,7 +393,7 @@ pub impl Datum { // Lvalues which potentially need to be dropped // must be passed by ref, so that we can zero them // out. - fail_unless!(self.mode.is_by_ref()); + assert!(self.mode.is_by_ref()); zero_mem(bcx, self.val, self.ty); } } @@ -697,7 +697,7 @@ pub impl Datum { // changing the type, so I am putting this // code in place here to do the right // thing if this change ever goes through. - fail_unless!(ty::type_is_immediate(ty)); + assert!(ty::type_is_immediate(ty)); (Some(Datum {ty: ty, ..*self}), bcx) } }; @@ -737,7 +737,7 @@ pub impl Datum { // except for changing the type, so I am putting this // code in place here to do the right thing if this // change ever goes through. - fail_unless!(ty::type_is_immediate(ty)); + assert!(ty::type_is_immediate(ty)); (Some(Datum {ty: ty, ..*self}), bcx) } } @@ -797,7 +797,7 @@ pub impl Datum { // either we were asked to deref a specific number of times, // in which case we should have, or we asked to deref as many // times as we can - fail_unless!(derefs == max || max == uint::max_value); + assert!(derefs == max || max == uint::max_value); DatumBlock { bcx: bcx, datum: datum } } @@ -817,7 +817,7 @@ pub impl DatumBlock { } fn assert_by_ref(&self) -> DatumBlock { - fail_unless!(self.datum.mode.is_by_ref()); + assert!(self.datum.mode.is_by_ref()); *self } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 6825c3896e485..dc910f9f178e3 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -278,7 +278,7 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock { debug!("add_env(closure_ty=%s)", ty_to_str(tcx, closure_ty)); let scratch = scratch_datum(bcx, closure_ty, false); let llfn = GEPi(bcx, scratch.val, [0u, abi::fn_field_code]); - fail_unless!(datum.appropriate_mode() == ByValue); + assert!(datum.appropriate_mode() == ByValue); Store(bcx, datum.to_appropriate_llval(bcx), llfn); let llenv = GEPi(bcx, scratch.val, [0u, abi::fn_field_box]); Store(bcx, base::null_env_ptr(bcx), llenv); @@ -457,7 +457,7 @@ fn trans_rvalue_datum_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock { } ast::expr_binary(op, lhs, rhs) => { // if overloaded, would be RvalueDpsExpr - fail_unless!(!bcx.ccx().maps.method_map.contains_key(&expr.id)); + assert!(!bcx.ccx().maps.method_map.contains_key(&expr.id)); return trans_binary(bcx, expr, op, lhs, rhs); } @@ -1301,10 +1301,10 @@ fn trans_unary_datum(bcx: block, let _icx = bcx.insn_ctxt("trans_unary_datum"); // if deref, would be LvalueExpr - fail_unless!(op != ast::deref); + assert!(op != ast::deref); // if overloaded, would be RvalueDpsExpr - fail_unless!(!bcx.ccx().maps.method_map.contains_key(&un_expr.id)); + assert!(!bcx.ccx().maps.method_map.contains_key(&un_expr.id)); let un_ty = expr_ty(bcx, un_expr); let sub_ty = expr_ty(bcx, sub_expr); diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs index 1639c6b414d19..1b27d21e6f464 100644 --- a/src/librustc/middle/trans/glue.rs +++ b/src/librustc/middle/trans/glue.rs @@ -401,7 +401,7 @@ pub fn make_visit_glue(bcx: block, v: ValueRef, t: ty::t) { let _icx = bcx.insn_ctxt("make_visit_glue"); let mut bcx = bcx; let ty_visitor_name = special_idents::ty_visitor; - fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name)); + assert!(bcx.ccx().tcx.intrinsic_defs.contains_key(&ty_visitor_name)); let (trait_id, ty) = *bcx.ccx().tcx.intrinsic_defs.get(&ty_visitor_name); let v = PointerCast(bcx, v, T_ptr(type_of::type_of(bcx.ccx(), ty))); bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, trait_id); @@ -489,7 +489,7 @@ pub fn trans_struct_drop(bcx: block, // Class dtors have no explicit args, so the params should // just consist of the output pointer and the environment // (self) - fail_unless!((params.len() == 2)); + assert!((params.len() == 2)); // If we need to take a reference to the class (because it's using // the Drop trait), do so now. @@ -675,7 +675,7 @@ pub fn declare_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info { let _icx = ccx.insn_ctxt("declare_tydesc"); // If emit_tydescs already ran, then we shouldn't be creating any new // tydescs. - fail_unless!(!*ccx.finished_tydescs); + assert!(!*ccx.finished_tydescs); let llty = type_of(ccx, t); diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index ae2d7bbee5065..ed9000e7418a4 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -327,7 +327,7 @@ pub fn trans_static_method_callee(bcx: block, match vtbls[bound_index] { typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => { - fail_unless!(rcvr_substs.all(|t| !ty::type_needs_infer(*t))); + assert!(rcvr_substs.all(|t| !ty::type_needs_infer(*t))); let mth_id = method_with_name(bcx.ccx(), impl_did, mname); let callee_substs = combine_impl_and_methods_tps( diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 29760eb0bb509..71e8f7c2125f2 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -47,7 +47,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, impl_did_opt: Option, ref_id: Option) -> (ValueRef, bool) { - fail_unless!(real_substs.all(|t| !ty::type_needs_infer(*t))); + assert!(real_substs.all(|t| !ty::type_needs_infer(*t))); let _icx = ccx.insn_ctxt("monomorphic_fn"); let mut must_cast = false; let substs = vec::map(real_substs, |t| { @@ -57,8 +57,8 @@ pub fn monomorphic_fn(ccx: @CrateContext, } }); - for real_substs.each() |s| { fail_unless!(!ty::type_has_params(*s)); } - for substs.each() |s| { fail_unless!(!ty::type_has_params(*s)); } + for real_substs.each() |s| { assert!(!ty::type_has_params(*s)); } + for substs.each() |s| { assert!(!ty::type_has_params(*s)); } let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len()); // XXX: Bad copy. let hash_id = make_mono_id(ccx, fn_id, copy substs, vtables, impl_did_opt, diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index b8145e6532602..a9869f15875c7 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -336,7 +336,7 @@ pub fn emit_calls_to_trait_visit_ty(bcx: block, -> block { use syntax::parse::token::special_idents::tydesc; let final = sub_block(bcx, ~"final"); - fail_unless!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc)); + assert!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc)); let (_, tydesc_ty) = *bcx.ccx().tcx.intrinsic_defs.get(&tydesc); let tydesc_ty = type_of(bcx.ccx(), tydesc_ty); let mut r = Reflector { diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index 8e4719d2ccc7d..a9381647b3326 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -68,7 +68,7 @@ pub fn type_of_fn_from_ty(cx: @CrateContext, fty: ty::t) -> TypeRef { } pub fn type_of_non_gc_box(cx: @CrateContext, t: ty::t) -> TypeRef { - fail_unless!(!ty::type_needs_infer(t)); + assert!(!ty::type_needs_infer(t)); let t_norm = ty::normalize_ty(cx.tcx, t); if t != t_norm { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 5e46fb512d4ce..425f14b7c0707 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2005,7 +2005,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { // If this assertion failures, it is likely because of a // failure in the cross-crate inlining code to translate a // def-id. - fail_unless!(p.def_id.crate == ast::local_crate); + assert!(p.def_id.crate == ast::local_crate); param_bounds_to_contents( cx, *cx.ty_param_bounds.get(&p.def_id.node)) @@ -3559,7 +3559,7 @@ pub fn trait_supertraits(cx: ctxt, // Not in the cache. It had better be in the metadata, which means it // shouldn't be local. - fail_unless!(!is_local(id)); + assert!(!is_local(id)); // Get the supertraits out of the metadata and create the // InstantiatedTraitRef for each. @@ -3591,7 +3591,7 @@ pub fn trait_methods(cx: ctxt, id: ast::def_id) -> @~[method] { // If the lookup in trait_method_cache fails, assume that the trait // method we're trying to look up is in a different crate, and look // for it there. - fail_unless!(id.crate != ast::local_crate); + assert!(id.crate != ast::local_crate); let result = csearch::get_trait_methods(cx, id); // Store the trait method in the local trait_method_cache so that @@ -3912,7 +3912,7 @@ pub fn lookup_item_type(cx: ctxt, return tpt; } None => { - fail_unless!(did.crate != ast::local_crate); + assert!(did.crate != ast::local_crate); let tyt = csearch::get_type(cx, did); cx.tcache.insert(did, tyt); return tyt; diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index eb106f3b91f72..697649a4187c2 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -585,7 +585,7 @@ pub fn ty_of_closure( // The caller should not both provide explicit bound lifetime // names and expected types. Either we infer the bound lifetime // names or they are provided, but not both. - fail_unless!(lifetimes.is_empty() || expected_sig.is_none()); + assert!(lifetimes.is_empty() || expected_sig.is_none()); debug!("ty_of_fn_decl"); let _i = indenter(); diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 18d84b967874f..f139643295790 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1802,7 +1802,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, if check_completeness && !error_happened { // Make sure the programmer specified all the fields. - fail_unless!(fields_found <= field_types.len()); + assert!(fields_found <= field_types.len()); if fields_found < field_types.len() { let mut missing_fields = ~[]; for field_types.each |class_field| { @@ -3412,8 +3412,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ~"visit_tydesc" => { let tydesc_name = special_idents::tydesc; let ty_visitor_name = tcx.sess.ident_of(~"TyVisitor"); - fail_unless!(tcx.intrinsic_defs.contains_key(&tydesc_name)); - fail_unless!(ccx.tcx.intrinsic_defs.contains_key(&ty_visitor_name)); + assert!(tcx.intrinsic_defs.contains_key(&tydesc_name)); + assert!(ccx.tcx.intrinsic_defs.contains_key(&ty_visitor_name)); let (_, tydesc_ty) = *tcx.intrinsic_defs.get(&tydesc_name); let (_, visitor_trait) = *tcx.intrinsic_defs.get(&ty_visitor_name); diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index d161df22976f6..dfc5f218d67d0 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -712,7 +712,7 @@ pub mod guarantor { ast::expr_copy(*) | ast::expr_repeat(*) | ast::expr_vec(*) => { - fail_unless!(!ty::expr_is_lval( + assert!(!ty::expr_is_lval( rcx.fcx.tcx(), rcx.fcx.inh.method_map, expr)); None } diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index d485ca447fcc3..a1eaa1f6a3394 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -181,7 +181,7 @@ pub fn lookup_vtable(vcx: &VtableContext, Some(ty) => ty, None => { // fixup_ty can only fail if this is early resolution - fail_unless!(is_early); + assert!(is_early); // The type has unconstrained type variables in it, so we can't // do early resolution on it. Return some completely bogus vtable // information: we aren't storing it anyways. @@ -367,7 +367,7 @@ pub fn lookup_vtable(vcx: &VtableContext, is_early) { Some(ref substs) => (/*bad*/copy *substs), None => { - fail_unless!(is_early); + assert!(is_early); // Bail out with a bogus answer return Some(vtable_param(0, 0)); } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 498ad2c5bffcb..4fc9e8d19ae1f 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -797,7 +797,7 @@ pub impl CoherenceChecker { } fn span_of_impl(&self, implementation: @Impl) -> span { - fail_unless!(implementation.did.crate == local_crate); + assert!(implementation.did.crate == local_crate); match self.crate_context.tcx.items.find(&implementation.did.node) { Some(&node_item(item, _)) => { return item.span; diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index ca59ee0328a66..d8093d571a111 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -586,7 +586,7 @@ pub impl InferCtxt { /// Execute `f` and commit the bindings if successful fn commit(@mut self, f: &fn() -> Result) -> Result { - fail_unless!(!self.in_snapshot()); + assert!(!self.in_snapshot()); debug!("commit()"); do indent { @@ -679,7 +679,7 @@ pub impl InferCtxt { let region_var = self.next_region_var_nb(span); // add lb_region as a lower bound on the newly built variable - fail_unless!(self.region_vars.make_subregion(span, + assert!(self.region_vars.make_subregion(span, lb_region, region_var).is_ok()); diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index 19c06804ea0c7..d9f00451dd57e 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -671,7 +671,7 @@ pub impl RegionVarBindings { match undo_item { Snapshot => {} AddVar(vid) => { - fail_unless!(self.var_spans.len() == vid.to_uint() + 1); + assert!(self.var_spans.len() == vid.to_uint() + 1); self.var_spans.pop(); } AddConstraint(ref constraint) => { @@ -731,7 +731,7 @@ pub impl RegionVarBindings { fn add_constraint(&mut self, +constraint: Constraint, span: span) { // cannot add constraints once regions are resolved - fail_unless!(self.values.is_empty()); + assert!(self.values.is_empty()); debug!("RegionVarBindings: add_constraint(%?)", constraint); @@ -747,7 +747,7 @@ pub impl RegionVarBindings { sub: Region, sup: Region) -> cres<()> { // cannot add constraints once regions are resolved - fail_unless!(self.values.is_empty()); + assert!(self.values.is_empty()); debug!("RegionVarBindings: make_subregion(%?, %?)", sub, sup); match (sub, sup) { @@ -789,7 +789,7 @@ pub impl RegionVarBindings { b: Region) -> cres { // cannot add constraints once regions are resolved - fail_unless!(self.values.is_empty()); + assert!(self.values.is_empty()); debug!("RegionVarBindings: lub_regions(%?, %?)", a, b); match (a, b) { @@ -815,7 +815,7 @@ pub impl RegionVarBindings { b: Region) -> cres { // cannot add constraints once regions are resolved - fail_unless!(self.values.is_empty()); + assert!(self.values.is_empty()); debug!("RegionVarBindings: glb_regions(%?, %?)", a, b); match (a, b) { @@ -1359,7 +1359,7 @@ pub impl RegionVarBindings { return match a_node.value { NoValue => { - fail_unless!(a_node.classification == Contracting); + assert!(a_node.classification == Contracting); a_node.value = Value(b_region); true // changed } @@ -1617,7 +1617,7 @@ pub impl RegionVarBindings { } ConstrainRegSubVar(region, _) => { - fail_unless!(dir == Incoming); + assert!(dir == Incoming); result.push(SpannedRegion { region: region, span: edge.span @@ -1625,7 +1625,7 @@ pub impl RegionVarBindings { } ConstrainVarSubReg(_, region) => { - fail_unless!(dir == Outgoing); + assert!(dir == Outgoing); result.push(SpannedRegion { region: region, span: edge.span diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index 038dc524bec07..c208d1d24fc62 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -114,9 +114,9 @@ pub impl ResolveState { // n.b. This is a hokey mess because the current fold doesn't // allow us to pass back errors in any useful way. - fail_unless!(vec::is_empty(self.v_seen)); + assert!(vec::is_empty(self.v_seen)); let rty = indent(|| self.resolve_type(typ) ); - fail_unless!(vec::is_empty(self.v_seen)); + assert!(vec::is_empty(self.v_seen)); match self.err { None => { debug!("Resolved to %s + %s (modes=%x)", diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs index 6a4def65fe744..52a0300c5a089 100644 --- a/src/librustc/middle/typeck/infer/test.rs +++ b/src/librustc/middle/typeck/infer/test.rs @@ -110,7 +110,7 @@ pub impl Env { m: &ast::_mod, idx: uint, names: &[~str]) -> Option { - fail_unless!(idx < names.len()); + assert!(idx < names.len()); for m.items.each |item| { if self.tcx.sess.str_of(item.ident) == names[idx] { return search(self, *item, idx+1, names); diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 3c5470dc22fa6..75dac7fd7c5df 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -131,7 +131,7 @@ pub impl InferCtxt { } else { // If equal, redirect one to the other and increment the // other's rank. - fail_unless!(node_a.rank == node_b.rank); + assert!(node_a.rank == node_b.rank); self.set(node_b.root, Redirect(node_a.root)); (node_a.root, node_a.rank + 1) } diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index ea577c758affc..2df9884911e55 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -184,7 +184,7 @@ pub struct CrateCtxt { // Functions that write types into the node type table pub fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) { debug!("write_ty_to_tcx(%d, %s)", node_id, ppaux::ty_to_str(tcx, ty)); - fail_unless!(!ty::type_needs_infer(ty)); + assert!(!ty::type_needs_infer(ty)); tcx.node_types.insert(node_id as uint, ty); } pub fn write_substs_to_tcx(tcx: ty::ctxt, @@ -193,7 +193,7 @@ pub fn write_substs_to_tcx(tcx: ty::ctxt, if substs.len() > 0u { debug!("write_substs_to_tcx(%d, %?)", node_id, substs.map(|t| ppaux::ty_to_str(tcx, *t))); - fail_unless!(substs.all(|t| !ty::type_needs_infer(*t))); + assert!(substs.all(|t| !ty::type_needs_infer(*t))); tcx.node_type_substs.insert(node_id, substs); } } diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index 7082c154d2f2c..eeca90dbecd5d 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -180,7 +180,7 @@ impl region_scope for MethodRscope { }) } fn self_region(&self, _span: span) -> Result { - fail_unless!(self.variance.is_some() || self.self_ty.is_borrowed()); + assert!(self.variance.is_some() || self.self_ty.is_borrowed()); match self.variance { None => {} // must be borrowed self, so this is OK Some(_) => { diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs index d3108f690c144..3b905c612a5c6 100644 --- a/src/librustdoc/astsrv.rs +++ b/src/librustdoc/astsrv.rs @@ -138,7 +138,7 @@ fn should_prune_unconfigured_items() { let source = ~"#[cfg(shut_up_and_leave_me_alone)]fn a() { }"; do from_str(source) |srv| { do exec(srv) |ctxt| { - fail_unless!(vec::is_empty(ctxt.ast.node.module.items)); + assert!(vec::is_empty(ctxt.ast.node.module.items)); } } } @@ -148,7 +148,7 @@ fn srv_should_build_ast_map() { let source = ~"fn a() { }"; do from_str(source) |srv| { do exec(srv) |ctxt| { - fail_unless!(!ctxt.ast_map.is_empty()) + assert!(!ctxt.ast_map.is_empty()) }; } } @@ -164,6 +164,6 @@ fn srv_should_return_request_result() { let source = ~"fn a() { }"; do from_str(source) |srv| { let result = exec(srv, |_ctxt| 1000 ); - fail_unless!(result == 1000); + assert!(result == 1000); } } diff --git a/src/librustdoc/attr_parser.rs b/src/librustdoc/attr_parser.rs index 32966156eb108..213198e6f2158 100644 --- a/src/librustdoc/attr_parser.rs +++ b/src/librustdoc/attr_parser.rs @@ -71,7 +71,7 @@ fn should_extract_crate_name_from_link_attribute() { let source = ~"#[link(name = \"snuggles\")]"; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); - fail_unless!(attrs.name == Some(~"snuggles")); + assert!(attrs.name == Some(~"snuggles")); } #[test] @@ -79,7 +79,7 @@ fn should_not_extract_crate_name_if_no_link_attribute() { let source = ~""; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); - fail_unless!(attrs.name == None); + assert!(attrs.name == None); } #[test] @@ -87,7 +87,7 @@ fn should_not_extract_crate_name_if_no_name_value_in_link_attribute() { let source = ~"#[link(whatever)]"; let attrs = test::parse_attributes(source); let attrs = parse_crate(attrs); - fail_unless!(attrs.name == None); + assert!(attrs.name == None); } pub fn parse_desc(attrs: ~[ast::attribute]) -> Option<~str> { @@ -106,7 +106,7 @@ fn parse_desc_should_handle_undocumented_mods() { let source = ~""; let attrs = test::parse_attributes(source); let attrs = parse_desc(attrs); - fail_unless!(attrs == None); + assert!(attrs == None); } #[test] @@ -114,7 +114,7 @@ fn parse_desc_should_parse_simple_doc_attributes() { let source = ~"#[doc = \"basic\"]"; let attrs = test::parse_attributes(source); let attrs = parse_desc(attrs); - fail_unless!(attrs == Some(~"basic")); + assert!(attrs == Some(~"basic")); } pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool { @@ -133,28 +133,28 @@ pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool { fn should_parse_hidden_attribute() { let source = ~"#[doc(hidden)]"; let attrs = test::parse_attributes(source); - fail_unless!(parse_hidden(attrs) == true); + assert!(parse_hidden(attrs) == true); } #[test] fn should_parse_hidden_attribute_with_other_docs() { let source = ~"#[doc = \"foo\"] #[doc(hidden)] #[doc = \"foo\"]"; let attrs = test::parse_attributes(source); - fail_unless!(parse_hidden(attrs) == true); + assert!(parse_hidden(attrs) == true); } #[test] fn should_not_parse_non_hidden_attribute() { let source = ~"#[doc = \"\"]"; let attrs = test::parse_attributes(source); - fail_unless!(parse_hidden(attrs) == false); + assert!(parse_hidden(attrs) == false); } #[test] fn should_concatenate_multiple_doc_comments() { let source = ~"/// foo\n/// bar"; let desc = parse_desc(test::parse_attributes(source)); - fail_unless!(desc == Some(~"foo\nbar")); + assert!(desc == Some(~"foo\nbar")); } diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 101c11bd58b36..b550155140f0b 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -81,7 +81,7 @@ fn fold_crate( #[test] fn should_replace_top_module_name_with_crate_name() { let doc = test::mk_doc(~"#[link(name = \"bond\")];"); - fail_unless!(doc.cratemod().name() == ~"bond"); + assert!(doc.cratemod().name() == ~"bond"); } fn fold_item( @@ -124,25 +124,25 @@ fn parse_item_attrs( #[test] fn should_should_extract_mod_attributes() { let doc = test::mk_doc(~"#[doc = \"test\"] mod a { }"); - fail_unless!(doc.cratemod().mods()[0].desc() == Some(~"test")); + assert!(doc.cratemod().mods()[0].desc() == Some(~"test")); } #[test] fn should_extract_top_mod_attributes() { let doc = test::mk_doc(~"#[doc = \"test\"];"); - fail_unless!(doc.cratemod().desc() == Some(~"test")); + assert!(doc.cratemod().desc() == Some(~"test")); } #[test] fn should_extract_foreign_fn_attributes() { let doc = test::mk_doc(~"extern { #[doc = \"test\"] fn a(); }"); - fail_unless!(doc.cratemod().nmods()[0].fns[0].desc() == Some(~"test")); + assert!(doc.cratemod().nmods()[0].fns[0].desc() == Some(~"test")); } #[test] fn should_extract_fn_attributes() { let doc = test::mk_doc(~"#[doc = \"test\"] fn a() -> int { }"); - fail_unless!(doc.cratemod().fns()[0].desc() == Some(~"test")); + assert!(doc.cratemod().fns()[0].desc() == Some(~"test")); } fn fold_enum( @@ -194,13 +194,13 @@ fn fold_enum( fn should_extract_enum_docs() { let doc = test::mk_doc(~"#[doc = \"b\"]\ enum a { v }"); - fail_unless!(doc.cratemod().enums()[0].desc() == Some(~"b")); + assert!(doc.cratemod().enums()[0].desc() == Some(~"b")); } #[test] fn should_extract_variant_docs() { let doc = test::mk_doc(~"enum a { #[doc = \"c\"] v }"); - fail_unless!(doc.cratemod().enums()[0].variants[0].desc == Some(~"c")); + assert!(doc.cratemod().enums()[0].variants[0].desc == Some(~"c")); } fn fold_trait( @@ -253,7 +253,7 @@ fn merge_method_attrs( }; do vec::map2(docs, attrs) |doc, attrs| { - fail_unless!(doc.name == attrs.first()); + assert!(doc.name == attrs.first()); let desc = attrs.second(); doc::MethodDoc { @@ -266,7 +266,7 @@ fn merge_method_attrs( #[test] fn should_extract_trait_docs() { let doc = test::mk_doc(~"#[doc = \"whatever\"] trait i { fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].desc() == Some(~"whatever")); + assert!(doc.cratemod().traits()[0].desc() == Some(~"whatever")); } #[test] @@ -276,7 +276,7 @@ fn should_extract_trait_method_docs() { #[doc = \"desc\"]\ fn f(a: bool) -> bool;\ }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].desc == Some(~"desc")); + assert!(doc.cratemod().traits()[0].methods[0].desc == Some(~"desc")); } @@ -297,7 +297,7 @@ fn fold_impl( fn should_extract_impl_docs() { let doc = test::mk_doc( ~"#[doc = \"whatever\"] impl int { fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].desc() == Some(~"whatever")); + assert!(doc.cratemod().impls()[0].desc() == Some(~"whatever")); } #[test] @@ -307,7 +307,7 @@ fn should_extract_impl_method_docs() { #[doc = \"desc\"]\ fn f(a: bool) -> bool { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].desc == Some(~"desc")); + assert!(doc.cratemod().impls()[0].methods[0].desc == Some(~"desc")); } #[cfg(test)] diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index 2b95d42f40e75..62ddec7a1199c 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -253,7 +253,7 @@ fn should_find_pandoc() { ProgramOutput { status: 0, out: ~"pandoc 1.8.2.1", err: ~"" } }; let result = maybe_find_pandoc(&config, None, mock_program_output); - fail_unless!(result == result::Ok(Some(~"pandoc"))); + assert!(result == result::Ok(Some(~"pandoc"))); } #[test] @@ -266,7 +266,7 @@ fn should_error_with_no_pandoc() { ProgramOutput { status: 1, out: ~"", err: ~"" } }; let result = maybe_find_pandoc(&config, None, mock_program_output); - fail_unless!(result == result::Err(~"couldn't find pandoc")); + assert!(result == result::Err(~"couldn't find pandoc")); } #[cfg(test)] @@ -283,20 +283,20 @@ mod test { #[test] fn should_error_with_no_crates() { let config = test::parse_config(~[~"rustdoc"]); - fail_unless!(config.get_err() == ~"no crates specified"); + assert!(config.get_err() == ~"no crates specified"); } #[test] fn should_error_with_multiple_crates() { let config = test::parse_config(~[~"rustdoc", ~"crate1.rc", ~"crate2.rc"]); - fail_unless!(config.get_err() == ~"multiple crates specified"); + assert!(config.get_err() == ~"multiple crates specified"); } #[test] fn should_set_output_dir_to_cwd_if_not_provided() { let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); - fail_unless!(config.get().output_dir == Path(".")); + assert!(config.get().output_dir == Path(".")); } #[test] @@ -304,13 +304,13 @@ fn should_set_output_dir_if_provided() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles" ]); - fail_unless!(config.get().output_dir == Path("snuggles")); + assert!(config.get().output_dir == Path("snuggles")); } #[test] fn should_set_output_format_to_pandoc_html_if_not_provided() { let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); - fail_unless!(config.get().output_format == PandocHtml); + assert!(config.get().output_format == PandocHtml); } #[test] @@ -318,7 +318,7 @@ fn should_set_output_format_to_markdown_if_requested() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown" ]); - fail_unless!(config.get().output_format == Markdown); + assert!(config.get().output_format == Markdown); } #[test] @@ -326,7 +326,7 @@ fn should_set_output_format_to_pandoc_html_if_requested() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html" ]); - fail_unless!(config.get().output_format == PandocHtml); + assert!(config.get().output_format == PandocHtml); } #[test] @@ -334,13 +334,13 @@ fn should_error_on_bogus_format() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus" ]); - fail_unless!(config.get_err() == ~"unknown output format 'bogus'"); + assert!(config.get_err() == ~"unknown output format 'bogus'"); } #[test] fn should_set_output_style_to_doc_per_mod_by_default() { let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); - fail_unless!(config.get().output_style == DocPerMod); + assert!(config.get().output_style == DocPerMod); } #[test] @@ -348,7 +348,7 @@ fn should_set_output_style_to_one_doc_if_requested() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate" ]); - fail_unless!(config.get().output_style == DocPerCrate); + assert!(config.get().output_style == DocPerCrate); } #[test] @@ -356,7 +356,7 @@ fn should_set_output_style_to_doc_per_mod_if_requested() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod" ]); - fail_unless!(config.get().output_style == DocPerMod); + assert!(config.get().output_style == DocPerMod); } #[test] @@ -364,7 +364,7 @@ fn should_error_on_bogus_output_style() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus" ]); - fail_unless!(config.get_err() == ~"unknown output style 'bogus'"); + assert!(config.get_err() == ~"unknown output style 'bogus'"); } #[test] @@ -372,11 +372,11 @@ fn should_set_pandoc_command_if_requested() { let config = test::parse_config(~[ ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc" ]); - fail_unless!(config.get().pandoc_cmd == Some(~"panda-bear-doc")); + assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc")); } #[test] fn should_set_pandoc_command_when_using_pandoc() { let config = test::parse_config(~[~"rustdoc", ~"crate.rc"]); - fail_unless!(config.get().pandoc_cmd == Some(~"pandoc")); + assert!(config.get().pandoc_cmd == Some(~"pandoc")); } diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs index 012a56c5b720a..7c50af40f337a 100644 --- a/src/librustdoc/desc_to_brief_pass.rs +++ b/src/librustdoc/desc_to_brief_pass.rs @@ -84,13 +84,13 @@ fn fold_impl(fold: &fold::Fold<()>, doc: doc::ImplDoc) -> doc::ImplDoc { #[test] fn should_promote_desc() { let doc = test::mk_doc(~"#[doc = \"desc\"] mod m { }"); - fail_unless!(doc.cratemod().mods()[0].brief() == Some(~"desc")); + assert!(doc.cratemod().mods()[0].brief() == Some(~"desc")); } #[test] fn should_promote_trait_method_desc() { let doc = test::mk_doc(~"trait i { #[doc = \"desc\"] fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].brief == + assert!(doc.cratemod().traits()[0].methods[0].brief == Some(~"desc")); } @@ -98,7 +98,7 @@ fn should_promote_trait_method_desc() { fn should_promote_impl_method_desc() { let doc = test::mk_doc( ~"impl int { #[doc = \"desc\"] fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].brief == Some(~"desc")); + assert!(doc.cratemod().impls()[0].methods[0].brief == Some(~"desc")); } #[cfg(test)] @@ -222,20 +222,20 @@ fn paragraphs(s: &str) -> ~[~str] { #[test] fn test_paragraphs_1() { let paras = paragraphs(~"1\n\n2"); - fail_unless!(paras == ~[~"1", ~"2"]); + assert!(paras == ~[~"1", ~"2"]); } #[test] fn test_paragraphs_2() { let paras = paragraphs(~"\n\n1\n1\n\n2\n\n"); - fail_unless!(paras == ~[~"1\n1", ~"2"]); + assert!(paras == ~[~"1\n1", ~"2"]); } #[test] fn should_promote_short_descs() { let desc = Some(~"desc"); let brief = extract(copy desc); - fail_unless!(brief == desc); + assert!(brief == desc); } #[test] @@ -249,7 +249,7 @@ Scotland in the mid 12th century, although it may have been built by King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); - fail_unless!(brief == None); + assert!(brief == None); } #[test] @@ -263,7 +263,7 @@ Scotland in the mid 12th century, although it may have been built by King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); - fail_unless!(brief == Some( + assert!(brief == Some( ~"Warkworth Castle is a ruined medieval building in the town")); } @@ -278,7 +278,7 @@ Scotland in the mid 12th century, although it may have been built by King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); - fail_unless!(brief == Some( + assert!(brief == Some( ~"Warkworth..Castle is a ruined medieval building in the town")); } @@ -293,6 +293,6 @@ Scotland in the mid 12th century, although it may have been built by King Henry II of England when he took control of England'snorthern counties."); let brief = extract(desc); - fail_unless!(brief == Some( + assert!(brief == Some( ~"Warkworth... Castle is a ruined medieval building in the town")); } diff --git a/src/librustdoc/escape_pass.rs b/src/librustdoc/escape_pass.rs index 1eb8c0e6eca59..949573be05ebb 100644 --- a/src/librustdoc/escape_pass.rs +++ b/src/librustdoc/escape_pass.rs @@ -27,5 +27,5 @@ fn escape(s: &str) -> ~str { fn should_escape_backslashes() { let s = ~"\\n"; let r = escape(s); - fail_unless!(r == ~"\\\\n"); + assert!(r == ~"\\\\n"); } diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs index 08a5928ac3dfb..1d6d569e1c29d 100644 --- a/src/librustdoc/extract.rs +++ b/src/librustdoc/extract.rs @@ -185,8 +185,8 @@ fn constdoc_from_const(itemdoc: doc::ItemDoc) -> doc::ConstDoc { #[test] fn should_extract_const_name_and_id() { let doc = test::mk_doc(~"static a: int = 0;"); - fail_unless!(doc.cratemod().consts()[0].id() != 0); - fail_unless!(doc.cratemod().consts()[0].name() == ~"a"); + assert!(doc.cratemod().consts()[0].id() != 0); + assert!(doc.cratemod().consts()[0].name() == ~"a"); } fn enumdoc_from_enum( @@ -216,14 +216,14 @@ fn variantdoc_from_variant(variant: &ast::variant) -> doc::VariantDoc { #[test] fn should_extract_enums() { let doc = test::mk_doc(~"enum e { v }"); - fail_unless!(doc.cratemod().enums()[0].id() != 0); - fail_unless!(doc.cratemod().enums()[0].name() == ~"e"); + assert!(doc.cratemod().enums()[0].id() != 0); + assert!(doc.cratemod().enums()[0].name() == ~"e"); } #[test] fn should_extract_enum_variants() { let doc = test::mk_doc(~"enum e { v }"); - fail_unless!(doc.cratemod().enums()[0].variants[0].name == ~"v"); + assert!(doc.cratemod().enums()[0].variants[0].name == ~"v"); } fn traitdoc_from_trait( @@ -262,13 +262,13 @@ fn traitdoc_from_trait( #[test] fn should_extract_traits() { let doc = test::mk_doc(~"trait i { fn f(); }"); - fail_unless!(doc.cratemod().traits()[0].name() == ~"i"); + assert!(doc.cratemod().traits()[0].name() == ~"i"); } #[test] fn should_extract_trait_methods() { let doc = test::mk_doc(~"trait i { fn f(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].name == ~"f"); + assert!(doc.cratemod().traits()[0].methods[0].name == ~"f"); } fn impldoc_from_impl( @@ -296,7 +296,7 @@ fn impldoc_from_impl( #[test] fn should_extract_impl_methods() { let doc = test::mk_doc(~"impl int { fn f() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].name == ~"f"); + assert!(doc.cratemod().impls()[0].methods[0].name == ~"f"); } fn tydoc_from_ty( @@ -311,7 +311,7 @@ fn tydoc_from_ty( #[test] fn should_extract_tys() { let doc = test::mk_doc(~"type a = int;"); - fail_unless!(doc.cratemod().types()[0].name() == ~"a"); + assert!(doc.cratemod().types()[0].name() == ~"a"); } fn structdoc_from_struct( @@ -333,13 +333,13 @@ fn structdoc_from_struct( #[test] fn should_extract_structs() { let doc = test::mk_doc(~"struct Foo { field: () }"); - fail_unless!(doc.cratemod().structs()[0].name() == ~"Foo"); + assert!(doc.cratemod().structs()[0].name() == ~"Foo"); } #[test] fn should_extract_struct_fields() { let doc = test::mk_doc(~"struct Foo { field: () }"); - fail_unless!(doc.cratemod().structs()[0].fields[0] == ~"field"); + assert!(doc.cratemod().structs()[0].fields[0] == ~"field"); } #[cfg(test)] @@ -359,35 +359,35 @@ mod test { #[test] pub fn extract_empty_crate() { let doc = mk_doc(~""); - fail_unless!(vec::is_empty(doc.cratemod().mods())); - fail_unless!(vec::is_empty(doc.cratemod().fns())); + assert!(vec::is_empty(doc.cratemod().mods())); + assert!(vec::is_empty(doc.cratemod().fns())); } #[test] pub fn extract_mods() { let doc = mk_doc(~"mod a { mod b { } mod c { } }"); - fail_unless!(doc.cratemod().mods()[0].name() == ~"a"); - fail_unless!(doc.cratemod().mods()[0].mods()[0].name() == ~"b"); - fail_unless!(doc.cratemod().mods()[0].mods()[1].name() == ~"c"); + assert!(doc.cratemod().mods()[0].name() == ~"a"); + assert!(doc.cratemod().mods()[0].mods()[0].name() == ~"b"); + assert!(doc.cratemod().mods()[0].mods()[1].name() == ~"c"); } #[test] pub fn extract_fns_from_foreign_mods() { let doc = mk_doc(~"extern { fn a(); }"); - fail_unless!(doc.cratemod().nmods()[0].fns[0].name() == ~"a"); + assert!(doc.cratemod().nmods()[0].fns[0].name() == ~"a"); } #[test] pub fn extract_mods_deep() { let doc = mk_doc(~"mod a { mod b { mod c { } } }"); - fail_unless!(doc.cratemod().mods()[0].mods()[0].mods()[0].name() == + assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].name() == ~"c"); } #[test] pub fn extract_should_set_mod_ast_id() { let doc = mk_doc(~"mod a { }"); - fail_unless!(doc.cratemod().mods()[0].id() != 0); + assert!(doc.cratemod().mods()[0].id() != 0); } #[test] @@ -396,14 +396,14 @@ mod test { ~"fn a() { } \ mod b { fn c() { } }"); - fail_unless!(doc.cratemod().fns()[0].name() == ~"a"); - fail_unless!(doc.cratemod().mods()[0].fns()[0].name() == ~"c"); + assert!(doc.cratemod().fns()[0].name() == ~"a"); + assert!(doc.cratemod().mods()[0].fns()[0].name() == ~"c"); } #[test] pub fn extract_should_set_fn_ast_id() { let doc = mk_doc(~"fn a() { }"); - fail_unless!(doc.cratemod().fns()[0].id() != 0); + assert!(doc.cratemod().fns()[0].id() != 0); } #[test] @@ -411,7 +411,7 @@ mod test { let source = ~""; let ast = parse::from_str(source); let doc = extract(ast, ~"burp"); - fail_unless!(doc.cratemod().name() == ~"burp"); + assert!(doc.cratemod().name() == ~"burp"); } #[test] @@ -419,7 +419,7 @@ mod test { let source = ~""; do astsrv::from_str(source) |srv| { let doc = from_srv(srv, ~"name"); - fail_unless!(doc.cratemod().name() == ~"name"); + assert!(doc.cratemod().name() == ~"name"); } } } diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs index 2cd9ef3671d6e..d2f97b66bb652 100644 --- a/src/librustdoc/fold.rs +++ b/src/librustdoc/fold.rs @@ -373,7 +373,7 @@ fn default_fold_should_produce_same_doc() { let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = (fld.fold_doc)(&fld, copy doc); - fail_unless!(doc == folded); + assert!(doc == folded); } #[test] @@ -383,7 +383,7 @@ fn default_fold_should_produce_same_consts() { let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = (fld.fold_doc)(&fld, copy doc); - fail_unless!(doc == folded); + assert!(doc == folded); } #[test] @@ -393,7 +393,7 @@ fn default_fold_should_produce_same_enums() { let doc = extract::extract(ast, ~""); let fld = default_seq_fold(()); let folded = (fld.fold_doc)(&fld, copy doc); - fail_unless!(doc == folded); + assert!(doc == folded); } #[test] @@ -403,5 +403,5 @@ fn default_parallel_fold_should_produce_same_doc() { let doc = extract::extract(ast, ~""); let fld = default_par_fold(()); let folded = (fld.fold_doc)(&fld, copy doc); - fail_unless!(doc == folded); + assert!(doc == folded); } diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs index 4feeed84aa28b..55901b4904aa3 100644 --- a/src/librustdoc/markdown_index_pass.rs +++ b/src/librustdoc/markdown_index_pass.rs @@ -164,27 +164,27 @@ fn pandoc_header_id(header: &str) -> ~str { #[test] fn should_remove_punctuation_from_headers() { - fail_unless!(pandoc_header_id(~"impl foo of bar") == + assert!(pandoc_header_id(~"impl foo of bar") == ~"impl-foo-of-bara"); - fail_unless!(pandoc_header_id(~"impl of num::num for int") + assert!(pandoc_header_id(~"impl of num::num for int") == ~"impl-of-numnum-for-int"); - fail_unless!(pandoc_header_id(~"impl of num::num for int/&") + assert!(pandoc_header_id(~"impl of num::num for int/&") == ~"impl-of-numnum-for-int"); - fail_unless!(pandoc_header_id(~"impl of num::num for ^int") + assert!(pandoc_header_id(~"impl of num::num for ^int") == ~"impl-of-numnum-for-int"); - fail_unless!(pandoc_header_id(~"impl for & condvar") + assert!(pandoc_header_id(~"impl for & condvar") == ~"impl-for-condvar"); - fail_unless!(pandoc_header_id(~"impl of Select for (Left, Right)") + assert!(pandoc_header_id(~"impl of Select for (Left, Right)") == ~"impl-of-selectt-u-for-left-right"); - fail_unless!(pandoc_header_id(~"impl of Condition<'self, T, U>") + assert!(pandoc_header_id(~"impl of Condition<'self, T, U>") == ~"impl-of-conditionself-t-u"); - fail_unless!(pandoc_header_id(~"impl of Condition") + assert!(pandoc_header_id(~"impl of Condition") == ~"impl-of-conditiont-copy-clone"); } #[test] fn should_trim_whitespace_after_removing_punctuation() { - fail_unless!(pandoc_header_id("impl foo for ()") == ~"impl-foo-for"); + assert!(pandoc_header_id("impl foo for ()") == ~"impl-foo-for"); } #[test] @@ -193,13 +193,13 @@ fn should_index_mod_contents() { config::DocPerCrate, ~"mod a { } fn b() { }" ); - fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { + assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { kind: ~"Module", name: ~"a", brief: None, link: ~"#module-a" }); - fail_unless!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry { + assert!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry { kind: ~"Function", name: ~"b", brief: None, @@ -213,13 +213,13 @@ fn should_index_mod_contents_multi_page() { config::DocPerMod, ~"mod a { } fn b() { }" ); - fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { + assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { kind: ~"Module", name: ~"a", brief: None, link: ~"a.html" }); - fail_unless!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry { + assert!((&doc.cratemod().index).get().entries[1] == doc::IndexEntry { kind: ~"Function", name: ~"b", brief: None, @@ -233,7 +233,7 @@ fn should_index_foreign_mod_pages() { config::DocPerMod, ~"extern mod a { }" ); - fail_unless!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { + assert!((&doc.cratemod().index).get().entries[0] == doc::IndexEntry { kind: ~"Foreign module", name: ~"a", brief: None, @@ -247,7 +247,7 @@ fn should_add_brief_desc_to_index() { config::DocPerMod, ~"#[doc = \"test\"] mod a { }" ); - fail_unless!((&doc.cratemod().index).get().entries[0].brief + assert!((&doc.cratemod().index).get().entries[0].brief == Some(~"test")); } @@ -257,7 +257,7 @@ fn should_index_foreign_mod_contents() { config::DocPerCrate, ~"extern mod a { fn b(); }" ); - fail_unless!((&doc.cratemod().nmods()[0].index).get().entries[0] + assert!((&doc.cratemod().nmods()[0].index).get().entries[0] == doc::IndexEntry { kind: ~"Function", name: ~"b", diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 4b1b92221c0e6..8c4cd26bb7c11 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -91,9 +91,9 @@ fn should_write_modules_last() { let idx_c = str::find_str(markdown, ~"# Module `c`").get(); let idx_d = str::find_str(markdown, ~"## Function `d`").get(); - fail_unless!(idx_b < idx_d); - fail_unless!(idx_d < idx_a); - fail_unless!(idx_a < idx_c); + assert!(idx_b < idx_d); + assert!(idx_d < idx_a); + assert!(idx_a < idx_c); } struct Ctxt { @@ -175,10 +175,10 @@ fn should_write_title_for_each_page() { let (page, markdown) = po.recv(); match page { doc::CratePage(_) => { - fail_unless!(str::contains(markdown, ~"% Crate core")); + assert!(str::contains(markdown, ~"% Crate core")); } doc::ItemPage(_) => { - fail_unless!(str::contains(markdown, ~"% Module a")); + assert!(str::contains(markdown, ~"% Module a")); } } } @@ -248,7 +248,7 @@ pub fn header_name(doc: doc::ItemTag) -> ~str { fullpath } &doc::ImplTag(ref doc) => { - fail_unless!(doc.self_ty.is_some()); + assert!(doc.self_ty.is_some()); let bounds = if (&doc.bounds_str).is_some() { fmt!(" where %s", (&doc.bounds_str).get()) } else { @@ -326,7 +326,7 @@ fn write_mod( #[test] fn should_write_full_path_to_mod() { let markdown = test::render(~"mod a { mod b { mod c { } } }"); - fail_unless!(str::contains(markdown, ~"# Module `a::b::c`")); + assert!(str::contains(markdown, ~"# Module `a::b::c`")); } fn write_common( @@ -371,7 +371,7 @@ fn should_write_sections() { Body\"]\ mod a { }"); - fail_unless!(str::contains(markdown, ~"#### Header\n\nBody\n\n")); + assert!(str::contains(markdown, ~"#### Header\n\nBody\n\n")); } fn write_mod_contents( @@ -428,7 +428,7 @@ fn item_header_lvl(doc: &doc::ItemTag) -> Hlvl { #[test] fn should_write_crate_description() { let markdown = test::render(~"#[doc = \"this is the crate\"];"); - fail_unless!(str::contains(markdown, ~"this is the crate")); + assert!(str::contains(markdown, ~"this is the crate")); } fn write_index(ctxt: &Ctxt, index: doc::Index) { @@ -457,7 +457,7 @@ fn write_index(ctxt: &Ctxt, index: doc::Index) { #[test] fn should_write_index() { let markdown = test::render(~"mod a { } mod b { }"); - fail_unless!(str::contains( + assert!(str::contains( markdown, ~"\n\n* [Module `a`](#module-a)\n\ * [Module `b`](#module-b)\n\n" @@ -467,19 +467,19 @@ fn should_write_index() { #[test] fn should_write_index_brief() { let markdown = test::render(~"#[doc = \"test\"] mod a { }"); - fail_unless!(str::contains(markdown, ~"(#module-a) - test\n")); + assert!(str::contains(markdown, ~"(#module-a) - test\n")); } #[test] fn should_not_write_index_if_no_entries() { let markdown = test::render(~""); - fail_unless!(!str::contains(markdown, ~"\n\n\n")); + assert!(!str::contains(markdown, ~"\n\n\n")); } #[test] fn should_write_index_for_foreign_mods() { let markdown = test::render(~"extern mod a { fn a(); }"); - fail_unless!(str::contains( + assert!(str::contains( markdown, ~"\n\n* [Function `a`](#function-a)\n\n" )); @@ -500,22 +500,22 @@ fn write_nmod(ctxt: &Ctxt, doc: doc::NmodDoc) { #[test] fn should_write_foreign_mods() { let markdown = test::render(~"#[doc = \"test\"] extern mod a { }"); - fail_unless!(str::contains(markdown, ~"Foreign module `a`")); - fail_unless!(str::contains(markdown, ~"test")); + assert!(str::contains(markdown, ~"Foreign module `a`")); + assert!(str::contains(markdown, ~"test")); } #[test] fn should_write_foreign_fns() { let markdown = test::render( ~"extern mod a { #[doc = \"test\"] fn a(); }"); - fail_unless!(str::contains(markdown, ~"test")); + assert!(str::contains(markdown, ~"test")); } #[test] fn should_write_foreign_fn_headers() { let markdown = test::render( ~"extern mod a { #[doc = \"test\"] fn a(); }"); - fail_unless!(str::contains(markdown, ~"## Function `a`")); + assert!(str::contains(markdown, ~"## Function `a`")); } fn write_fn( @@ -561,19 +561,19 @@ fn code_block_indent(s: ~str) -> ~str { #[test] fn write_markdown_should_write_function_header() { let markdown = test::render(~"fn func() { }"); - fail_unless!(str::contains(markdown, ~"## Function `func`")); + assert!(str::contains(markdown, ~"## Function `func`")); } #[test] fn should_write_the_function_signature() { let markdown = test::render(~"#[doc = \"f\"] fn a() { }"); - fail_unless!(str::contains(markdown, ~"\n fn a()\n")); + assert!(str::contains(markdown, ~"\n fn a()\n")); } #[test] fn should_insert_blank_line_after_fn_signature() { let markdown = test::render(~"#[doc = \"f\"] fn a() { }"); - fail_unless!(str::contains(markdown, ~"fn a()\n\n")); + assert!(str::contains(markdown, ~"fn a()\n\n")); } #[test] @@ -594,13 +594,13 @@ fn should_correctly_indent_fn_signature() { ] }; let markdown = test::write_markdown_str(doc); - fail_unless!(str::contains(markdown, ~" line 1\n line 2")); + assert!(str::contains(markdown, ~" line 1\n line 2")); } #[test] fn should_leave_blank_line_between_fn_header_and_sig() { let markdown = test::render(~"fn a() { }"); - fail_unless!(str::contains(markdown, ~"Function `a`\n\n fn a()")); + assert!(str::contains(markdown, ~"Function `a`\n\n fn a()")); } fn write_const( @@ -614,7 +614,7 @@ fn write_const( #[test] fn should_write_const_header() { let markdown = test::render(~"static a: bool = true;"); - fail_unless!(str::contains(markdown, ~"## Const `a`\n\n")); + assert!(str::contains(markdown, ~"## Const `a`\n\n")); } #[test] @@ -622,7 +622,7 @@ fn should_write_const_description() { let markdown = test::render( ~"#[doc = \"b\"]\ static a: bool = true;"); - fail_unless!(str::contains(markdown, ~"\n\nb\n\n")); + assert!(str::contains(markdown, ~"\n\nb\n\n")); } fn write_enum( @@ -636,14 +636,14 @@ fn write_enum( #[test] fn should_write_enum_header() { let markdown = test::render(~"enum a { b }"); - fail_unless!(str::contains(markdown, ~"## Enum `a`\n\n")); + assert!(str::contains(markdown, ~"## Enum `a`\n\n")); } #[test] fn should_write_enum_description() { let markdown = test::render( ~"#[doc = \"b\"] enum a { b }"); - fail_unless!(str::contains(markdown, ~"\n\nb\n\n")); + assert!(str::contains(markdown, ~"\n\nb\n\n")); } fn write_variants( @@ -664,7 +664,7 @@ fn write_variants( } fn write_variant(ctxt: &Ctxt, doc: doc::VariantDoc) { - fail_unless!(doc.sig.is_some()); + assert!(doc.sig.is_some()); let sig = (&doc.sig).get(); match copy doc.desc { Some(desc) => { @@ -682,7 +682,7 @@ fn should_write_variant_list() { ~"enum a { \ #[doc = \"test\"] b, \ #[doc = \"test\"] c }"); - fail_unless!(str::contains( + assert!(str::contains( markdown, ~"\n\n#### Variants\n\ \n* `b` - test\ @@ -692,7 +692,7 @@ fn should_write_variant_list() { #[test] fn should_write_variant_list_without_descs() { let markdown = test::render(~"enum a { b, c }"); - fail_unless!(str::contains( + assert!(str::contains( markdown, ~"\n\n#### Variants\n\ \n* `b`\ @@ -702,7 +702,7 @@ fn should_write_variant_list_without_descs() { #[test] fn should_write_variant_list_with_signatures() { let markdown = test::render(~"enum a { b(int), #[doc = \"a\"] c(int) }"); - fail_unless!(str::contains( + assert!(str::contains( markdown, ~"\n\n#### Variants\n\ \n* `b(int)`\ @@ -733,28 +733,28 @@ fn write_method(ctxt: &Ctxt, doc: doc::MethodDoc) { #[test] fn should_write_trait_header() { let markdown = test::render(~"trait i { fn a(); }"); - fail_unless!(str::contains(markdown, ~"## Trait `i`")); + assert!(str::contains(markdown, ~"## Trait `i`")); } #[test] fn should_write_trait_desc() { let markdown = test::render( ~"#[doc = \"desc\"] trait i { fn a(); }"); - fail_unless!(str::contains(markdown, ~"desc")); + assert!(str::contains(markdown, ~"desc")); } #[test] fn should_write_trait_method_header() { let markdown = test::render( ~"trait i { fn a(); }"); - fail_unless!(str::contains(markdown, ~"### Method `a`")); + assert!(str::contains(markdown, ~"### Method `a`")); } #[test] fn should_write_trait_method_signature() { let markdown = test::render( ~"trait i { fn a(&self); }"); - fail_unless!(str::contains(markdown, ~"\n fn a(&self)")); + assert!(str::contains(markdown, ~"\n fn a(&self)")); } fn write_impl(ctxt: &Ctxt, doc: doc::ImplDoc) { @@ -765,19 +765,19 @@ fn write_impl(ctxt: &Ctxt, doc: doc::ImplDoc) { #[test] fn should_write_impl_header() { let markdown = test::render(~"impl int { fn a() { } }"); - fail_unless!(str::contains(markdown, ~"## Implementation for `int`")); + assert!(str::contains(markdown, ~"## Implementation for `int`")); } #[test] fn should_write_impl_header_with_bounds() { let markdown = test::render(~"impl int { }"); - fail_unless!(str::contains(markdown, ~"## Implementation for `int` where ``")); + assert!(str::contains(markdown, ~"## Implementation for `int` where ``")); } #[test] fn should_write_impl_header_with_trait() { let markdown = test::render(~"impl j for int { fn a() { } }"); - fail_unless!(str::contains(markdown, + assert!(str::contains(markdown, ~"## Implementation of `j` for `int`")); } @@ -785,21 +785,21 @@ fn should_write_impl_header_with_trait() { fn should_write_impl_desc() { let markdown = test::render( ~"#[doc = \"desc\"] impl int { fn a() { } }"); - fail_unless!(str::contains(markdown, ~"desc")); + assert!(str::contains(markdown, ~"desc")); } #[test] fn should_write_impl_method_header() { let markdown = test::render( ~"impl int { fn a() { } }"); - fail_unless!(str::contains(markdown, ~"### Method `a`")); + assert!(str::contains(markdown, ~"### Method `a`")); } #[test] fn should_write_impl_method_signature() { let markdown = test::render( ~"impl int { fn a(&mut self) { } }"); - fail_unless!(str::contains(markdown, ~"\n fn a(&mut self)")); + assert!(str::contains(markdown, ~"\n fn a(&mut self)")); } fn write_type( @@ -813,20 +813,20 @@ fn write_type( #[test] fn should_write_type_header() { let markdown = test::render(~"type t = int;"); - fail_unless!(str::contains(markdown, ~"## Type `t`")); + assert!(str::contains(markdown, ~"## Type `t`")); } #[test] fn should_write_type_desc() { let markdown = test::render( ~"#[doc = \"desc\"] type t = int;"); - fail_unless!(str::contains(markdown, ~"\n\ndesc\n\n")); + assert!(str::contains(markdown, ~"\n\ndesc\n\n")); } #[test] fn should_write_type_signature() { let markdown = test::render(~"type t = int;"); - fail_unless!(str::contains(markdown, ~"\n\n type t = int\n\n")); + assert!(str::contains(markdown, ~"\n\n type t = int\n\n")); } fn put_struct( @@ -840,7 +840,7 @@ fn put_struct( #[test] fn should_put_struct_header() { let markdown = test::render(~"struct S { field: () }"); - fail_unless!(str::contains(markdown, ~"## Struct `S`\n\n")); + assert!(str::contains(markdown, ~"## Struct `S`\n\n")); } #[cfg(test)] @@ -927,12 +927,12 @@ mod test { #[test] pub fn write_markdown_should_write_mod_headers() { let markdown = render(~"mod moo { }"); - fail_unless!(str::contains(markdown, ~"# Module `moo`")); + assert!(str::contains(markdown, ~"# Module `moo`")); } #[test] pub fn should_leave_blank_line_after_header() { let markdown = render(~"mod morp { }"); - fail_unless!(str::contains(markdown, ~"Module `morp`\n\n")); + assert!(str::contains(markdown, ~"Module `morp`\n\n")); } } diff --git a/src/librustdoc/markdown_writer.rs b/src/librustdoc/markdown_writer.rs index 4c68e632f83eb..2011649995ecd 100644 --- a/src/librustdoc/markdown_writer.rs +++ b/src/librustdoc/markdown_writer.rs @@ -92,7 +92,7 @@ fn pandoc_writer( config: config::Config, page: doc::Page ) -> Writer { - fail_unless!(config.pandoc_cmd.is_some()); + assert!(config.pandoc_cmd.is_some()); let pandoc_cmd = (&config.pandoc_cmd).get(); let filename = make_local_filename(config, page); @@ -201,7 +201,7 @@ pub fn make_filename( config.output_style == config::DocPerMod { ~"index" } else { - fail_unless!(doc.topmod.name() != ~""); + assert!(doc.topmod.name() != ~""); doc.topmod.name() } } @@ -229,7 +229,7 @@ fn should_use_markdown_file_name_based_off_crate() { let doc = test::mk_doc(~"test", ~""); let page = doc::CratePage(doc.CrateDoc()); let filename = make_local_filename(config, page); - fail_unless!(filename.to_str() == ~"output/dir/test.md"); + assert!(filename.to_str() == ~"output/dir/test.md"); } #[test] @@ -243,7 +243,7 @@ fn should_name_html_crate_file_name_index_html_when_doc_per_mod() { let doc = test::mk_doc(~"", ~""); let page = doc::CratePage(doc.CrateDoc()); let filename = make_local_filename(config, page); - fail_unless!(filename.to_str() == ~"output/dir/index.html"); + assert!(filename.to_str() == ~"output/dir/index.html"); } #[test] @@ -258,7 +258,7 @@ fn should_name_mod_file_names_by_path() { let modb = copy doc.cratemod().mods()[0].mods()[0]; let page = doc::ItemPage(doc::ModTag(modb)); let filename = make_local_filename(config, page); - fail_unless!(filename == Path("output/dir/a_b.html")); + assert!(filename == Path("output/dir/a_b.html")); } #[cfg(test)] diff --git a/src/librustdoc/page_pass.rs b/src/librustdoc/page_pass.rs index e1996409a7694..55f17f5c1501d 100644 --- a/src/librustdoc/page_pass.rs +++ b/src/librustdoc/page_pass.rs @@ -155,19 +155,19 @@ fn should_not_split_the_doc_into_pages_for_doc_per_crate() { config::DocPerCrate, ~"mod a { } mod b { mod c { } }" ); - fail_unless!(doc.pages.len() == 1u); + assert!(doc.pages.len() == 1u); } #[test] fn should_make_a_page_for_every_mod() { let doc = test::mk_doc(~"mod a { }"); - fail_unless!(doc.pages.mods()[0].name() == ~"a"); + assert!(doc.pages.mods()[0].name() == ~"a"); } #[test] fn should_remove_mods_from_containing_mods() { let doc = test::mk_doc(~"mod a { }"); - fail_unless!(vec::is_empty(doc.cratemod().mods())); + assert!(vec::is_empty(doc.cratemod().mods())); } #[cfg(test)] diff --git a/src/librustdoc/pass.rs b/src/librustdoc/pass.rs index e71b145d7df97..52d6e8d9cd670 100644 --- a/src/librustdoc/pass.rs +++ b/src/librustdoc/pass.rs @@ -93,6 +93,6 @@ fn test_run_passes() { ]; let doc = extract::from_srv(srv.clone(), ~"one"); let doc = run_passes(srv, doc, passes); - fail_unless!(doc.cratemod().name() == ~"onetwothree"); + assert!(doc.cratemod().name() == ~"onetwothree"); } } diff --git a/src/librustdoc/path_pass.rs b/src/librustdoc/path_pass.rs index 58b25446dc1b3..dab60e0e0c05f 100644 --- a/src/librustdoc/path_pass.rs +++ b/src/librustdoc/path_pass.rs @@ -98,9 +98,9 @@ fn should_record_mod_paths() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = run(srv.clone(), doc); - fail_unless!(doc.cratemod().mods()[0].mods()[0].mods()[0].path() + assert!(doc.cratemod().mods()[0].mods()[0].mods()[0].path() == ~[~"a", ~"b"]); - fail_unless!(doc.cratemod().mods()[0].mods()[1].mods()[0].path() + assert!(doc.cratemod().mods()[0].mods()[1].mods()[0].path() == ~[~"a", ~"d"]); } } @@ -111,7 +111,7 @@ fn should_record_fn_paths() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = run(srv.clone(), doc); - fail_unless!(doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]); + assert!(doc.cratemod().mods()[0].fns()[0].path() == ~[~"a"]); } } diff --git a/src/librustdoc/prune_hidden_pass.rs b/src/librustdoc/prune_hidden_pass.rs index 3c069e59e7ae3..f46d183ffcfaf 100644 --- a/src/librustdoc/prune_hidden_pass.rs +++ b/src/librustdoc/prune_hidden_pass.rs @@ -66,7 +66,7 @@ fn should_prune_hidden_items() { use core::vec; let doc = test::mk_doc(~"#[doc(hidden)] mod a { }"); - fail_unless!(vec::is_empty(doc.cratemod().mods())) + assert!(vec::is_empty(doc.cratemod().mods())) } #[cfg(test)] diff --git a/src/librustdoc/prune_private_pass.rs b/src/librustdoc/prune_private_pass.rs index e6f21b5df5457..a1f8fdb75d9ea 100644 --- a/src/librustdoc/prune_private_pass.rs +++ b/src/librustdoc/prune_private_pass.rs @@ -85,7 +85,7 @@ fn strip_priv_methods( let ast_method = do methods.find |m| { extract::to_str(m.ident) == method.name }; - fail_unless!(ast_method.is_some()); + assert!(ast_method.is_some()); let ast_method = ast_method.unwrap(); match ast_method.vis { ast::public => true, @@ -157,7 +157,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool { #[test] fn should_prune_items_without_pub_modifier() { let doc = test::mk_doc(~"mod a { }"); - fail_unless!(vec::is_empty(doc.cratemod().mods())); + assert!(vec::is_empty(doc.cratemod().mods())); } #[test] @@ -168,7 +168,7 @@ fn should_not_prune_trait_impls() { trait Foo { } \ impl Foo for int { } \ "); - fail_unless!(!doc.cratemod().impls().is_empty()); + assert!(!doc.cratemod().impls().is_empty()); } #[test] @@ -178,7 +178,7 @@ fn should_prune_associated_methods_without_vis_modifier_on_impls_without_vis_mod pub fn bar() { }\ fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods.len() == 1); + assert!(doc.cratemod().impls()[0].methods.len() == 1); } #[test] @@ -188,7 +188,7 @@ fn should_prune_priv_associated_methods_on_impls_without_vis_modifier() { pub fn bar() { }\ priv fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods.len() == 1); + assert!(doc.cratemod().impls()[0].methods.len() == 1); } #[test] @@ -198,7 +198,7 @@ fn should_prune_priv_associated_methods_on_pub_impls() { fn bar() { }\ priv fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods.len() == 1); + assert!(doc.cratemod().impls()[0].methods.len() == 1); } #[test] @@ -208,7 +208,7 @@ fn should_prune_associated_methods_without_vis_modifier_on_priv_impls() { pub fn bar() { }\ fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods.len() == 1); + assert!(doc.cratemod().impls()[0].methods.len() == 1); } #[test] @@ -218,7 +218,7 @@ fn should_prune_priv_associated_methods_on_priv_impls() { pub fn bar() { }\ priv fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls()[0].methods.len() == 1); + assert!(doc.cratemod().impls()[0].methods.len() == 1); } #[test] @@ -227,7 +227,7 @@ fn should_prune_associated_impls_with_no_pub_methods() { ~"priv impl Foo {\ fn baz() { }\ }"); - fail_unless!(doc.cratemod().impls().is_empty()); + assert!(doc.cratemod().impls().is_empty()); } #[test] @@ -236,7 +236,7 @@ fn should_not_prune_associated_impls_with_pub_methods() { ~" \ impl Foo { pub fn bar() { } } \ "); - fail_unless!(!doc.cratemod().impls().is_empty()); + assert!(!doc.cratemod().impls().is_empty()); } diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs index 33003a59611d4..788f84b06c2e8 100644 --- a/src/librustdoc/sectionalize_pass.rs +++ b/src/librustdoc/sectionalize_pass.rs @@ -168,7 +168,7 @@ fn should_create_section_headers() { Body\"]\ mod a { }"); - fail_unless!(str::contains( + assert!(str::contains( doc.cratemod().mods()[0].item.sections[0].header, ~"Header")); } @@ -181,7 +181,7 @@ fn should_create_section_bodies() { Body\"]\ mod a { }"); - fail_unless!(str::contains( + assert!(str::contains( doc.cratemod().mods()[0].item.sections[0].body, ~"Body")); } @@ -194,7 +194,7 @@ fn should_not_create_sections_from_indented_headers() { Body\"]\ mod a { }"); - fail_unless!(vec::is_empty(doc.cratemod().mods()[0].item.sections)); + assert!(vec::is_empty(doc.cratemod().mods()[0].item.sections)); } #[test] @@ -206,10 +206,10 @@ fn should_remove_section_text_from_main_desc() { Body\"]\ mod a { }"); - fail_unless!(!str::contains( + assert!(!str::contains( doc.cratemod().mods()[0].desc().get(), ~"Header")); - fail_unless!(!str::contains( + assert!(!str::contains( doc.cratemod().mods()[0].desc().get(), ~"Body")); } @@ -222,7 +222,7 @@ fn should_eliminate_desc_if_it_is_just_whitespace() { Body\"]\ mod a { }"); - fail_unless!(doc.cratemod().mods()[0].desc() == None); + assert!(doc.cratemod().mods()[0].desc() == None); } #[test] @@ -233,7 +233,7 @@ fn should_sectionalize_trait_methods() { # Header\n\ Body\"]\ fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].sections.len() == 1u); + assert!(doc.cratemod().traits()[0].methods[0].sections.len() == 1u); } #[test] @@ -244,7 +244,7 @@ fn should_sectionalize_impl_methods() { # Header\n\ Body\"]\ fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].sections.len() == 1u); + assert!(doc.cratemod().impls()[0].methods[0].sections.len() == 1u); } #[cfg(test)] diff --git a/src/librustdoc/sort_item_name_pass.rs b/src/librustdoc/sort_item_name_pass.rs index b3fb874cdb260..86b2cc634fd04 100644 --- a/src/librustdoc/sort_item_name_pass.rs +++ b/src/librustdoc/sort_item_name_pass.rs @@ -31,7 +31,7 @@ fn test() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass().f)(srv.clone(), doc); - fail_unless!(doc.cratemod().items[0].name() == ~"y"); - fail_unless!(doc.cratemod().items[1].name() == ~"z"); + assert!(doc.cratemod().items[0].name() == ~"y"); + assert!(doc.cratemod().items[1].name() == ~"z"); } } diff --git a/src/librustdoc/sort_item_type_pass.rs b/src/librustdoc/sort_item_type_pass.rs index 5919f1b0c2fbe..d75565d4ec824 100644 --- a/src/librustdoc/sort_item_type_pass.rs +++ b/src/librustdoc/sort_item_type_pass.rs @@ -55,14 +55,14 @@ fn test() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass().f)(srv.clone(), doc); - fail_unless!(doc.cratemod().items[0].name() == ~"iconst"); - fail_unless!(doc.cratemod().items[1].name() == ~"itype"); - fail_unless!(doc.cratemod().items[2].name() == ~"ienum"); - fail_unless!(doc.cratemod().items[3].name() == ~"istruct"); - fail_unless!(doc.cratemod().items[4].name() == ~"itrait"); - fail_unless!(doc.cratemod().items[5].name() == ~"__extensions__"); - fail_unless!(doc.cratemod().items[6].name() == ~"ifn"); - fail_unless!(doc.cratemod().items[7].name() == ~"imod"); - fail_unless!(doc.cratemod().items[8].name() == ~"inmod"); + assert!(doc.cratemod().items[0].name() == ~"iconst"); + assert!(doc.cratemod().items[1].name() == ~"itype"); + assert!(doc.cratemod().items[2].name() == ~"ienum"); + assert!(doc.cratemod().items[3].name() == ~"istruct"); + assert!(doc.cratemod().items[4].name() == ~"itrait"); + assert!(doc.cratemod().items[5].name() == ~"__extensions__"); + assert!(doc.cratemod().items[6].name() == ~"ifn"); + assert!(doc.cratemod().items[7].name() == ~"imod"); + assert!(doc.cratemod().items[8].name() == ~"inmod"); } } diff --git a/src/librustdoc/sort_pass.rs b/src/librustdoc/sort_pass.rs index e66eb3c0fae30..dc7bc8b9df21f 100644 --- a/src/librustdoc/sort_pass.rs +++ b/src/librustdoc/sort_pass.rs @@ -67,10 +67,10 @@ fn test() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass(~"", name_lteq).f)(srv.clone(), doc); - fail_unless!(doc.cratemod().mods()[0].name() == ~"w"); - fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"x"); - fail_unless!(doc.cratemod().mods()[1].items[1].name() == ~"y"); - fail_unless!(doc.cratemod().mods()[1].name() == ~"z"); + assert!(doc.cratemod().mods()[0].name() == ~"w"); + assert!(doc.cratemod().mods()[1].items[0].name() == ~"x"); + assert!(doc.cratemod().mods()[1].items[1].name() == ~"y"); + assert!(doc.cratemod().mods()[1].name() == ~"z"); } } @@ -84,10 +84,10 @@ fn should_be_stable() { do astsrv::from_str(source) |srv| { let doc = extract::from_srv(srv.clone(), ~""); let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc); - fail_unless!(doc.cratemod().mods()[0].items[0].name() == ~"b"); - fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"d"); + assert!(doc.cratemod().mods()[0].items[0].name() == ~"b"); + assert!(doc.cratemod().mods()[1].items[0].name() == ~"d"); let doc = (mk_pass(~"", always_eq).f)(srv.clone(), doc); - fail_unless!(doc.cratemod().mods()[0].items[0].name() == ~"b"); - fail_unless!(doc.cratemod().mods()[1].items[0].name() == ~"d"); + assert!(doc.cratemod().mods()[0].items[0].name() == ~"b"); + assert!(doc.cratemod().mods()[1].items[0].name() == ~"d"); } } diff --git a/src/librustdoc/text_pass.rs b/src/librustdoc/text_pass.rs index 65e7228eeaea2..b5e9b452d148b 100644 --- a/src/librustdoc/text_pass.rs +++ b/src/librustdoc/text_pass.rs @@ -140,89 +140,89 @@ fn fold_impl( #[test] fn should_execute_op_on_enum_brief() { let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }"); - fail_unless!(doc.cratemod().enums()[0].brief() == Some(~"a")); + assert!(doc.cratemod().enums()[0].brief() == Some(~"a")); } #[test] fn should_execute_op_on_enum_desc() { let doc = test::mk_doc(~"#[doc = \" a \"] enum a { b }"); - fail_unless!(doc.cratemod().enums()[0].desc() == Some(~"a")); + assert!(doc.cratemod().enums()[0].desc() == Some(~"a")); } #[test] fn should_execute_op_on_variant_desc() { let doc = test::mk_doc(~"enum a { #[doc = \" a \"] b }"); - fail_unless!(doc.cratemod().enums()[0].variants[0].desc == Some(~"a")); + assert!(doc.cratemod().enums()[0].variants[0].desc == Some(~"a")); } #[test] fn should_execute_op_on_trait_brief() { let doc = test::mk_doc( ~"#[doc = \" a \"] trait i { fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].brief() == Some(~"a")); + assert!(doc.cratemod().traits()[0].brief() == Some(~"a")); } #[test] fn should_execute_op_on_trait_desc() { let doc = test::mk_doc( ~"#[doc = \" a \"] trait i { fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].desc() == Some(~"a")); + assert!(doc.cratemod().traits()[0].desc() == Some(~"a")); } #[test] fn should_execute_op_on_trait_method_brief() { let doc = test::mk_doc( ~"trait i { #[doc = \" a \"] fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].brief == Some(~"a")); + assert!(doc.cratemod().traits()[0].methods[0].brief == Some(~"a")); } #[test] fn should_execute_op_on_trait_method_desc() { let doc = test::mk_doc( ~"trait i { #[doc = \" a \"] fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].desc == Some(~"a")); + assert!(doc.cratemod().traits()[0].methods[0].desc == Some(~"a")); } #[test] fn should_execute_op_on_impl_brief() { let doc = test::mk_doc( ~"#[doc = \" a \"] impl int { fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].brief() == Some(~"a")); + assert!(doc.cratemod().impls()[0].brief() == Some(~"a")); } #[test] fn should_execute_op_on_impl_desc() { let doc = test::mk_doc( ~"#[doc = \" a \"] impl int { fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].desc() == Some(~"a")); + assert!(doc.cratemod().impls()[0].desc() == Some(~"a")); } #[test] fn should_execute_op_on_impl_method_brief() { let doc = test::mk_doc( ~"impl int { #[doc = \" a \"] fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].brief == Some(~"a")); + assert!(doc.cratemod().impls()[0].methods[0].brief == Some(~"a")); } #[test] fn should_execute_op_on_impl_method_desc() { let doc = test::mk_doc( ~"impl int { #[doc = \" a \"] fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].desc == Some(~"a")); + assert!(doc.cratemod().impls()[0].methods[0].desc == Some(~"a")); } #[test] fn should_execute_op_on_type_brief() { let doc = test::mk_doc( ~"#[doc = \" a \"] type t = int;"); - fail_unless!(doc.cratemod().types()[0].brief() == Some(~"a")); + assert!(doc.cratemod().types()[0].brief() == Some(~"a")); } #[test] fn should_execute_op_on_type_desc() { let doc = test::mk_doc( ~"#[doc = \" a \"] type t = int;"); - fail_unless!(doc.cratemod().types()[0].desc() == Some(~"a")); + assert!(doc.cratemod().types()[0].desc() == Some(~"a")); } #[test] @@ -232,7 +232,7 @@ fn should_execute_on_item_section_headers() { # Header \n\ Body\"]\ fn a() { }"); - fail_unless!(doc.cratemod().fns()[0].sections()[0].header == ~"Header"); + assert!(doc.cratemod().fns()[0].sections()[0].header == ~"Header"); } #[test] @@ -242,7 +242,7 @@ fn should_execute_on_item_section_bodies() { # Header\n\ Body \"]\ fn a() { }"); - fail_unless!(doc.cratemod().fns()[0].sections()[0].body == ~"Body"); + assert!(doc.cratemod().fns()[0].sections()[0].body == ~"Body"); } #[test] @@ -253,7 +253,7 @@ fn should_execute_on_trait_method_section_headers() { # Header \n\ Body\"]\ fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].sections[0].header + assert!(doc.cratemod().traits()[0].methods[0].sections[0].header == ~"Header"); } @@ -265,7 +265,7 @@ fn should_execute_on_trait_method_section_bodies() { # Header\n\ Body \"]\ fn a(); }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].sections[0].body == + assert!(doc.cratemod().traits()[0].methods[0].sections[0].body == ~"Body"); } @@ -277,7 +277,7 @@ fn should_execute_on_impl_method_section_headers() { # Header \n\ Body\"]\ fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].sections[0].header + assert!(doc.cratemod().impls()[0].methods[0].sections[0].header == ~"Header"); } @@ -289,7 +289,7 @@ fn should_execute_on_impl_method_section_bodies() { # Header\n\ Body \"]\ fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].sections[0].body == + assert!(doc.cratemod().impls()[0].methods[0].sections[0].body == ~"Body"); } diff --git a/src/librustdoc/trim_pass.rs b/src/librustdoc/trim_pass.rs index a1439e2e14932..ca543a27189dc 100644 --- a/src/librustdoc/trim_pass.rs +++ b/src/librustdoc/trim_pass.rs @@ -29,7 +29,7 @@ fn should_trim_text() { let doc = test::mk_doc(~"#[doc = \" desc \"] \ mod m { }"); - fail_unless!(doc.cratemod().mods()[0].desc() == Some(~"desc")); + assert!(doc.cratemod().mods()[0].desc() == Some(~"desc")); } #[cfg(test)] diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index 229a0a3ff0f3d..293799d85b2a4 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -86,13 +86,13 @@ fn get_fn_sig(srv: astsrv::Srv, fn_id: doc::AstId) -> Option<~str> { #[test] fn should_add_fn_sig() { let doc = test::mk_doc(~"fn a() -> int { }"); - fail_unless!(doc.cratemod().fns()[0].sig == Some(~"fn a() -> int")); + assert!(doc.cratemod().fns()[0].sig == Some(~"fn a() -> int")); } #[test] fn should_add_foreign_fn_sig() { let doc = test::mk_doc(~"extern mod a { fn a() -> int; }"); - fail_unless!(doc.cratemod().nmods()[0].fns[0].sig == + assert!(doc.cratemod().nmods()[0].fns[0].sig == Some(~"fn a() -> int")); } @@ -122,7 +122,7 @@ fn fold_const( #[test] fn should_add_const_types() { let doc = test::mk_doc(~"static a: bool = true;"); - fail_unless!(doc.cratemod().consts()[0].sig == Some(~"bool")); + assert!(doc.cratemod().consts()[0].sig == Some(~"bool")); } fn fold_enum( @@ -166,7 +166,7 @@ fn fold_enum( #[test] fn should_add_variant_sigs() { let doc = test::mk_doc(~"enum a { b(int) }"); - fail_unless!(doc.cratemod().enums()[0].variants[0].sig == + assert!(doc.cratemod().enums()[0].variants[0].sig == Some(~"b(int)")); } @@ -263,7 +263,7 @@ fn get_method_sig( #[test] fn should_add_trait_method_sigs() { let doc = test::mk_doc(~"trait i { fn a(&mut self) -> int; }"); - fail_unless!(doc.cratemod().traits()[0].methods[0].sig + assert!(doc.cratemod().traits()[0].methods[0].sig == Some(~"fn a(&mut self) -> int")); } @@ -308,31 +308,31 @@ fn fold_impl( #[test] fn should_add_impl_bounds() { let doc = test::mk_doc(~"impl Option { }"); - fail_unless!(doc.cratemod().impls()[0].bounds_str == Some(~"")); + assert!(doc.cratemod().impls()[0].bounds_str == Some(~"")); } #[test] fn should_add_impl_trait_types() { let doc = test::mk_doc(~"impl j for int { fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].trait_types[0] == ~"j"); + assert!(doc.cratemod().impls()[0].trait_types[0] == ~"j"); } #[test] fn should_not_add_impl_trait_types_if_none() { let doc = test::mk_doc(~"impl int { fn a() { } }"); - fail_unless!(vec::len(doc.cratemod().impls()[0].trait_types) == 0); + assert!(vec::len(doc.cratemod().impls()[0].trait_types) == 0); } #[test] fn should_add_impl_self_ty() { let doc = test::mk_doc(~"impl int { fn a() { } }"); - fail_unless!(doc.cratemod().impls()[0].self_ty == Some(~"int")); + assert!(doc.cratemod().impls()[0].self_ty == Some(~"int")); } #[test] fn should_add_impl_method_sigs() { let doc = test::mk_doc(~"impl int { fn a(&self) -> int { fail!() } }"); - fail_unless!(doc.cratemod().impls()[0].methods[0].sig + assert!(doc.cratemod().impls()[0].methods[0].sig == Some(~"fn a(&self) -> int")); } @@ -372,7 +372,7 @@ fn fold_type( #[test] fn should_add_type_signatures() { let doc = test::mk_doc(~"type t = int;"); - fail_unless!(doc.cratemod().types()[0].sig == Some(~"type t = int")); + assert!(doc.cratemod().types()[0].sig == Some(~"type t = int")); } fn fold_struct( @@ -425,7 +425,7 @@ fn strip_struct_extra_stuff(item: @ast::item) -> @ast::item { #[test] fn should_add_struct_defs() { let doc = test::mk_doc(~"struct S { field: () }"); - fail_unless!((&doc.cratemod().structs()[0].sig).get().contains( + assert!((&doc.cratemod().structs()[0].sig).get().contains( "struct S {")); } @@ -433,14 +433,14 @@ fn should_add_struct_defs() { fn should_not_serialize_struct_drop_blocks() { // All we care about are the fields let doc = test::mk_doc(~"struct S { field: (), drop { } }"); - fail_unless!(!(&doc.cratemod().structs()[0].sig).get().contains("drop")); + assert!(!(&doc.cratemod().structs()[0].sig).get().contains("drop")); } #[test] fn should_not_serialize_struct_attrs() { // All we care about are the fields let doc = test::mk_doc(~"#[wut] struct S { field: () }"); - fail_unless!(!(&doc.cratemod().structs()[0].sig).get().contains("wut")); + assert!(!(&doc.cratemod().structs()[0].sig).get().contains("wut")); } #[cfg(test)] diff --git a/src/librustdoc/unindent_pass.rs b/src/librustdoc/unindent_pass.rs index 6207e2252e40b..19877fea1fdd6 100644 --- a/src/librustdoc/unindent_pass.rs +++ b/src/librustdoc/unindent_pass.rs @@ -84,7 +84,7 @@ fn unindent(s: &str) -> ~str { if str::is_whitespace(*line) { copy *line } else { - fail_unless!(str::len(*line) >= min_indent); + assert!(str::len(*line) >= min_indent); str::slice(*line, min_indent, str::len(*line)).to_owned() } }; @@ -98,14 +98,14 @@ fn unindent(s: &str) -> ~str { fn should_unindent() { let s = ~" line1\n line2"; let r = unindent(s); - fail_unless!(r == ~"line1\nline2"); + assert!(r == ~"line1\nline2"); } #[test] fn should_unindent_multiple_paragraphs() { let s = ~" line1\n\n line2"; let r = unindent(s); - fail_unless!(r == ~"line1\n\nline2"); + assert!(r == ~"line1\n\nline2"); } #[test] @@ -114,7 +114,7 @@ fn should_leave_multiple_indent_levels() { // base indentation and should be preserved let s = ~" line1\n\n line2"; let r = unindent(s); - fail_unless!(r == ~"line1\n\n line2"); + assert!(r == ~"line1\n\n line2"); } #[test] @@ -126,12 +126,12 @@ fn should_ignore_first_line_indent() { // and continue here"] let s = ~"line1\n line2"; let r = unindent(s); - fail_unless!(r == ~"line1\nline2"); + assert!(r == ~"line1\nline2"); } #[test] fn should_not_ignore_first_line_indent_in_a_single_line_para() { let s = ~"line1\n\n line2"; let r = unindent(s); - fail_unless!(r == ~"line1\n\n line2"); + assert!(r == ~"line1\n\n line2"); } diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index f9dc13f198922..cd64061af0392 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -790,19 +790,19 @@ pub fn link_exe(src: &Path, dest: &Path) -> bool { #[test] fn test_is_cmd() { - fail_unless!(is_cmd(~"build")); - fail_unless!(is_cmd(~"clean")); - fail_unless!(is_cmd(~"do")); - fail_unless!(is_cmd(~"info")); - fail_unless!(is_cmd(~"install")); - fail_unless!(is_cmd(~"prefer")); - fail_unless!(is_cmd(~"test")); - fail_unless!(is_cmd(~"uninstall")); - fail_unless!(is_cmd(~"unprefer")); + assert!(is_cmd(~"build")); + assert!(is_cmd(~"clean")); + assert!(is_cmd(~"do")); + assert!(is_cmd(~"info")); + assert!(is_cmd(~"install")); + assert!(is_cmd(~"prefer")); + assert!(is_cmd(~"test")); + assert!(is_cmd(~"uninstall")); + assert!(is_cmd(~"unprefer")); } #[test] fn test_parse_name() { - fail_unless!(parse_name(~"org.mozilla.servo").get() == ~"servo"); - fail_unless!(parse_name(~"org. mozilla.servo 2131").is_err()); + assert!(parse_name(~"org.mozilla.servo").get() == ~"servo"); + assert!(parse_name(~"org. mozilla.servo 2131").is_err()); } diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index 02c50cc7c9858..ac8dd1a5d6523 100644 --- a/src/libstd/arc.rs +++ b/src/libstd/arc.rs @@ -44,7 +44,7 @@ pub impl<'self> Condvar<'self> { */ #[inline(always)] fn wait_on(&self, condvar_id: uint) { - fail_unless!(!*self.failed); + assert!(!*self.failed); self.cond.wait_on(condvar_id); // This is why we need to wrap sync::condvar. check_poison(self.is_mutex, *self.failed); @@ -60,7 +60,7 @@ pub impl<'self> Condvar<'self> { */ #[inline(always)] fn signal_on(&self, condvar_id: uint) -> bool { - fail_unless!(!*self.failed); + assert!(!*self.failed); self.cond.signal_on(condvar_id) } @@ -74,7 +74,7 @@ pub impl<'self> Condvar<'self> { */ #[inline(always)] fn broadcast_on(&self, condvar_id: uint) -> uint { - fail_unless!(!*self.failed); + assert!(!*self.failed); self.cond.broadcast_on(condvar_id) } } @@ -230,7 +230,7 @@ struct PoisonOnFail { impl Drop for PoisonOnFail { fn finalize(&self) { unsafe { - /* fail_unless!(!*self.failed); + /* assert!(!*self.failed); -- might be false in case of cond.wait() */ if task::failing() { *self.failed = true; @@ -392,7 +392,7 @@ pub impl RWARC { // of this cast is removing the mutability.) let new_data = unsafe { cast::transmute_immut(data) }; // Downgrade ensured the token belonged to us. Just a sanity check. - fail_unless!(ptr::ref_eq(&state.data, new_data)); + assert!(ptr::ref_eq(&state.data, new_data)); // Produce new token RWReadMode { data: new_data, @@ -505,13 +505,13 @@ mod tests { let arc_v = p.recv(); let v = *arc::get::<~[int]>(&arc_v); - fail_unless!(v[3] == 4); + assert!(v[3] == 4); }; let c = p.recv(); c.send(arc::clone(&arc_v)); - fail_unless!((*arc::get(&arc_v))[2] == 3); + assert!((*arc::get(&arc_v))[2] == 3); info!(arc_v); } @@ -532,7 +532,7 @@ mod tests { } do arc.access_cond |state, cond| { comm::send_one(c.take(), ()); - fail_unless!(!*state); + assert!(!*state); while !*state { cond.wait(); } @@ -549,7 +549,7 @@ mod tests { do arc2.access_cond |one, cond| { cond.signal(); // Parent should fail when it wakes up. - fail_unless!(*one == 0); + assert!(*one == 0); } } @@ -566,11 +566,11 @@ mod tests { let arc2 = ~arc.clone(); do task::try || { do arc2.access |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do arc.access |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[should_fail] #[ignore(cfg(windows))] @@ -579,11 +579,11 @@ mod tests { let arc2 = (*arc).clone(); do task::try || { do arc2.write |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do arc.read |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[should_fail] #[ignore(cfg(windows))] @@ -592,11 +592,11 @@ mod tests { let arc2 = (*arc).clone(); do task::try || { do arc2.write |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do arc.write |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[should_fail] #[ignore(cfg(windows))] @@ -606,12 +606,12 @@ mod tests { do task::try || { do arc2.write_downgrade |write_mode| { do (&write_mode).write |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } } }; do arc.write |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[ignore(cfg(windows))] @@ -620,11 +620,11 @@ mod tests { let arc2 = (*arc).clone(); do task::try || { do arc2.read |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do arc.read |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[ignore(cfg(windows))] @@ -633,11 +633,11 @@ mod tests { let arc2 = (*arc).clone(); do task::try || { do arc2.read |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } }; do arc.write |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] #[ignore(cfg(windows))] @@ -648,12 +648,12 @@ mod tests { do arc2.write_downgrade |write_mode| { let read_mode = arc2.downgrade(write_mode); do (&read_mode).read |one| { - fail_unless!(*one == 2); + assert!(*one == 2); } } }; do arc.write |one| { - fail_unless!(*one == 1); + assert!(*one == 1); } } #[test] @@ -681,7 +681,7 @@ mod tests { do task::task().future_result(|+r| children.push(r)).spawn || { do arc3.read |num| { - fail_unless!(*num >= 0); + assert!(*num >= 0); } } } @@ -691,7 +691,7 @@ mod tests { // Wait for writer to finish p.recv(); - do arc.read |num| { fail_unless!(*num == 10); } + do arc.read |num| { assert!(*num == 10); } } #[test] pub fn test_rw_downgrade() { @@ -712,7 +712,7 @@ mod tests { do task::spawn || { rp1.recv(); // wait for downgrader to give go-ahead do arcn.read |state| { - fail_unless!(*state == 31337); + assert!(*state == 31337); rc2.send(()); } } @@ -724,7 +724,7 @@ mod tests { do task::spawn || { wp1.recv(); do arc2.write_cond |state, cond| { - fail_unless!(*state == 0); + assert!(*state == 0); *state = 42; cond.signal(); } @@ -732,7 +732,7 @@ mod tests { do arc2.write |state| { // This shouldn't happen until after the downgrade read // section, and all other readers, finish. - fail_unless!(*state == 31337); + assert!(*state == 31337); *state = 42; } wc2.send(()); @@ -745,7 +745,7 @@ mod tests { while *state == 0 { cond.wait(); } - fail_unless!(*state == 42); + assert!(*state == 42); *state = 31337; // send to other readers for vec::each(reader_convos) |x| { @@ -763,7 +763,7 @@ mod tests { } } wc1.send(()); // tell writer to try again - fail_unless!(*state == 31337); + assert!(*state == 31337); } } diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index d3452712728b9..0266f2d8631cf 100644 --- a/src/libstd/base64.rs +++ b/src/libstd/base64.rs @@ -159,23 +159,23 @@ mod tests { #[test] pub fn test_to_base64() { - fail_unless!((~"").to_base64() == ~""); - fail_unless!((~"f").to_base64() == ~"Zg=="); - fail_unless!((~"fo").to_base64() == ~"Zm8="); - fail_unless!((~"foo").to_base64() == ~"Zm9v"); - fail_unless!((~"foob").to_base64() == ~"Zm9vYg=="); - fail_unless!((~"fooba").to_base64() == ~"Zm9vYmE="); - fail_unless!((~"foobar").to_base64() == ~"Zm9vYmFy"); + assert!((~"").to_base64() == ~""); + assert!((~"f").to_base64() == ~"Zg=="); + assert!((~"fo").to_base64() == ~"Zm8="); + assert!((~"foo").to_base64() == ~"Zm9v"); + assert!((~"foob").to_base64() == ~"Zm9vYg=="); + assert!((~"fooba").to_base64() == ~"Zm9vYmE="); + assert!((~"foobar").to_base64() == ~"Zm9vYmFy"); } #[test] pub fn test_from_base64() { - fail_unless!((~"").from_base64() == str::to_bytes(~"")); - fail_unless!((~"Zg==").from_base64() == str::to_bytes(~"f")); - fail_unless!((~"Zm8=").from_base64() == str::to_bytes(~"fo")); - fail_unless!((~"Zm9v").from_base64() == str::to_bytes(~"foo")); - fail_unless!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob")); - fail_unless!((~"Zm9vYmE=").from_base64() == str::to_bytes(~"fooba")); - fail_unless!((~"Zm9vYmFy").from_base64() == str::to_bytes(~"foobar")); + assert!((~"").from_base64() == str::to_bytes(~"")); + assert!((~"Zg==").from_base64() == str::to_bytes(~"f")); + assert!((~"Zm8=").from_base64() == str::to_bytes(~"fo")); + assert!((~"Zm9v").from_base64() == str::to_bytes(~"foo")); + assert!((~"Zm9vYg==").from_base64() == str::to_bytes(~"foob")); + assert!((~"Zm9vYmE=").from_base64() == str::to_bytes(~"fooba")); + assert!((~"Zm9vYmFy").from_base64() == str::to_bytes(~"foobar")); } } diff --git a/src/libstd/bigint.rs b/src/libstd/bigint.rs index 9671112bec01f..35b1a28a465cd 100644 --- a/src/libstd/bigint.rs +++ b/src/libstd/bigint.rs @@ -162,7 +162,7 @@ impl Sub for BigUint { lo }; - fail_unless!(borrow == 0); // <=> fail_unless!((self >= other)); + assert!(borrow == 0); // <=> assert!((self >= other)); return BigUint::new(diff); } } @@ -351,7 +351,7 @@ pub impl BigUint { n <<= 1; shift += 1; } - fail_unless!(shift < BigDigit::bits); + assert!(shift < BigDigit::bits); let (d, m) = divmod_inner(self << shift, other << shift); return (d, m >> shift); @@ -390,7 +390,7 @@ pub impl BigUint { for an.each_reverse |elt| { let ai = BigDigit::to_uint(carry, *elt); let di = ai / (bn as uint); - fail_unless!(di < BigDigit::base); + assert!(di < BigDigit::base); carry = (ai % (bn as uint)) as BigDigit; d = ~[di as BigDigit] + d; } @@ -434,7 +434,7 @@ pub impl BigUint { } fn to_str_radix(&self, radix: uint) -> ~str { - fail_unless!(1 < radix && radix <= 16); + assert!(1 < radix && radix <= 16); let (base, max_len) = get_radix_base(radix); if base == BigDigit::base { return fill_concat(self.data, radix, max_len) @@ -510,7 +510,7 @@ pub impl BigUint { #[cfg(target_arch = "x86_64")] priv fn get_radix_base(radix: uint) -> (uint, uint) { - fail_unless!(1 < radix && radix <= 16); + assert!(1 < radix && radix <= 16); match radix { 2 => (4294967296, 32), 3 => (3486784401, 20), @@ -535,7 +535,7 @@ priv fn get_radix_base(radix: uint) -> (uint, uint) { #[cfg(target_arch = "x86")] #[cfg(target_arch = "mips")] priv fn get_radix_base(radix: uint) -> (uint, uint) { - fail_unless!(1 < radix && radix <= 16); + assert!(1 < radix && radix <= 16); match radix { 2 => (65536, 16), 3 => (59049, 10), @@ -784,7 +784,7 @@ pub impl BigInt { if ss < os { return -1; } if ss > os { return 1; } - fail_unless!(ss == os); + assert!(ss == os); match ss { Zero => 0, Plus => self.data.cmp(&other.data), @@ -871,7 +871,7 @@ mod biguint_tests { #[test] fn test_from_slice() { fn check(slice: &[BigDigit], data: &[BigDigit]) { - fail_unless!(data == BigUint::from_slice(slice).data); + assert!(data == BigUint::from_slice(slice).data); } check(~[1], ~[1]); check(~[0, 0, 0], ~[]); @@ -889,30 +889,30 @@ mod biguint_tests { for vec::slice(data, i, data.len()).eachi |j0, nj| { let j = j0 + i; if i == j { - fail_unless!(ni.cmp(nj) == 0); - fail_unless!(nj.cmp(ni) == 0); - fail_unless!(ni == nj); - fail_unless!(!(ni != nj)); - fail_unless!(ni <= nj); - fail_unless!(ni >= nj); - fail_unless!(!(ni < nj)); - fail_unless!(!(ni > nj)); + assert!(ni.cmp(nj) == 0); + assert!(nj.cmp(ni) == 0); + assert!(ni == nj); + assert!(!(ni != nj)); + assert!(ni <= nj); + assert!(ni >= nj); + assert!(!(ni < nj)); + assert!(!(ni > nj)); } else { - fail_unless!(ni.cmp(nj) < 0); - fail_unless!(nj.cmp(ni) > 0); + assert!(ni.cmp(nj) < 0); + assert!(nj.cmp(ni) > 0); - fail_unless!(!(ni == nj)); - fail_unless!(ni != nj); + assert!(!(ni == nj)); + assert!(ni != nj); - fail_unless!(ni <= nj); - fail_unless!(!(ni >= nj)); - fail_unless!(ni < nj); - fail_unless!(!(ni > nj)); + assert!(ni <= nj); + assert!(!(ni >= nj)); + assert!(ni < nj); + assert!(!(ni > nj)); - fail_unless!(!(nj <= ni)); - fail_unless!(nj >= ni); - fail_unless!(!(nj < ni)); - fail_unless!(nj > ni); + assert!(!(nj <= ni)); + assert!(nj >= ni); + assert!(!(nj < ni)); + assert!(nj > ni); } } } @@ -921,7 +921,7 @@ mod biguint_tests { #[test] fn test_shl() { fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) { - fail_unless!(BigUint::new(v) << shift == BigUint::new(ans)); + assert!(BigUint::new(v) << shift == BigUint::new(ans)); } check(~[], 3, ~[]); @@ -966,7 +966,7 @@ mod biguint_tests { #[ignore(cfg(target_arch = "mips"))] fn test_shr() { fn check(v: ~[BigDigit], shift: uint, ans: ~[BigDigit]) { - fail_unless!(BigUint::new(v) >> shift == BigUint::new(ans)); + assert!(BigUint::new(v) >> shift == BigUint::new(ans)); } check(~[], 3, ~[]); @@ -1008,8 +1008,8 @@ mod biguint_tests { fn test_convert_int() { fn check(v: ~[BigDigit], i: int) { let b = BigUint::new(v); - fail_unless!(b == IntConvertible::from_int(i)); - fail_unless!(b.to_int() == i); + assert!(b == IntConvertible::from_int(i)); + assert!(b.to_int() == i); } check(~[], 0); @@ -1018,17 +1018,17 @@ mod biguint_tests { check(~[ 0, 1], ((uint::max_value >> BigDigit::bits) + 1) as int); check(~[-1, -1 >> 1], int::max_value); - fail_unless!(BigUint::new(~[0, -1]).to_int() == int::max_value); - fail_unless!(BigUint::new(~[0, 0, 1]).to_int() == int::max_value); - fail_unless!(BigUint::new(~[0, 0, -1]).to_int() == int::max_value); + assert!(BigUint::new(~[0, -1]).to_int() == int::max_value); + assert!(BigUint::new(~[0, 0, 1]).to_int() == int::max_value); + assert!(BigUint::new(~[0, 0, -1]).to_int() == int::max_value); } #[test] fn test_convert_uint() { fn check(v: ~[BigDigit], u: uint) { let b = BigUint::new(v); - fail_unless!(b == BigUint::from_uint(u)); - fail_unless!(b.to_uint() == u); + assert!(b == BigUint::from_uint(u)); + assert!(b.to_uint() == u); } check(~[], 0); @@ -1038,8 +1038,8 @@ mod biguint_tests { check(~[ 0, -1], uint::max_value << BigDigit::bits); check(~[-1, -1], uint::max_value); - fail_unless!(BigUint::new(~[0, 0, 1]).to_uint() == uint::max_value); - fail_unless!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value); + assert!(BigUint::new(~[0, 0, 1]).to_uint() == uint::max_value); + assert!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value); } static sum_triples: &'static [(&'static [BigDigit], @@ -1064,8 +1064,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - fail_unless!(a + b == c); - fail_unless!(b + a == c); + assert!(a + b == c); + assert!(b + a == c); } } @@ -1077,8 +1077,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - fail_unless!(c - a == b); - fail_unless!(c - b == a); + assert!(c - a == b); + assert!(c - b == a); } } @@ -1128,8 +1128,8 @@ mod biguint_tests { let b = BigUint::from_slice(bVec); let c = BigUint::from_slice(cVec); - fail_unless!(a * b == c); - fail_unless!(b * a == c); + assert!(a * b == c); + assert!(b * a == c); } for divmod_quadruples.each |elm| { @@ -1139,8 +1139,8 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); let d = BigUint::from_slice(dVec); - fail_unless!(a == b * c + d); - fail_unless!(a == c * b + d); + assert!(a == b * c + d); + assert!(a == c * b + d); } } @@ -1153,10 +1153,10 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); if a.is_not_zero() { - fail_unless!(c.divmod(&a) == (b, Zero::zero())); + assert!(c.divmod(&a) == (b, Zero::zero())); } if b.is_not_zero() { - fail_unless!(c.divmod(&b) == (a, Zero::zero())); + assert!(c.divmod(&b) == (a, Zero::zero())); } } @@ -1167,7 +1167,7 @@ mod biguint_tests { let c = BigUint::from_slice(cVec); let d = BigUint::from_slice(dVec); - if b.is_not_zero() { fail_unless!(a.divmod(&b) == (c, d)); } + if b.is_not_zero() { assert!(a.divmod(&b) == (c, d)); } } } @@ -1234,7 +1234,7 @@ mod biguint_tests { let &(n, rs) = num_pair; for rs.each |str_pair| { let &(radix, str) = str_pair; - fail_unless!(n.to_str_radix(radix) == str); + assert!(n.to_str_radix(radix) == str); } } } @@ -1245,13 +1245,13 @@ mod biguint_tests { let &(n, rs) = num_pair; for rs.each |str_pair| { let &(radix, str) = str_pair; - fail_unless!(Some(n) == BigUint::from_str_radix(str, radix)); + assert!(Some(n) == BigUint::from_str_radix(str, radix)); } } - fail_unless!(BigUint::from_str_radix(~"Z", 10) == None); - fail_unless!(BigUint::from_str_radix(~"_", 2) == None); - fail_unless!(BigUint::from_str_radix(~"-1", 10) == None); + assert!(BigUint::from_str_radix(~"Z", 10) == None); + assert!(BigUint::from_str_radix(~"_", 2) == None); + assert!(BigUint::from_str_radix(~"-1", 10) == None); } #[test] @@ -1269,7 +1269,7 @@ mod biguint_tests { let ans = match BigUint::from_str_radix(s, 10) { Some(x) => x, None => fail!() }; - fail_unless!(n == ans); + assert!(n == ans); } check(3, "6"); @@ -1291,7 +1291,7 @@ mod bigint_tests { fn check(inp_s: Sign, inp_n: uint, ans_s: Sign, ans_n: uint) { let inp = BigInt::from_biguint(inp_s, BigUint::from_uint(inp_n)); let ans = BigInt { sign: ans_s, data: BigUint::from_uint(ans_n)}; - fail_unless!(inp == ans); + assert!(inp == ans); } check(Plus, 1, Plus, 1); check(Plus, 0, Zero, 0); @@ -1311,30 +1311,30 @@ mod bigint_tests { for vec::slice(nums, i, nums.len()).eachi |j0, nj| { let j = i + j0; if i == j { - fail_unless!(ni.cmp(nj) == 0); - fail_unless!(nj.cmp(ni) == 0); - fail_unless!(ni == nj); - fail_unless!(!(ni != nj)); - fail_unless!(ni <= nj); - fail_unless!(ni >= nj); - fail_unless!(!(ni < nj)); - fail_unless!(!(ni > nj)); + assert!(ni.cmp(nj) == 0); + assert!(nj.cmp(ni) == 0); + assert!(ni == nj); + assert!(!(ni != nj)); + assert!(ni <= nj); + assert!(ni >= nj); + assert!(!(ni < nj)); + assert!(!(ni > nj)); } else { - fail_unless!(ni.cmp(nj) < 0); - fail_unless!(nj.cmp(ni) > 0); + assert!(ni.cmp(nj) < 0); + assert!(nj.cmp(ni) > 0); - fail_unless!(!(ni == nj)); - fail_unless!(ni != nj); + assert!(!(ni == nj)); + assert!(ni != nj); - fail_unless!(ni <= nj); - fail_unless!(!(ni >= nj)); - fail_unless!(ni < nj); - fail_unless!(!(ni > nj)); + assert!(ni <= nj); + assert!(!(ni >= nj)); + assert!(ni < nj); + assert!(!(ni > nj)); - fail_unless!(!(nj <= ni)); - fail_unless!(nj >= ni); - fail_unless!(!(nj < ni)); - fail_unless!(nj > ni); + assert!(!(nj <= ni)); + assert!(nj >= ni); + assert!(!(nj < ni)); + assert!(nj > ni); } } } @@ -1343,8 +1343,8 @@ mod bigint_tests { #[test] fn test_convert_int() { fn check(b: BigInt, i: int) { - fail_unless!(b == IntConvertible::from_int(i)); - fail_unless!(b.to_int() == i); + assert!(b == IntConvertible::from_int(i)); + assert!(b.to_int() == i); } check(Zero::zero(), 0); @@ -1353,20 +1353,20 @@ mod bigint_tests { Plus, BigUint::from_uint(int::max_value as uint) ), int::max_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Plus, BigUint::from_uint(int::max_value as uint + 1) ).to_int() == int::max_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Plus, BigUint::new(~[1, 2, 3]) ).to_int() == int::max_value); check(BigInt::from_biguint( Minus, BigUint::from_uint(-int::min_value as uint) ), int::min_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Minus, BigUint::from_uint(-int::min_value as uint + 1) ).to_int() == int::min_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Minus, BigUint::new(~[1, 2, 3]) ).to_int() == int::min_value); } @@ -1374,8 +1374,8 @@ mod bigint_tests { #[test] fn test_convert_uint() { fn check(b: BigInt, u: uint) { - fail_unless!(b == BigInt::from_uint(u)); - fail_unless!(b.to_uint() == u); + assert!(b == BigInt::from_uint(u)); + assert!(b.to_uint() == u); } check(Zero::zero(), 0); @@ -1384,14 +1384,14 @@ mod bigint_tests { check( BigInt::from_biguint(Plus, BigUint::from_uint(uint::max_value)), uint::max_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Plus, BigUint::new(~[1, 2, 3]) ).to_uint() == uint::max_value); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Minus, BigUint::from_uint(uint::max_value) ).to_uint() == 0); - fail_unless!(BigInt::from_biguint( + assert!(BigInt::from_biguint( Minus, BigUint::new(~[1, 2, 3]) ).to_uint() == 0); } @@ -1418,14 +1418,14 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - fail_unless!(a + b == c); - fail_unless!(b + a == c); - fail_unless!(c + (-a) == b); - fail_unless!(c + (-b) == a); - fail_unless!(a + (-c) == (-b)); - fail_unless!(b + (-c) == (-a)); - fail_unless!((-a) + (-b) == (-c)); - fail_unless!(a + (-a) == Zero::zero()); + assert!(a + b == c); + assert!(b + a == c); + assert!(c + (-a) == b); + assert!(c + (-b) == a); + assert!(a + (-c) == (-b)); + assert!(b + (-c) == (-a)); + assert!((-a) + (-b) == (-c)); + assert!(a + (-a) == Zero::zero()); } } @@ -1437,14 +1437,14 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - fail_unless!(c - a == b); - fail_unless!(c - b == a); - fail_unless!((-b) - a == (-c)); - fail_unless!((-a) - b == (-c)); - fail_unless!(b - (-a) == c); - fail_unless!(a - (-b) == c); - fail_unless!((-c) - (-a) == (-b)); - fail_unless!(a - a == Zero::zero()); + assert!(c - a == b); + assert!(c - b == a); + assert!((-b) - a == (-c)); + assert!((-a) - b == (-c)); + assert!(b - (-a) == c); + assert!(a - (-b) == c); + assert!((-c) - (-a) == (-b)); + assert!(a - a == Zero::zero()); } } @@ -1494,11 +1494,11 @@ mod bigint_tests { let b = BigInt::from_slice(Plus, bVec); let c = BigInt::from_slice(Plus, cVec); - fail_unless!(a * b == c); - fail_unless!(b * a == c); + assert!(a * b == c); + assert!(b * a == c); - fail_unless!((-a) * b == -c); - fail_unless!((-b) * a == -c); + assert!((-a) * b == -c); + assert!((-b) * a == -c); } for divmod_quadruples.each |elm| { @@ -1508,8 +1508,8 @@ mod bigint_tests { let c = BigInt::from_slice(Plus, cVec); let d = BigInt::from_slice(Plus, dVec); - fail_unless!(a == b * c + d); - fail_unless!(a == c * b + d); + assert!(a == b * c + d); + assert!(a == c * b + d); } } @@ -1518,12 +1518,12 @@ mod bigint_tests { fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) { let (d, m) = a.divmod(b); if m.is_not_zero() { - fail_unless!(m.sign == b.sign); + assert!(m.sign == b.sign); } - fail_unless!(m.abs() <= b.abs()); - fail_unless!(*a == b * d + m); - fail_unless!(d == *ans_d); - fail_unless!(m == *ans_m); + assert!(m.abs() <= b.abs()); + assert!(*a == b * d + m); + assert!(d == *ans_d); + assert!(m == *ans_m); } fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) { @@ -1569,12 +1569,12 @@ mod bigint_tests { fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) { let (q, r) = a.quotrem(b); if r.is_not_zero() { - fail_unless!(r.sign == a.sign); + assert!(r.sign == a.sign); } - fail_unless!(r.abs() <= b.abs()); - fail_unless!(*a == b * q + r); - fail_unless!(q == *ans_q); - fail_unless!(r == *ans_r); + assert!(r.abs() <= b.abs()); + assert!(*a == b * q + r); + assert!(q == *ans_q); + assert!(r == *ans_r); } fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) { @@ -1609,7 +1609,7 @@ mod bigint_tests { #[test] fn test_to_str_radix() { fn check(n: int, ans: &str) { - fail_unless!(ans == IntConvertible::from_int::( + assert!(ans == IntConvertible::from_int::( n).to_str_radix(10)); } check(10, "10"); @@ -1624,7 +1624,7 @@ mod bigint_tests { fn test_from_str_radix() { fn check(s: &str, ans: Option) { let ans = ans.map(|&n| IntConvertible::from_int(n)); - fail_unless!(BigInt::from_str_radix(s, 10) == ans); + assert!(BigInt::from_str_radix(s, 10) == ans); } check("10", Some(10)); check("1", Some(1)); @@ -1637,11 +1637,11 @@ mod bigint_tests { #[test] fn test_neg() { - fail_unless!(-BigInt::new(Plus, ~[1, 1, 1]) == + assert!(-BigInt::new(Plus, ~[1, 1, 1]) == BigInt::new(Minus, ~[1, 1, 1])); - fail_unless!(-BigInt::new(Minus, ~[1, 1, 1]) == + assert!(-BigInt::new(Minus, ~[1, 1, 1]) == BigInt::new(Plus, ~[1, 1, 1])); - fail_unless!(-Zero::zero::() == Zero::zero::()); + assert!(-Zero::zero::() == Zero::zero::()); } } diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index 8bac0fed3c925..f69e2130e7141 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -132,7 +132,7 @@ pub impl BigBitv { fn process(&mut self, b: &BigBitv, nbits: uint, op: &fn(uint, uint) -> uint) -> bool { let len = b.storage.len(); - fail_unless!((self.storage.len() == len)); + assert!((self.storage.len() == len)); let mut changed = false; for uint::range(0, len) |i| { let mask = big_mask(nbits, i); @@ -300,7 +300,7 @@ pub impl Bitv { /// Retrieve the value at index `i` #[inline(always)] fn get(&self, i: uint) -> bool { - fail_unless!((i < self.nbits)); + assert!((i < self.nbits)); match self.rep { Big(ref b) => b.get(i), Small(ref s) => s.get(i) @@ -314,7 +314,7 @@ pub impl Bitv { */ #[inline(always)] fn set(&mut self, i: uint, x: bool) { - fail_unless!((i < self.nbits)); + assert!((i < self.nbits)); match self.rep { Big(ref mut b) => b.set(i, x), Small(ref mut s) => s.set(i, x) @@ -484,7 +484,7 @@ pub impl Bitv { * the bitvector and vector must have the same length */ fn eq_vec(&self, v: ~[uint]) -> bool { - fail_unless!(self.nbits == v.len()); + assert!(self.nbits == v.len()); let mut i = 0; while i < self.nbits { let w0 = self.get(i); @@ -725,7 +725,7 @@ impl Set for BitvSet { let nbits = self.capacity(); if value >= nbits { let newsize = uint::max(value, nbits * 2) / uint::bits + 1; - fail_unless!(newsize > self.bitv.storage.len()); + assert!(newsize > self.bitv.storage.len()); self.bitv.storage.grow(newsize, &0); } self.size += 1; @@ -884,10 +884,10 @@ mod tests { #[test] pub fn test_to_str() { let zerolen = Bitv::new(0u, false); - fail_unless!(zerolen.to_str() == ~""); + assert!(zerolen.to_str() == ~""); let eightbits = Bitv::new(8u, false); - fail_unless!(eightbits.to_str() == ~"00000000"); + assert!(eightbits.to_str() == ~"00000000"); } #[test] @@ -896,16 +896,16 @@ mod tests { let mut exp; act = Bitv::new(0u, false); exp = vec::from_elem::(0u, 0u); - fail_unless!(act.eq_vec(exp)); + assert!(act.eq_vec(exp)); } #[test] pub fn test_1_element() { let mut act; act = Bitv::new(1u, false); - fail_unless!(act.eq_vec(~[0u])); + assert!(act.eq_vec(~[0u])); act = Bitv::new(1u, true); - fail_unless!(act.eq_vec(~[1u])); + assert!(act.eq_vec(~[1u])); } #[test] @@ -913,7 +913,7 @@ mod tests { let mut b = bitv::Bitv::new(2, false); b.set(0, true); b.set(1, false); - fail_unless!(b.to_str() == ~"10"); + assert!(b.to_str() == ~"10"); } #[test] @@ -922,11 +922,11 @@ mod tests { // all 0 act = Bitv::new(10u, false); - fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]))); + assert!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u]))); // all 1 act = Bitv::new(10u, true); - fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]))); + assert!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u]))); // mixed act = Bitv::new(10u, false); @@ -935,7 +935,7 @@ mod tests { act.set(2u, true); act.set(3u, true); act.set(4u, true); - fail_unless!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]))); + assert!((act.eq_vec(~[1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u]))); // mixed act = Bitv::new(10u, false); @@ -944,7 +944,7 @@ mod tests { act.set(7u, true); act.set(8u, true); act.set(9u, true); - fail_unless!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]))); + assert!((act.eq_vec(~[0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u]))); // mixed act = Bitv::new(10u, false); @@ -952,7 +952,7 @@ mod tests { act.set(3u, true); act.set(6u, true); act.set(9u, true); - fail_unless!((act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]))); + assert!((act.eq_vec(~[1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u]))); } #[test] @@ -961,14 +961,14 @@ mod tests { // all 0 act = Bitv::new(31u, false); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); // all 1 act = Bitv::new(31u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); @@ -983,7 +983,7 @@ mod tests { act.set(5u, true); act.set(6u, true); act.set(7u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -998,7 +998,7 @@ mod tests { act.set(21u, true); act.set(22u, true); act.set(23u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -1012,7 +1012,7 @@ mod tests { act.set(28u, true); act.set(29u, true); act.set(30u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); @@ -1022,7 +1022,7 @@ mod tests { act.set(3u, true); act.set(17u, true); act.set(30u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u])); @@ -1034,14 +1034,14 @@ mod tests { // all 0 act = Bitv::new(32u, false); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); // all 1 act = Bitv::new(32u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); @@ -1056,7 +1056,7 @@ mod tests { act.set(5u, true); act.set(6u, true); act.set(7u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -1071,7 +1071,7 @@ mod tests { act.set(21u, true); act.set(22u, true); act.set(23u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -1086,7 +1086,7 @@ mod tests { act.set(29u, true); act.set(30u, true); act.set(31u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); @@ -1097,7 +1097,7 @@ mod tests { act.set(17u, true); act.set(30u, true); act.set(31u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u])); @@ -1109,14 +1109,14 @@ mod tests { // all 0 act = Bitv::new(33u, false); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); // all 1 act = Bitv::new(33u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u])); @@ -1131,7 +1131,7 @@ mod tests { act.set(5u, true); act.set(6u, true); act.set(7u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -1146,7 +1146,7 @@ mod tests { act.set(21u, true); act.set(22u, true); act.set(23u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u])); @@ -1161,7 +1161,7 @@ mod tests { act.set(29u, true); act.set(30u, true); act.set(31u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 0u])); @@ -1173,7 +1173,7 @@ mod tests { act.set(30u, true); act.set(31u, true); act.set(32u, true); - fail_unless!(act.eq_vec( + assert!(act.eq_vec( ~[0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u])); @@ -1183,14 +1183,14 @@ mod tests { pub fn test_equal_differing_sizes() { let v0 = Bitv::new(10u, false); let v1 = Bitv::new(11u, false); - fail_unless!(!v0.equal(&v1)); + assert!(!v0.equal(&v1)); } #[test] pub fn test_equal_greatly_differing_sizes() { let v0 = Bitv::new(10u, false); let v1 = Bitv::new(110u, false); - fail_unless!(!v0.equal(&v1)); + assert!(!v0.equal(&v1)); } #[test] @@ -1201,7 +1201,7 @@ mod tests { let mut b = bitv::Bitv::new(1, true); b.set(0, true); - fail_unless!(a.equal(&b)); + assert!(a.equal(&b)); } #[test] @@ -1216,38 +1216,38 @@ mod tests { b.set(i, true); } - fail_unless!(a.equal(&b)); + assert!(a.equal(&b)); } #[test] pub fn test_from_bytes() { let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]); let str = ~"10110110" + ~"00000000" + ~"11111111"; - fail_unless!(bitv.to_str() == str); + assert!(bitv.to_str() == str); } #[test] pub fn test_to_bytes() { let mut bv = Bitv::new(3, true); bv.set(1, false); - fail_unless!(bv.to_bytes() == ~[0b10100000]); + assert!(bv.to_bytes() == ~[0b10100000]); let mut bv = Bitv::new(9, false); bv.set(2, true); bv.set(8, true); - fail_unless!(bv.to_bytes() == ~[0b00100000, 0b10000000]); + assert!(bv.to_bytes() == ~[0b00100000, 0b10000000]); } #[test] pub fn test_from_bools() { - fail_unless!(from_bools([true, false, true, true]).to_str() == + assert!(from_bools([true, false, true, true]).to_str() == ~"1011"); } #[test] pub fn test_to_bools() { let bools = ~[false, false, true, false, false, true, true, false]; - fail_unless!(from_bytes([0b00100110]).to_bools() == bools); + assert!(from_bytes([0b00100110]).to_bools() == bools); } #[test] @@ -1258,10 +1258,10 @@ mod tests { b1.set(1, true); b2.set(1, true); b2.set(2, true); - fail_unless!(b1.difference(&b2)); - fail_unless!(b1[0]); - fail_unless!(!b1[1]); - fail_unless!(!b1[2]); + assert!(b1.difference(&b2)); + assert!(b1[0]); + assert!(!b1[1]); + assert!(!b1[2]); } #[test] @@ -1272,10 +1272,10 @@ mod tests { b1.set(40, true); b2.set(40, true); b2.set(80, true); - fail_unless!(b1.difference(&b2)); - fail_unless!(b1[0]); - fail_unless!(!b1[40]); - fail_unless!(!b1[80]); + assert!(b1.difference(&b2)); + assert!(b1[0]); + assert!(!b1[40]); + assert!(!b1[80]); } #[test] @@ -1299,13 +1299,13 @@ mod tests { #[test] pub fn test_bitv_set_basic() { let mut b = BitvSet::new(); - fail_unless!(b.insert(3)); - fail_unless!(!b.insert(3)); - fail_unless!(b.contains(&3)); - fail_unless!(b.insert(400)); - fail_unless!(!b.insert(400)); - fail_unless!(b.contains(&400)); - fail_unless!(b.len() == 2); + assert!(b.insert(3)); + assert!(!b.insert(3)); + assert!(b.contains(&3)); + assert!(b.insert(400)); + assert!(!b.insert(400)); + assert!(b.contains(&400)); + assert!(b.len() == 2); } #[test] @@ -1313,26 +1313,26 @@ mod tests { let mut a = BitvSet::new(); let mut b = BitvSet::new(); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(77)); - fail_unless!(a.insert(103)); - fail_unless!(a.insert(5)); + assert!(a.insert(11)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(77)); + assert!(a.insert(103)); + assert!(a.insert(5)); - fail_unless!(b.insert(2)); - fail_unless!(b.insert(11)); - fail_unless!(b.insert(77)); - fail_unless!(b.insert(5)); - fail_unless!(b.insert(3)); + assert!(b.insert(2)); + assert!(b.insert(11)); + assert!(b.insert(77)); + assert!(b.insert(5)); + assert!(b.insert(3)); let mut i = 0; let expected = [3, 5, 11, 77]; for a.intersection(&b) |x| { - fail_unless!(*x == expected[i]); + assert!(*x == expected[i]); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] @@ -1340,22 +1340,22 @@ mod tests { let mut a = BitvSet::new(); let mut b = BitvSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(200)); - fail_unless!(a.insert(500)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(200)); + assert!(a.insert(500)); - fail_unless!(b.insert(3)); - fail_unless!(b.insert(200)); + assert!(b.insert(3)); + assert!(b.insert(200)); let mut i = 0; let expected = [1, 5, 500]; for a.difference(&b) |x| { - fail_unless!(*x == expected[i]); + assert!(*x == expected[i]); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] @@ -1363,67 +1363,67 @@ mod tests { let mut a = BitvSet::new(); let mut b = BitvSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(9)); - fail_unless!(a.insert(11)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(9)); + assert!(a.insert(11)); - fail_unless!(b.insert(3)); - fail_unless!(b.insert(9)); - fail_unless!(b.insert(14)); - fail_unless!(b.insert(220)); + assert!(b.insert(3)); + assert!(b.insert(9)); + assert!(b.insert(14)); + assert!(b.insert(220)); let mut i = 0; let expected = [1, 5, 11, 14, 220]; for a.symmetric_difference(&b) |x| { - fail_unless!(*x == expected[i]); + assert!(*x == expected[i]); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] pub fn test_bitv_set_union() { let mut a = BitvSet::new(); let mut b = BitvSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.insert(3)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(9)); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(160)); - fail_unless!(a.insert(19)); - fail_unless!(a.insert(24)); - - fail_unless!(b.insert(1)); - fail_unless!(b.insert(5)); - fail_unless!(b.insert(9)); - fail_unless!(b.insert(13)); - fail_unless!(b.insert(19)); + assert!(a.insert(1)); + assert!(a.insert(3)); + assert!(a.insert(5)); + assert!(a.insert(9)); + assert!(a.insert(11)); + assert!(a.insert(160)); + assert!(a.insert(19)); + assert!(a.insert(24)); + + assert!(b.insert(1)); + assert!(b.insert(5)); + assert!(b.insert(9)); + assert!(b.insert(13)); + assert!(b.insert(19)); let mut i = 0; let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160]; for a.union(&b) |x| { - fail_unless!(*x == expected[i]); + assert!(*x == expected[i]); i += 1 } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] pub fn test_bitv_remove() { let mut a = BitvSet::new(); - fail_unless!(a.insert(1)); - fail_unless!(a.remove(&1)); + assert!(a.insert(1)); + assert!(a.remove(&1)); - fail_unless!(a.insert(100)); - fail_unless!(a.remove(&100)); + assert!(a.insert(100)); + assert!(a.remove(&100)); - fail_unless!(a.insert(1000)); - fail_unless!(a.remove(&1000)); - fail_unless!(a.capacity() == uint::bits); + assert!(a.insert(1000)); + assert!(a.remove(&1000)); + assert!(a.capacity() == uint::bits); } fn rng() -> @rand::Rng { diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 1787be75e24d2..113c8130349ff 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -122,7 +122,7 @@ pub unsafe fn c_vec_with_dtor(base: *mut T, len: uint, dtor: @fn()) * Fails if `ofs` is greater or equal to the length of the vector */ pub fn get(t: CVec, ofs: uint) -> T { - fail_unless!(ofs < len(t)); + assert!(ofs < len(t)); return unsafe { *ptr::mut_offset(t.base, ofs) }; } @@ -132,7 +132,7 @@ pub fn get(t: CVec, ofs: uint) -> T { * Fails if `ofs` is greater or equal to the length of the vector */ pub fn set(t: CVec, ofs: uint, v: T) { - fail_unless!(ofs < len(t)); + assert!(ofs < len(t)); unsafe { *ptr::mut_offset(t.base, ofs) = v }; } @@ -159,7 +159,7 @@ mod tests { unsafe { let mem = libc::malloc(n); - fail_unless!(mem as int != 0); + assert!(mem as int != 0); return unsafe { c_vec_with_dtor(mem as *mut u8, n as uint, || unsafe { free(mem) }) }; @@ -172,9 +172,9 @@ mod tests { set(cv, 3u, 8u8); set(cv, 4u, 9u8); - fail_unless!(get(cv, 3u) == 8u8); - fail_unless!(get(cv, 4u) == 9u8); - fail_unless!(len(cv) == 16u); + assert!(get(cv, 3u) == 8u8); + assert!(get(cv, 4u) == 9u8); + assert!(len(cv) == 16u); } #[test] @@ -202,7 +202,7 @@ mod tests { set(cv, 0u, 32u8); set(cv, 1u, 33u8); - fail_unless!(unsafe { *p } == 32u8); + assert!(unsafe { *p } == 32u8); set(cv, 2u, 34u8); /* safety */ } diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs index 93a2f4e2acc74..5d7f64a7c8fa0 100644 --- a/src/libstd/cmp.rs +++ b/src/libstd/cmp.rs @@ -53,15 +53,15 @@ impl FuzzyEq for f64 { #[test] fn test_fuzzy_equals() { - fail_unless!((&1.0f).fuzzy_eq(&1.0)); - fail_unless!((&1.0f32).fuzzy_eq(&1.0f32)); - fail_unless!((&1.0f64).fuzzy_eq(&1.0f64)); + assert!((&1.0f).fuzzy_eq(&1.0)); + assert!((&1.0f32).fuzzy_eq(&1.0f32)); + assert!((&1.0f64).fuzzy_eq(&1.0f64)); } #[test] fn test_fuzzy_eq_eps() { - fail_unless!((&1.2f).fuzzy_eq_eps(&0.9, &0.5)); - fail_unless!(!(&1.5f).fuzzy_eq_eps(&0.9, &0.5)); + assert!((&1.2f).fuzzy_eq_eps(&0.9, &0.5)); + assert!(!(&1.5f).fuzzy_eq_eps(&0.9, &0.5)); } #[test] @@ -87,16 +87,16 @@ mod test_complex{ let a = Complex {r: 0.9, i: 0.9}; let b = Complex {r: 0.9, i: 0.9}; - fail_unless!((a.fuzzy_eq(&b))); + assert!((a.fuzzy_eq(&b))); } #[test] fn test_fuzzy_eq_eps() { let other = Complex {r: 0.9, i: 0.9}; - fail_unless!((&Complex {r: 0.9, i: 1.2}).fuzzy_eq_eps(&other, &0.5)); - fail_unless!((&Complex {r: 1.2, i: 0.9}).fuzzy_eq_eps(&other, &0.5)); - fail_unless!(!(&Complex {r: 0.9, i: 1.5}).fuzzy_eq_eps(&other, &0.5)); - fail_unless!(!(&Complex {r: 1.5, i: 0.9}).fuzzy_eq_eps(&other, &0.5)); + assert!((&Complex {r: 0.9, i: 1.2}).fuzzy_eq_eps(&other, &0.5)); + assert!((&Complex {r: 1.2, i: 0.9}).fuzzy_eq_eps(&other, &0.5)); + assert!(!(&Complex {r: 0.9, i: 1.5}).fuzzy_eq_eps(&other, &0.5)); + assert!(!(&Complex {r: 1.5, i: 0.9}).fuzzy_eq_eps(&other, &0.5)); } } diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs index 9f68c6762228d..0e0347406aecf 100644 --- a/src/libstd/comm.rs +++ b/src/libstd/comm.rs @@ -105,7 +105,7 @@ mod test { left.send(~"abc"); right.send(123); - fail_unless!(left.recv() == 123); - fail_unless!(right.recv() == ~"abc"); + assert!(left.recv() == 123); + assert!(right.recv() == ~"abc"); } } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 72b68f8fe3aff..e029b882472f0 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -120,7 +120,7 @@ pub impl Deque { /// Grow is only called on full elts, so nelts is also len(elts), unlike /// elsewhere. fn grow(nelts: uint, lo: uint, elts: &mut [Option]) -> ~[Option] { - fail_unless!(nelts == elts.len()); + assert!(nelts == elts.len()); let mut rv = ~[]; do rv.grow_fn(nelts + 1) |i| { @@ -145,46 +145,46 @@ mod tests { #[test] fn test_simple() { let mut d = Deque::new(); - fail_unless!(d.len() == 0u); + assert!(d.len() == 0u); d.add_front(17); d.add_front(42); d.add_back(137); - fail_unless!(d.len() == 3u); + assert!(d.len() == 3u); d.add_back(137); - fail_unless!(d.len() == 4u); + assert!(d.len() == 4u); debug!(d.peek_front()); - fail_unless!(*d.peek_front() == 42); + assert!(*d.peek_front() == 42); debug!(d.peek_back()); - fail_unless!(*d.peek_back() == 137); + assert!(*d.peek_back() == 137); let mut i: int = d.pop_front(); debug!(i); - fail_unless!(i == 42); + assert!(i == 42); i = d.pop_back(); debug!(i); - fail_unless!(i == 137); + assert!(i == 137); i = d.pop_back(); debug!(i); - fail_unless!(i == 137); + assert!(i == 137); i = d.pop_back(); debug!(i); - fail_unless!(i == 17); - fail_unless!(d.len() == 0u); + assert!(i == 17); + assert!(d.len() == 0u); d.add_back(3); - fail_unless!(d.len() == 1u); + assert!(d.len() == 1u); d.add_front(2); - fail_unless!(d.len() == 2u); + assert!(d.len() == 2u); d.add_back(4); - fail_unless!(d.len() == 3u); + assert!(d.len() == 3u); d.add_front(1); - fail_unless!(d.len() == 4u); + assert!(d.len() == 4u); debug!(d.get(0)); debug!(d.get(1)); debug!(d.get(2)); debug!(d.get(3)); - fail_unless!(*d.get(0) == 1); - fail_unless!(*d.get(1) == 2); - fail_unless!(*d.get(2) == 3); - fail_unless!(*d.get(3) == 4); + assert!(*d.get(0) == 1); + assert!(*d.get(1) == 2); + assert!(*d.get(2) == 3); + assert!(*d.get(3) == 4); } #[test] @@ -195,62 +195,62 @@ mod tests { let d: @int = @175; let mut deq = Deque::new(); - fail_unless!(deq.len() == 0); + assert!(deq.len() == 0); deq.add_front(a); deq.add_front(b); deq.add_back(c); - fail_unless!(deq.len() == 3); + assert!(deq.len() == 3); deq.add_back(d); - fail_unless!(deq.len() == 4); - fail_unless!(*deq.peek_front() == b); - fail_unless!(*deq.peek_back() == d); - fail_unless!(deq.pop_front() == b); - fail_unless!(deq.pop_back() == d); - fail_unless!(deq.pop_back() == c); - fail_unless!(deq.pop_back() == a); - fail_unless!(deq.len() == 0); + assert!(deq.len() == 4); + assert!(*deq.peek_front() == b); + assert!(*deq.peek_back() == d); + assert!(deq.pop_front() == b); + assert!(deq.pop_back() == d); + assert!(deq.pop_back() == c); + assert!(deq.pop_back() == a); + assert!(deq.len() == 0); deq.add_back(c); - fail_unless!(deq.len() == 1); + assert!(deq.len() == 1); deq.add_front(b); - fail_unless!(deq.len() == 2); + assert!(deq.len() == 2); deq.add_back(d); - fail_unless!(deq.len() == 3); + assert!(deq.len() == 3); deq.add_front(a); - fail_unless!(deq.len() == 4); - fail_unless!(*deq.get(0) == a); - fail_unless!(*deq.get(1) == b); - fail_unless!(*deq.get(2) == c); - fail_unless!(*deq.get(3) == d); + assert!(deq.len() == 4); + assert!(*deq.get(0) == a); + assert!(*deq.get(1) == b); + assert!(*deq.get(2) == c); + assert!(*deq.get(3) == d); } fn test_parameterized(a: T, b: T, c: T, d: T) { let mut deq = Deque::new(); - fail_unless!(deq.len() == 0); + assert!(deq.len() == 0); deq.add_front(a); deq.add_front(b); deq.add_back(c); - fail_unless!(deq.len() == 3); + assert!(deq.len() == 3); deq.add_back(d); - fail_unless!(deq.len() == 4); - fail_unless!(*deq.peek_front() == b); - fail_unless!(*deq.peek_back() == d); - fail_unless!(deq.pop_front() == b); - fail_unless!(deq.pop_back() == d); - fail_unless!(deq.pop_back() == c); - fail_unless!(deq.pop_back() == a); - fail_unless!(deq.len() == 0); + assert!(deq.len() == 4); + assert!(*deq.peek_front() == b); + assert!(*deq.peek_back() == d); + assert!(deq.pop_front() == b); + assert!(deq.pop_back() == d); + assert!(deq.pop_back() == c); + assert!(deq.pop_back() == a); + assert!(deq.len() == 0); deq.add_back(c); - fail_unless!(deq.len() == 1); + assert!(deq.len() == 1); deq.add_front(b); - fail_unless!(deq.len() == 2); + assert!(deq.len() == 2); deq.add_back(d); - fail_unless!(deq.len() == 3); + assert!(deq.len() == 3); deq.add_front(a); - fail_unless!(deq.len() == 4); - fail_unless!(*deq.get(0) == a); - fail_unless!(*deq.get(1) == b); - fail_unless!(*deq.get(2) == c); - fail_unless!(*deq.get(3) == d); + assert!(deq.len() == 4); + assert!(*deq.get(0) == a); + assert!(*deq.get(1) == b); + assert!(*deq.get(2) == c); + assert!(*deq.get(3) == d); } #[deriving(Eq)] diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 484220776c3d5..bc9fc3553fe2f 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -179,22 +179,22 @@ pub mod reader { pub fn doc_as_str(d: Doc) -> ~str { str::from_bytes(doc_data(d)) } pub fn doc_as_u8(d: Doc) -> u8 { - fail_unless!(d.end == d.start + 1u); + assert!(d.end == d.start + 1u); (*d.data)[d.start] } pub fn doc_as_u16(d: Doc) -> u16 { - fail_unless!(d.end == d.start + 2u); + assert!(d.end == d.start + 2u); io::u64_from_be_bytes(*d.data, d.start, 2u) as u16 } pub fn doc_as_u32(d: Doc) -> u32 { - fail_unless!(d.end == d.start + 4u); + assert!(d.end == d.start + 4u); io::u64_from_be_bytes(*d.data, d.start, 4u) as u32 } pub fn doc_as_u64(d: Doc) -> u64 { - fail_unless!(d.end == d.start + 8u); + assert!(d.end == d.start + 8u); io::u64_from_be_bytes(*d.data, d.start, 8u) } @@ -559,7 +559,7 @@ pub mod writer { priv impl Encoder { // used internally to emit things like the vector length and so on fn _emit_tagged_uint(&self, t: EbmlEncoderTag, v: uint) { - fail_unless!(v <= 0xFFFF_FFFF_u); + assert!(v <= 0xFFFF_FFFF_u); self.wr_tagged_u32(t as uint, v as u32); } @@ -713,7 +713,7 @@ mod tests { let deser = reader::Decoder(ebml_doc); let v1 = serialize::Decodable::decode(&deser); debug!("v1 == %?", v1); - fail_unless!(v == v1); + assert!(v == v1); } test_v(Some(22)); diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs index ab6844b80fff9..74e7ad9dc3f6d 100644 --- a/src/libstd/flatpipes.rs +++ b/src/libstd/flatpipes.rs @@ -358,8 +358,8 @@ pub mod flatteners { impl Unflattener for PodUnflattener { fn unflatten(&self, buf: ~[u8]) -> T { - fail_unless!(size_of::() != 0); - fail_unless!(size_of::() == buf.len()); + assert!(size_of::() != 0); + assert!(size_of::() == buf.len()); let addr_of_init: &u8 = unsafe { &*vec::raw::to_ptr(buf) }; let addr_of_value: &T = unsafe { cast::transmute(addr_of_init) }; copy *addr_of_value @@ -368,7 +368,7 @@ pub mod flatteners { impl Flattener for PodFlattener { fn flatten(&self, val: T) -> ~[u8] { - fail_unless!(size_of::() != 0); + assert!(size_of::() != 0); let val: *T = ptr::to_unsafe_ptr(&val); let byte_value = val as *u8; unsafe { vec::from_buf(byte_value, size_of::()) } @@ -519,11 +519,11 @@ pub mod bytepipes { let mut left = count; let mut bytes = ~[]; while !self.reader.eof() && left > 0 { - fail_unless!(left <= count); - fail_unless!(left > 0); + assert!(left <= count); + assert!(left > 0); let new_bytes = self.reader.read_bytes(left); bytes.push_all(new_bytes); - fail_unless!(new_bytes.len() <= left); + assert!(new_bytes.len() <= left); left -= new_bytes.len(); } @@ -576,7 +576,7 @@ pub mod bytepipes { return Some(bytes); } else if vec::uniq_len(&const self.buf) > 0 { let mut bytes = ::core::util::replace(&mut self.buf, ~[]); - fail_unless!(count > bytes.len()); + assert!(count > bytes.len()); match self.try_recv(count - bytes.len()) { Some(rest) => { bytes.push_all(rest); @@ -587,7 +587,7 @@ pub mod bytepipes { } else if vec::uniq_len(&const self.buf) == 0 { match self.port.try_recv() { Some(buf) => { - fail_unless!(!buf.is_empty()); + assert!(!buf.is_empty()); self.buf = buf; return self.try_recv(count); } @@ -655,7 +655,7 @@ mod test { let port = serial::reader_port(reader); let res: int = port.recv(); - fail_unless!(res == 10i); + assert!(res == 10i); } #[test] @@ -669,7 +669,7 @@ mod test { } for int::range(0, 10) |i| { - fail_unless!(i == port.recv()) + assert!(i == port.recv()) } } @@ -684,7 +684,7 @@ mod test { } for int::range(0, 10) |i| { - fail_unless!(@i == port.recv()) + assert!(@i == port.recv()) } } @@ -701,7 +701,7 @@ mod test { let port = pod::reader_port(reader); let res: int = port.recv(); - fail_unless!(res == 10); + assert!(res == 10); } #[test] @@ -715,7 +715,7 @@ mod test { } for int::range(0, 10) |i| { - fail_unless!(i == port.recv()) + assert!(i == port.recv()) } } @@ -799,7 +799,7 @@ mod test { kill_ch.send(None) }; - fail_unless!(listen_res.is_ok()); + assert!(listen_res.is_ok()); } // Client task @@ -812,7 +812,7 @@ mod test { debug!("connecting"); let iotask = &uv::global_loop::get(); let connect_result = tcp::connect(copy addr, port, iotask); - fail_unless!(connect_result.is_ok()); + assert!(connect_result.is_ok()); let sock = result::unwrap(connect_result); let socket_buf: tcp::TcpSocketBuf = tcp::socket_buf(sock); @@ -833,7 +833,7 @@ mod test { debug!("accepting connection"); let accept_result = tcp::accept(conn); debug!("accepted"); - fail_unless!(accept_result.is_ok()); + assert!(accept_result.is_ok()); let sock = result::unwrap(accept_result); res_chan.send(()); @@ -845,7 +845,7 @@ mod test { for int::range(0, 10) |i| { let j = port.recv(); debug!("receieved %?", j); - fail_unless!(i == j); + assert!(i == j); } // The test is over! @@ -891,7 +891,7 @@ mod test { let bytes = ~[]; let port = loader(bytes); let res: Option = port.try_recv(); - fail_unless!(res.is_none()); + assert!(res.is_none()); } #[test] @@ -908,7 +908,7 @@ mod test { let bytes = ~[0]; let port = loader(bytes); let res: Option = port.try_recv(); - fail_unless!(res.is_none()); + assert!(res.is_none()); } #[test] @@ -926,7 +926,7 @@ mod test { let bytes = CONTINUE.to_vec() + ~[0]; let port = loader(bytes); let res: Option = port.try_recv(); - fail_unless!(res.is_none()); + assert!(res.is_none()); } #[test] @@ -939,7 +939,7 @@ mod test { } fn test_try_recv_none4(+loader: PortLoader

) { - fail_unless!(do task::try || { + assert!(do task::try || { static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD]; // The control word is followed by a valid length, // then undeserializable garbage diff --git a/src/libstd/future.rs b/src/libstd/future.rs index 8504b3e8ae5e0..a4887306d2a93 100644 --- a/src/libstd/future.rs +++ b/src/libstd/future.rs @@ -155,7 +155,7 @@ pub mod test { #[test] pub fn test_from_value() { let f = from_value(~"snail"); - fail_unless!(f.get() == ~"snail"); + assert!(f.get() == ~"snail"); } #[test] @@ -163,31 +163,31 @@ pub mod test { let (ch, po) = oneshot::init(); send_one(ch, ~"whale"); let f = from_port(po); - fail_unless!(f.get() == ~"whale"); + assert!(f.get() == ~"whale"); } #[test] pub fn test_from_fn() { let f = from_fn(|| ~"brail"); - fail_unless!(f.get() == ~"brail"); + assert!(f.get() == ~"brail"); } #[test] pub fn test_interface_get() { let f = from_value(~"fail"); - fail_unless!(f.get() == ~"fail"); + assert!(f.get() == ~"fail"); } #[test] pub fn test_get_ref_method() { let f = from_value(22); - fail_unless!(*f.get_ref() == 22); + assert!(*f.get_ref() == 22); } #[test] pub fn test_spawn() { let f = spawn(|| ~"bale"); - fail_unless!(f.get() == ~"bale"); + assert!(f.get() == ~"bale"); } #[test] @@ -204,7 +204,7 @@ pub mod test { let f = do spawn { copy expected }; do task::spawn || { let actual = f.get(); - fail_unless!(actual == expected); + assert!(actual == expected); } } } diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 4525dc0ae61c0..df37c48ebe8b8 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -484,7 +484,7 @@ pub mod groups { pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { let len = short_name.len(); - fail_unless!(len == 1 || len == 0); + assert!(len == 1 || len == 0); return OptGroup { short_name: str::from_slice(short_name), long_name: str::from_slice(long_name), hint: str::from_slice(hint), @@ -497,7 +497,7 @@ pub mod groups { pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { let len = short_name.len(); - fail_unless!(len == 1 || len == 0); + assert!(len == 1 || len == 0); return OptGroup {short_name: str::from_slice(short_name), long_name: str::from_slice(long_name), hint: str::from_slice(hint), @@ -510,7 +510,7 @@ pub mod groups { pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup { let len = short_name.len(); - fail_unless!(len == 1 || len == 0); + assert!(len == 1 || len == 0); return OptGroup {short_name: str::from_slice(short_name), long_name: str::from_slice(long_name), hint: ~"", @@ -523,7 +523,7 @@ pub mod groups { pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { let len = short_name.len(); - fail_unless!(len == 1 || len == 0); + assert!(len == 1 || len == 0); return OptGroup {short_name: str::from_slice(short_name), long_name: str::from_slice(long_name), hint: str::from_slice(hint), @@ -539,7 +539,7 @@ pub mod groups { pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { let len = short_name.len(); - fail_unless!(len == 1 || len == 0); + assert!(len == 1 || len == 0); return OptGroup {short_name: str::from_slice(short_name), long_name: str::from_slice(long_name), hint: str::from_slice(hint), @@ -666,11 +666,11 @@ mod tests { pub fn check_fail_type(f: Fail_, ft: FailType) { match f { - ArgumentMissing(_) => fail_unless!(ft == ArgumentMissing_), - UnrecognizedOption(_) => fail_unless!(ft == UnrecognizedOption_), - OptionMissing(_) => fail_unless!(ft == OptionMissing_), - OptionDuplicated(_) => fail_unless!(ft == OptionDuplicated_), - UnexpectedArgument(_) => fail_unless!(ft == UnexpectedArgument_) + ArgumentMissing(_) => assert!(ft == ArgumentMissing_), + UnrecognizedOption(_) => assert!(ft == UnrecognizedOption_), + OptionMissing(_) => assert!(ft == OptionMissing_), + OptionDuplicated(_) => assert!(ft == OptionDuplicated_), + UnexpectedArgument(_) => assert!(ft == UnexpectedArgument_) } } @@ -683,8 +683,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"test"))); - fail_unless!((opt_str(m, ~"test") == ~"20")); + assert!((opt_present(m, ~"test"))); + assert!((opt_str(m, ~"test") == ~"20")); } _ => { fail!(~"test_reqopt_long failed"); } } @@ -730,8 +730,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"t"))); - fail_unless!((opt_str(m, ~"t") == ~"20")); + assert!((opt_present(m, ~"t"))); + assert!((opt_str(m, ~"t") == ~"20")); } _ => fail!() } @@ -779,8 +779,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"test"))); - fail_unless!((opt_str(m, ~"test") == ~"20")); + assert!((opt_present(m, ~"test"))); + assert!((opt_str(m, ~"test") == ~"20")); } _ => fail!() } @@ -792,7 +792,7 @@ mod tests { let opts = ~[optopt(~"test")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"test")), + Ok(ref m) => assert!(!opt_present(m, ~"test")), _ => fail!() } } @@ -826,8 +826,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"t"))); - fail_unless!((opt_str(m, ~"t") == ~"20")); + assert!((opt_present(m, ~"t"))); + assert!((opt_str(m, ~"t") == ~"20")); } _ => fail!() } @@ -839,7 +839,7 @@ mod tests { let opts = ~[optopt(~"t")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"t")), + Ok(ref m) => assert!(!opt_present(m, ~"t")), _ => fail!() } } @@ -874,7 +874,7 @@ mod tests { let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(opt_present(m, ~"test")), + Ok(ref m) => assert!(opt_present(m, ~"test")), _ => fail!() } } @@ -885,7 +885,7 @@ mod tests { let opts = ~[optflag(~"test")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"test")), + Ok(ref m) => assert!(!opt_present(m, ~"test")), _ => fail!() } } @@ -921,7 +921,7 @@ mod tests { let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(opt_present(m, ~"t")), + Ok(ref m) => assert!(opt_present(m, ~"t")), _ => fail!() } } @@ -932,7 +932,7 @@ mod tests { let opts = ~[optflag(~"t")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"t")), + Ok(ref m) => assert!(!opt_present(m, ~"t")), _ => fail!() } } @@ -946,7 +946,7 @@ mod tests { Ok(ref m) => { // The next variable after the flag is just a free argument - fail_unless!((m.free[0] == ~"20")); + assert!((m.free[0] == ~"20")); } _ => fail!() } @@ -971,7 +971,7 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_count(m, ~"v") == 1)); + assert!((opt_count(m, ~"v") == 1)); } _ => fail!() } @@ -984,7 +984,7 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_count(m, ~"v") == 2)); + assert!((opt_count(m, ~"v") == 2)); } _ => fail!() } @@ -997,7 +997,7 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_count(m, ~"v") == 2)); + assert!((opt_count(m, ~"v") == 2)); } _ => fail!() } @@ -1010,7 +1010,7 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_count(m, ~"verbose") == 1)); + assert!((opt_count(m, ~"verbose") == 1)); } _ => fail!() } @@ -1023,7 +1023,7 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_count(m, ~"verbose") == 2)); + assert!((opt_count(m, ~"verbose") == 2)); } _ => fail!() } @@ -1037,8 +1037,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"test"))); - fail_unless!((opt_str(m, ~"test") == ~"20")); + assert!((opt_present(m, ~"test"))); + assert!((opt_str(m, ~"test") == ~"20")); } _ => fail!() } @@ -1050,7 +1050,7 @@ mod tests { let opts = ~[optmulti(~"test")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"test")), + Ok(ref m) => assert!(!opt_present(m, ~"test")), _ => fail!() } } @@ -1073,11 +1073,11 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"test"))); - fail_unless!((opt_str(m, ~"test") == ~"20")); + assert!((opt_present(m, ~"test"))); + assert!((opt_str(m, ~"test") == ~"20")); let pair = opt_strs(m, ~"test"); - fail_unless!((pair[0] == ~"20")); - fail_unless!((pair[1] == ~"30")); + assert!((pair[0] == ~"20")); + assert!((pair[1] == ~"30")); } _ => fail!() } @@ -1090,8 +1090,8 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"t"))); - fail_unless!((opt_str(m, ~"t") == ~"20")); + assert!((opt_present(m, ~"t"))); + assert!((opt_str(m, ~"t") == ~"20")); } _ => fail!() } @@ -1103,7 +1103,7 @@ mod tests { let opts = ~[optmulti(~"t")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => fail_unless!(!opt_present(m, ~"t")), + Ok(ref m) => assert!(!opt_present(m, ~"t")), _ => fail!() } } @@ -1126,11 +1126,11 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((opt_present(m, ~"t"))); - fail_unless!((opt_str(m, ~"t") == ~"20")); + assert!((opt_present(m, ~"t"))); + assert!((opt_str(m, ~"t") == ~"20")); let pair = opt_strs(m, ~"t"); - fail_unless!((pair[0] == ~"20")); - fail_unless!((pair[1] == ~"30")); + assert!((pair[0] == ~"20")); + assert!((pair[1] == ~"30")); } _ => fail!() } @@ -1171,20 +1171,20 @@ mod tests { let rs = getopts(args, opts); match rs { Ok(ref m) => { - fail_unless!((m.free[0] == ~"prog")); - fail_unless!((m.free[1] == ~"free1")); - fail_unless!((opt_str(m, ~"s") == ~"20")); - fail_unless!((m.free[2] == ~"free2")); - fail_unless!((opt_present(m, ~"flag"))); - fail_unless!((opt_str(m, ~"long") == ~"30")); - fail_unless!((opt_present(m, ~"f"))); + assert!((m.free[0] == ~"prog")); + assert!((m.free[1] == ~"free1")); + assert!((opt_str(m, ~"s") == ~"20")); + assert!((m.free[2] == ~"free2")); + assert!((opt_present(m, ~"flag"))); + assert!((opt_str(m, ~"long") == ~"30")); + assert!((opt_present(m, ~"f"))); let pair = opt_strs(m, ~"m"); - fail_unless!((pair[0] == ~"40")); - fail_unless!((pair[1] == ~"50")); + assert!((pair[0] == ~"40")); + assert!((pair[1] == ~"50")); let pair = opt_strs(m, ~"n"); - fail_unless!((pair[0] == ~"-A B")); - fail_unless!((pair[1] == ~"-60 70")); - fail_unless!((!opt_present(m, ~"notpresent"))); + assert!((pair[0] == ~"-A B")); + assert!((pair[1] == ~"-60 70")); + assert!((!opt_present(m, ~"notpresent"))); } _ => fail!() } @@ -1198,18 +1198,18 @@ mod tests { result::Ok(m) => m, result::Err(_) => fail!() }; - fail_unless!(opts_present(matches, ~[~"e"])); - fail_unless!(opts_present(matches, ~[~"encrypt"])); - fail_unless!(opts_present(matches, ~[~"encrypt", ~"e"])); - fail_unless!(opts_present(matches, ~[~"e", ~"encrypt"])); - fail_unless!(!opts_present(matches, ~[~"f"])); - fail_unless!(!opts_present(matches, ~[~"thing"])); - fail_unless!(!opts_present(matches, ~[])); + assert!(opts_present(matches, ~[~"e"])); + assert!(opts_present(matches, ~[~"encrypt"])); + assert!(opts_present(matches, ~[~"encrypt", ~"e"])); + assert!(opts_present(matches, ~[~"e", ~"encrypt"])); + assert!(!opts_present(matches, ~[~"f"])); + assert!(!opts_present(matches, ~[~"thing"])); + assert!(!opts_present(matches, ~[])); - fail_unless!(opts_str(matches, ~[~"e"]) == ~"foo"); - fail_unless!(opts_str(matches, ~[~"encrypt"]) == ~"foo"); - fail_unless!(opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo"); - fail_unless!(opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo"); + assert!(opts_str(matches, ~[~"e"]) == ~"foo"); + assert!(opts_str(matches, ~[~"encrypt"]) == ~"foo"); + assert!(opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo"); + assert!(opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo"); } #[test] @@ -1220,17 +1220,17 @@ mod tests { result::Ok(m) => m, result::Err(_) => fail!() }; - fail_unless!(opts_present(matches, ~[~"L"])); - fail_unless!(opts_str(matches, ~[~"L"]) == ~"foo"); - fail_unless!(opts_present(matches, ~[~"M"])); - fail_unless!(opts_str(matches, ~[~"M"]) == ~"."); + assert!(opts_present(matches, ~[~"L"])); + assert!(opts_str(matches, ~[~"L"]) == ~"foo"); + assert!(opts_present(matches, ~[~"M"])); + assert!(opts_str(matches, ~[~"M"]) == ~"."); } #[test] pub fn test_groups_reqopt() { let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL"); - fail_unless!(opt == OptGroup { short_name: ~"b", + assert!(opt == OptGroup { short_name: ~"b", long_name: ~"banana", hint: ~"VAL", desc: ~"some bananas", @@ -1241,7 +1241,7 @@ mod tests { #[test] pub fn test_groups_optopt() { let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL"); - fail_unless!(opt == OptGroup { short_name: ~"a", + assert!(opt == OptGroup { short_name: ~"a", long_name: ~"apple", hint: ~"VAL", desc: ~"some apples", @@ -1252,7 +1252,7 @@ mod tests { #[test] pub fn test_groups_optflag() { let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis"); - fail_unless!(opt == OptGroup { short_name: ~"k", + assert!(opt == OptGroup { short_name: ~"k", long_name: ~"kiwi", hint: ~"", desc: ~"some kiwis", @@ -1264,7 +1264,7 @@ mod tests { pub fn test_groups_optflagopt() { let opt = groups::optflagopt(~"p", ~"pineapple", ~"some pineapples", ~"VAL"); - fail_unless!(opt == OptGroup { short_name: ~"p", + assert!(opt == OptGroup { short_name: ~"p", long_name: ~"pineapple", hint: ~"VAL", desc: ~"some pineapples", @@ -1276,7 +1276,7 @@ mod tests { pub fn test_groups_optmulti() { let opt = groups::optmulti(~"l", ~"lime", ~"some limes", ~"VAL"); - fail_unless!(opt == OptGroup { short_name: ~"l", + assert!(opt == OptGroup { short_name: ~"l", long_name: ~"lime", hint: ~"VAL", desc: ~"some limes", @@ -1290,7 +1290,7 @@ mod tests { let verbose = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL"); - fail_unless!(groups::long_to_short(&verbose) == short); + assert!(groups::long_to_short(&verbose) == short); } #[test] @@ -1315,7 +1315,7 @@ mod tests { ~"-p", ~"16", ~"l", ~"35"]; // FIXME #4681: sort options here? - fail_unless!(getopts(sample_args, short) + assert!(getopts(sample_args, short) == groups::getopts(sample_args, verbose)); } @@ -1347,7 +1347,7 @@ Options: debug!("expected: <<%s>>", expected); debug!("generated: <<%s>>", generated_usage); - fail_unless!(generated_usage == expected); + assert!(generated_usage == expected); } #[test] @@ -1376,7 +1376,7 @@ Options: debug!("expected: <<%s>>", expected); debug!("generated: <<%s>>", usage); - fail_unless!(usage == expected) + assert!(usage == expected) } } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index b918f8505c802..63d461ed4d3bf 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -165,28 +165,28 @@ mod tests { let full1 = from_vec(~[1]); let full2 = from_vec(~['r', 'u']); - fail_unless!(is_empty(empty)); - fail_unless!(!is_empty(full1)); - fail_unless!(!is_empty(full2)); + assert!(is_empty(empty)); + assert!(!is_empty(full1)); + assert!(!is_empty(full2)); } #[test] pub fn test_from_vec() { let l = from_vec(~[0, 1, 2]); - fail_unless!((head(l) == 0)); + assert!((head(l) == 0)); let tail_l = tail(l); - fail_unless!((head(tail_l) == 1)); + assert!((head(tail_l) == 1)); let tail_tail_l = tail(tail_l); - fail_unless!((head(tail_tail_l) == 2)); + assert!((head(tail_tail_l) == 2)); } #[test] pub fn test_from_vec_empty() { let empty : @list::List = from_vec(~[]); - fail_unless!((empty == @list::Nil::)); + assert!((empty == @list::Nil::)); } #[test] @@ -194,8 +194,8 @@ mod tests { fn add(a: &uint, b: &int) -> uint { return *a + (*b as uint); } let l = from_vec(~[0, 1, 2, 3, 4]); let empty = @list::Nil::; - fail_unless!((list::foldl(0u, l, add) == 10u)); - fail_unless!((list::foldl(0u, empty, add) == 0u)); + assert!((list::foldl(0u, l, add) == 10u)); + assert!((list::foldl(0u, empty, add) == 0u)); } #[test] @@ -204,14 +204,14 @@ mod tests { *a - *b } let l = from_vec(~[1, 2, 3, 4]); - fail_unless!((list::foldl(0, l, sub) == -10)); + assert!((list::foldl(0, l, sub) == -10)); } #[test] pub fn test_find_success() { fn match_(i: &int) -> bool { return *i == 2; } let l = from_vec(~[0, 1, 2]); - fail_unless!((list::find(l, match_) == option::Some(2))); + assert!((list::find(l, match_) == option::Some(2))); } #[test] @@ -219,31 +219,31 @@ mod tests { fn match_(_i: &int) -> bool { return false; } let l = from_vec(~[0, 1, 2]); let empty = @list::Nil::; - fail_unless!((list::find(l, match_) == option::None::)); - fail_unless!((list::find(empty, match_) == option::None::)); + assert!((list::find(l, match_) == option::None::)); + assert!((list::find(empty, match_) == option::None::)); } #[test] pub fn test_has() { let l = from_vec(~[5, 8, 6]); let empty = @list::Nil::; - fail_unless!((list::has(l, 5))); - fail_unless!((!list::has(l, 7))); - fail_unless!((list::has(l, 8))); - fail_unless!((!list::has(empty, 5))); + assert!((list::has(l, 5))); + assert!((!list::has(l, 7))); + assert!((list::has(l, 8))); + assert!((!list::has(empty, 5))); } #[test] pub fn test_len() { let l = from_vec(~[0, 1, 2]); let empty = @list::Nil::; - fail_unless!((list::len(l) == 3u)); - fail_unless!((list::len(empty) == 0u)); + assert!((list::len(l) == 3u)); + assert!((list::len(empty) == 0u)); } #[test] pub fn test_append() { - fail_unless!(from_vec(~[1,2,3,4]) + assert!(from_vec(~[1,2,3,4]) == list::append(list::from_vec(~[1,2]), list::from_vec(~[3,4]))); } } diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index e20ac624278f7..8f35376a6f1f1 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -125,17 +125,17 @@ pub fn md4_text(msg: &str) -> ~str { md4_str(str::to_bytes(msg)) } #[test] fn test_md4() { - fail_unless!(md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0"); - fail_unless!(md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24"); - fail_unless!(md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d"); - fail_unless!(md4_text(~"message digest") == + assert!(md4_text(~"") == ~"31d6cfe0d16ae931b73c59d7e0c089c0"); + assert!(md4_text(~"a") == ~"bde52cb31de33e46245e05fbdbd6fb24"); + assert!(md4_text(~"abc") == ~"a448017aaf21d8525fc10ae87aa6729d"); + assert!(md4_text(~"message digest") == ~"d9130a8164549fe818874806e1c7014b"); - fail_unless!(md4_text(~"abcdefghijklmnopqrstuvwxyz") == + assert!(md4_text(~"abcdefghijklmnopqrstuvwxyz") == ~"d79e1c308aa5bbcdeea8ed63df412da9"); - fail_unless!(md4_text( + assert!(md4_text( ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ 0123456789") == ~"043f8582f241db351ce627e153e7f0e4"); - fail_unless!(md4_text(~"1234567890123456789012345678901234567890123456789\ + assert!(md4_text(~"1234567890123456789012345678901234567890123456789\ 0123456789012345678901234567890") == ~"e33b4ddc9c38f2199c3e7b164fcc0536"); } diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 4fd06f4316444..6403e0eb5c47a 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -379,7 +379,7 @@ mod test { #[test] fn test_ip_ipv4_parse_and_format_ip() { let localhost_str = ~"127.0.0.1"; - fail_unless!(format_addr(&v4::parse_addr(localhost_str)) + assert!(format_addr(&v4::parse_addr(localhost_str)) == localhost_str) } #[test] @@ -388,14 +388,14 @@ mod test { let format_result = format_addr(&v6::parse_addr(localhost_str)); debug!("results: expected: '%s' actual: '%s'", localhost_str, format_result); - fail_unless!(format_result == localhost_str); + assert!(format_result == localhost_str); } #[test] fn test_ip_ipv4_bad_parse() { match v4::try_parse_addr(~"b4df00d") { result::Err(ref err_info) => { debug!("got error as expected %?", err_info); - fail_unless!(true); + assert!(true); } result::Ok(ref addr) => { fail!(fmt!("Expected failure, but got addr %?", addr)); @@ -408,7 +408,7 @@ mod test { match v6::try_parse_addr(~"::,~2234k;") { result::Err(ref err_info) => { debug!("got error as expected %?", err_info); - fail_unless!(true); + assert!(true); } result::Ok(ref addr) => { fail!(fmt!("Expected failure, but got addr %?", addr)); @@ -439,7 +439,7 @@ mod test { } // at least one result.. this is going to vary from system // to system, based on stuff like the contents of /etc/hosts - fail_unless!(!results.is_empty()); + assert!(!results.is_empty()); } #[test] #[ignore(reason = "valgrind says it's leaky")] @@ -447,6 +447,6 @@ mod test { let localhost_name = ~"sjkl234m,./sdf"; let iotask = &uv::global_loop::get(); let ga_result = get_addr(localhost_name, iotask); - fail_unless!(result::is_err(&ga_result)); + assert!(result::is_err(&ga_result)); } } diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 998b8640b6882..8a51af8573f06 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -876,7 +876,7 @@ impl io::Reader for TcpSocketBuf { let mut count: uint = 0; loop { - fail_unless!(count < len); + assert!(count < len); // If possible, copy up to `len` bytes from the internal // `data.buf` into `buf` @@ -897,7 +897,7 @@ impl io::Reader for TcpSocketBuf { } } - fail_unless!(count <= len); + assert!(count <= len); if count == len { break; } @@ -1589,15 +1589,15 @@ pub mod test { server_port, expected_req, hl_loop); - fail_unless!(actual_resp_result.is_ok()); + assert!(actual_resp_result.is_ok()); let actual_resp = actual_resp_result.get(); let actual_req = server_result_po.recv(); debug!("REQ: expected: '%s' actual: '%s'", expected_req, actual_req); debug!("RESP: expected: '%s' actual: '%s'", expected_resp, actual_resp); - fail_unless!(str::contains(actual_req, expected_req)); - fail_unless!(str::contains(actual_resp, expected_resp)); + assert!(str::contains(actual_req, expected_req)); + assert!(str::contains(actual_resp, expected_resp)); } pub fn impl_gl_tcp_ipv4_get_peer_addr() { let hl_loop = &uv::global_loop::get(); @@ -1630,9 +1630,9 @@ pub mod test { debug!("testing peer address"); // This is what we are actually testing! - fail_unless!(net::ip::format_addr(&sock.get_peer_addr()) == + assert!(net::ip::format_addr(&sock.get_peer_addr()) == ~"127.0.0.1"); - fail_unless!(net::ip::get_port(&sock.get_peer_addr()) == 8887); + assert!(net::ip::get_port(&sock.get_peer_addr()) == 8887); // Fulfill the protocol the test server expects let resp_bytes = str::to_bytes(~"ping"); @@ -1693,7 +1693,7 @@ pub mod test { hl_loop); match listen_err { AddressInUse => { - fail_unless!(true); + assert!(true); } _ => { fail!(~"expected address_in_use listen error,"+ @@ -1712,7 +1712,7 @@ pub mod test { hl_loop); match listen_err { AccessDenied => { - fail_unless!(true); + assert!(true); } _ => { fail!(~"expected address_in_use listen error,"+ @@ -1749,7 +1749,7 @@ pub mod test { let server_addr = ip::v4::parse_addr(server_ip); let conn_result = connect(server_addr, server_port, iotask); if result::is_err(&conn_result) { - fail_unless!(false); + assert!(false); } let sock_buf = @socket_buf(result::unwrap(conn_result)); buf_write(sock_buf, expected_req); @@ -1764,8 +1764,8 @@ pub mod test { expected_req, actual_req); debug!("RESP: expected: '%s' actual: '%s'", expected_resp, actual_resp); - fail_unless!(str::contains(actual_req, expected_req)); - fail_unless!(str::contains(actual_resp, expected_resp)); + assert!(str::contains(actual_req, expected_req)); + assert!(str::contains(actual_resp, expected_resp)); } pub fn impl_tcp_socket_impl_reader_handles_eof() { @@ -1796,7 +1796,7 @@ pub mod test { let server_addr = ip::v4::parse_addr(server_ip); let conn_result = connect(server_addr, server_port, hl_loop); if result::is_err(&conn_result) { - fail_unless!(false); + assert!(false); } let sock_buf = @socket_buf(result::unwrap(conn_result)); buf_write(sock_buf, expected_req); @@ -1804,7 +1804,7 @@ pub mod test { let buf_reader = sock_buf as @Reader; let actual_response = str::from_bytes(buf_reader.read_whole_stream()); debug!("Actual response: %s", actual_response); - fail_unless!(expected_resp == actual_response); + assert!(expected_resp == actual_response); } fn buf_write(w: &W, val: &str) { diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 9caab11d6434e..d23784953ef99 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -733,83 +733,83 @@ impl to_bytes::IterBytes for Url { #[test] fn test_split_char_first() { let (u,v) = split_char_first(~"hello, sweet world", ','); - fail_unless!(u == ~"hello"); - fail_unless!(v == ~" sweet world"); + assert!(u == ~"hello"); + assert!(v == ~" sweet world"); let (u,v) = split_char_first(~"hello sweet world", ','); - fail_unless!(u == ~"hello sweet world"); - fail_unless!(v == ~""); + assert!(u == ~"hello sweet world"); + assert!(v == ~""); } #[test] fn test_get_authority() { let (u, h, p, r) = get_authority( "//user:pass@rust-lang.org/something").unwrap(); - fail_unless!(u == Some(UserInfo::new(~"user", Some(~"pass")))); - fail_unless!(h == ~"rust-lang.org"); - fail_unless!(p.is_none()); - fail_unless!(r == ~"/something"); + assert!(u == Some(UserInfo::new(~"user", Some(~"pass")))); + assert!(h == ~"rust-lang.org"); + assert!(p.is_none()); + assert!(r == ~"/something"); let (u, h, p, r) = get_authority( "//rust-lang.org:8000?something").unwrap(); - fail_unless!(u.is_none()); - fail_unless!(h == ~"rust-lang.org"); - fail_unless!(p == Some(~"8000")); - fail_unless!(r == ~"?something"); + assert!(u.is_none()); + assert!(h == ~"rust-lang.org"); + assert!(p == Some(~"8000")); + assert!(r == ~"?something"); let (u, h, p, r) = get_authority( "//rust-lang.org#blah").unwrap(); - fail_unless!(u.is_none()); - fail_unless!(h == ~"rust-lang.org"); - fail_unless!(p.is_none()); - fail_unless!(r == ~"#blah"); + assert!(u.is_none()); + assert!(h == ~"rust-lang.org"); + assert!(p.is_none()); + assert!(r == ~"#blah"); // ipv6 tests let (_, h, _, _) = get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334#blah").unwrap(); - fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); let (_, h, p, _) = get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah").unwrap(); - fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); - fail_unless!(p == Some(~"8000")); + assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert!(p == Some(~"8000")); let (u, h, p, _) = get_authority( "//us:p@2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000#blah" ).unwrap(); - fail_unless!(u == Some(UserInfo::new(~"us", Some(~"p")))); - fail_unless!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); - fail_unless!(p == Some(~"8000")); + assert!(u == Some(UserInfo::new(~"us", Some(~"p")))); + assert!(h == ~"2001:0db8:85a3:0042:0000:8a2e:0370:7334"); + assert!(p == Some(~"8000")); // invalid authorities; - fail_unless!(get_authority("//user:pass@rust-lang:something").is_err()); - fail_unless!(get_authority("//user@rust-lang:something:/path").is_err()); - fail_unless!(get_authority( + assert!(get_authority("//user:pass@rust-lang:something").is_err()); + assert!(get_authority("//user@rust-lang:something:/path").is_err()); + assert!(get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:800a").is_err()); - fail_unless!(get_authority( + assert!(get_authority( "//2001:0db8:85a3:0042:0000:8a2e:0370:7334:8000:00").is_err()); // these parse as empty, because they don't start with '//' let (_, h, _, _) = get_authority(~"user:pass@rust-lang").unwrap(); - fail_unless!(h == ~""); + assert!(h == ~""); let (_, h, _, _) = get_authority(~"rust-lang.org").unwrap(); - fail_unless!(h == ~""); + assert!(h == ~""); } #[test] fn test_get_path() { let (p, r) = get_path("/something+%20orother", true).unwrap(); - fail_unless!(p == ~"/something+ orother"); - fail_unless!(r == ~""); + assert!(p == ~"/something+ orother"); + assert!(r == ~""); let (p, r) = get_path("test@email.com#fragment", false).unwrap(); - fail_unless!(p == ~"test@email.com"); - fail_unless!(r == ~"#fragment"); + assert!(p == ~"test@email.com"); + assert!(r == ~"#fragment"); let (p, r) = get_path(~"/gen/:addr=?q=v", false).unwrap(); - fail_unless!(p == ~"/gen/:addr="); - fail_unless!(r == ~"?q=v"); + assert!(p == ~"/gen/:addr="); + assert!(r == ~"?q=v"); //failure cases - fail_unless!(get_path(~"something?q", true).is_err()); + assert!(get_path(~"something?q", true).is_err()); } #[cfg(test)] @@ -826,247 +826,247 @@ mod tests { let up = from_str(url); let u = up.unwrap(); - fail_unless!(u.scheme == ~"http"); + assert!(u.scheme == ~"http"); let userinfo = u.user.get_ref(); - fail_unless!(userinfo.user == ~"user"); - fail_unless!(userinfo.pass.get_ref() == &~"pass"); - fail_unless!(u.host == ~"rust-lang.org"); - fail_unless!(u.path == ~"/doc"); - fail_unless!(u.query == ~[(~"s", ~"v")]); - fail_unless!(u.fragment.get_ref() == &~"something"); + assert!(userinfo.user == ~"user"); + assert!(userinfo.pass.get_ref() == &~"pass"); + assert!(u.host == ~"rust-lang.org"); + assert!(u.path == ~"/doc"); + assert!(u.query == ~[(~"s", ~"v")]); + assert!(u.fragment.get_ref() == &~"something"); } #[test] pub fn test_url_parse_host_slash() { let urlstr = ~"http://0.42.42.42/"; let url = from_str(urlstr).unwrap(); - fail_unless!(url.host == ~"0.42.42.42"); - fail_unless!(url.path == ~"/"); + assert!(url.host == ~"0.42.42.42"); + assert!(url.path == ~"/"); } #[test] pub fn test_url_with_underscores() { let urlstr = ~"http://dotcom.com/file_name.html"; let url = from_str(urlstr).unwrap(); - fail_unless!(url.path == ~"/file_name.html"); + assert!(url.path == ~"/file_name.html"); } #[test] pub fn test_url_with_dashes() { let urlstr = ~"http://dotcom.com/file-name.html"; let url = from_str(urlstr).unwrap(); - fail_unless!(url.path == ~"/file-name.html"); + assert!(url.path == ~"/file-name.html"); } #[test] pub fn test_no_scheme() { - fail_unless!(get_scheme("noschemehere.html").is_err()); + assert!(get_scheme("noschemehere.html").is_err()); } #[test] pub fn test_invalid_scheme_errors() { - fail_unless!(from_str("99://something").is_err()); - fail_unless!(from_str("://something").is_err()); + assert!(from_str("99://something").is_err()); + assert!(from_str("://something").is_err()); } #[test] pub fn test_full_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?s=v#something"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_userless_url_parse_and_format() { let url = ~"http://rust-lang.org/doc?s=v#something"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_queryless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc#something"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_empty_query_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?#something"; let should_be = ~"http://user:pass@rust-lang.org/doc#something"; - fail_unless!(from_str(url).unwrap().to_str() == should_be); + assert!(from_str(url).unwrap().to_str() == should_be); } #[test] pub fn test_fragmentless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org/doc?q=v"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_minimal_url_parse_and_format() { let url = ~"http://rust-lang.org/doc"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_scheme_host_only_url_parse_and_format() { let url = ~"http://rust-lang.org"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_pathless_url_parse_and_format() { let url = ~"http://user:pass@rust-lang.org?q=v#something"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_scheme_host_fragment_only_url_parse_and_format() { let url = ~"http://rust-lang.org#something"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_url_component_encoding() { let url = ~"http://rust-lang.org/doc%20uments?ba%25d%20=%23%26%2B"; let u = from_str(url).unwrap(); - fail_unless!(u.path == ~"/doc uments"); - fail_unless!(u.query == ~[(~"ba%d ", ~"#&+")]); + assert!(u.path == ~"/doc uments"); + assert!(u.query == ~[(~"ba%d ", ~"#&+")]); } #[test] pub fn test_url_without_authority() { let url = ~"mailto:test@email.com"; - fail_unless!(from_str(url).unwrap().to_str() == url); + assert!(from_str(url).unwrap().to_str() == url); } #[test] pub fn test_encode() { - fail_unless!(encode("") == ~""); - fail_unless!(encode("http://example.com") == ~"http://example.com"); - fail_unless!(encode("foo bar% baz") == ~"foo%20bar%25%20baz"); - fail_unless!(encode(" ") == ~"%20"); - fail_unless!(encode("!") == ~"!"); - fail_unless!(encode("\"") == ~"\""); - fail_unless!(encode("#") == ~"#"); - fail_unless!(encode("$") == ~"$"); - fail_unless!(encode("%") == ~"%25"); - fail_unless!(encode("&") == ~"&"); - fail_unless!(encode("'") == ~"%27"); - fail_unless!(encode("(") == ~"("); - fail_unless!(encode(")") == ~")"); - fail_unless!(encode("*") == ~"*"); - fail_unless!(encode("+") == ~"+"); - fail_unless!(encode(",") == ~","); - fail_unless!(encode("/") == ~"/"); - fail_unless!(encode(":") == ~":"); - fail_unless!(encode(";") == ~";"); - fail_unless!(encode("=") == ~"="); - fail_unless!(encode("?") == ~"?"); - fail_unless!(encode("@") == ~"@"); - fail_unless!(encode("[") == ~"["); - fail_unless!(encode("]") == ~"]"); + assert!(encode("") == ~""); + assert!(encode("http://example.com") == ~"http://example.com"); + assert!(encode("foo bar% baz") == ~"foo%20bar%25%20baz"); + assert!(encode(" ") == ~"%20"); + assert!(encode("!") == ~"!"); + assert!(encode("\"") == ~"\""); + assert!(encode("#") == ~"#"); + assert!(encode("$") == ~"$"); + assert!(encode("%") == ~"%25"); + assert!(encode("&") == ~"&"); + assert!(encode("'") == ~"%27"); + assert!(encode("(") == ~"("); + assert!(encode(")") == ~")"); + assert!(encode("*") == ~"*"); + assert!(encode("+") == ~"+"); + assert!(encode(",") == ~","); + assert!(encode("/") == ~"/"); + assert!(encode(":") == ~":"); + assert!(encode(";") == ~";"); + assert!(encode("=") == ~"="); + assert!(encode("?") == ~"?"); + assert!(encode("@") == ~"@"); + assert!(encode("[") == ~"["); + assert!(encode("]") == ~"]"); } #[test] pub fn test_encode_component() { - fail_unless!(encode_component("") == ~""); - fail_unless!(encode_component("http://example.com") == + assert!(encode_component("") == ~""); + assert!(encode_component("http://example.com") == ~"http%3A%2F%2Fexample.com"); - fail_unless!(encode_component("foo bar% baz") == + assert!(encode_component("foo bar% baz") == ~"foo%20bar%25%20baz"); - fail_unless!(encode_component(" ") == ~"%20"); - fail_unless!(encode_component("!") == ~"%21"); - fail_unless!(encode_component("#") == ~"%23"); - fail_unless!(encode_component("$") == ~"%24"); - fail_unless!(encode_component("%") == ~"%25"); - fail_unless!(encode_component("&") == ~"%26"); - fail_unless!(encode_component("'") == ~"%27"); - fail_unless!(encode_component("(") == ~"%28"); - fail_unless!(encode_component(")") == ~"%29"); - fail_unless!(encode_component("*") == ~"%2A"); - fail_unless!(encode_component("+") == ~"%2B"); - fail_unless!(encode_component(",") == ~"%2C"); - fail_unless!(encode_component("/") == ~"%2F"); - fail_unless!(encode_component(":") == ~"%3A"); - fail_unless!(encode_component(";") == ~"%3B"); - fail_unless!(encode_component("=") == ~"%3D"); - fail_unless!(encode_component("?") == ~"%3F"); - fail_unless!(encode_component("@") == ~"%40"); - fail_unless!(encode_component("[") == ~"%5B"); - fail_unless!(encode_component("]") == ~"%5D"); + assert!(encode_component(" ") == ~"%20"); + assert!(encode_component("!") == ~"%21"); + assert!(encode_component("#") == ~"%23"); + assert!(encode_component("$") == ~"%24"); + assert!(encode_component("%") == ~"%25"); + assert!(encode_component("&") == ~"%26"); + assert!(encode_component("'") == ~"%27"); + assert!(encode_component("(") == ~"%28"); + assert!(encode_component(")") == ~"%29"); + assert!(encode_component("*") == ~"%2A"); + assert!(encode_component("+") == ~"%2B"); + assert!(encode_component(",") == ~"%2C"); + assert!(encode_component("/") == ~"%2F"); + assert!(encode_component(":") == ~"%3A"); + assert!(encode_component(";") == ~"%3B"); + assert!(encode_component("=") == ~"%3D"); + assert!(encode_component("?") == ~"%3F"); + assert!(encode_component("@") == ~"%40"); + assert!(encode_component("[") == ~"%5B"); + assert!(encode_component("]") == ~"%5D"); } #[test] pub fn test_decode() { - fail_unless!(decode("") == ~""); - fail_unless!(decode("abc/def 123") == ~"abc/def 123"); - fail_unless!(decode("abc%2Fdef%20123") == ~"abc%2Fdef 123"); - fail_unless!(decode("%20") == ~" "); - fail_unless!(decode("%21") == ~"%21"); - fail_unless!(decode("%22") == ~"%22"); - fail_unless!(decode("%23") == ~"%23"); - fail_unless!(decode("%24") == ~"%24"); - fail_unless!(decode("%25") == ~"%"); - fail_unless!(decode("%26") == ~"%26"); - fail_unless!(decode("%27") == ~"'"); - fail_unless!(decode("%28") == ~"%28"); - fail_unless!(decode("%29") == ~"%29"); - fail_unless!(decode("%2A") == ~"%2A"); - fail_unless!(decode("%2B") == ~"%2B"); - fail_unless!(decode("%2C") == ~"%2C"); - fail_unless!(decode("%2F") == ~"%2F"); - fail_unless!(decode("%3A") == ~"%3A"); - fail_unless!(decode("%3B") == ~"%3B"); - fail_unless!(decode("%3D") == ~"%3D"); - fail_unless!(decode("%3F") == ~"%3F"); - fail_unless!(decode("%40") == ~"%40"); - fail_unless!(decode("%5B") == ~"%5B"); - fail_unless!(decode("%5D") == ~"%5D"); + assert!(decode("") == ~""); + assert!(decode("abc/def 123") == ~"abc/def 123"); + assert!(decode("abc%2Fdef%20123") == ~"abc%2Fdef 123"); + assert!(decode("%20") == ~" "); + assert!(decode("%21") == ~"%21"); + assert!(decode("%22") == ~"%22"); + assert!(decode("%23") == ~"%23"); + assert!(decode("%24") == ~"%24"); + assert!(decode("%25") == ~"%"); + assert!(decode("%26") == ~"%26"); + assert!(decode("%27") == ~"'"); + assert!(decode("%28") == ~"%28"); + assert!(decode("%29") == ~"%29"); + assert!(decode("%2A") == ~"%2A"); + assert!(decode("%2B") == ~"%2B"); + assert!(decode("%2C") == ~"%2C"); + assert!(decode("%2F") == ~"%2F"); + assert!(decode("%3A") == ~"%3A"); + assert!(decode("%3B") == ~"%3B"); + assert!(decode("%3D") == ~"%3D"); + assert!(decode("%3F") == ~"%3F"); + assert!(decode("%40") == ~"%40"); + assert!(decode("%5B") == ~"%5B"); + assert!(decode("%5D") == ~"%5D"); } #[test] pub fn test_decode_component() { - fail_unless!(decode_component("") == ~""); - fail_unless!(decode_component("abc/def 123") == ~"abc/def 123"); - fail_unless!(decode_component("abc%2Fdef%20123") == ~"abc/def 123"); - fail_unless!(decode_component("%20") == ~" "); - fail_unless!(decode_component("%21") == ~"!"); - fail_unless!(decode_component("%22") == ~"\""); - fail_unless!(decode_component("%23") == ~"#"); - fail_unless!(decode_component("%24") == ~"$"); - fail_unless!(decode_component("%25") == ~"%"); - fail_unless!(decode_component("%26") == ~"&"); - fail_unless!(decode_component("%27") == ~"'"); - fail_unless!(decode_component("%28") == ~"("); - fail_unless!(decode_component("%29") == ~")"); - fail_unless!(decode_component("%2A") == ~"*"); - fail_unless!(decode_component("%2B") == ~"+"); - fail_unless!(decode_component("%2C") == ~","); - fail_unless!(decode_component("%2F") == ~"/"); - fail_unless!(decode_component("%3A") == ~":"); - fail_unless!(decode_component("%3B") == ~";"); - fail_unless!(decode_component("%3D") == ~"="); - fail_unless!(decode_component("%3F") == ~"?"); - fail_unless!(decode_component("%40") == ~"@"); - fail_unless!(decode_component("%5B") == ~"["); - fail_unless!(decode_component("%5D") == ~"]"); + assert!(decode_component("") == ~""); + assert!(decode_component("abc/def 123") == ~"abc/def 123"); + assert!(decode_component("abc%2Fdef%20123") == ~"abc/def 123"); + assert!(decode_component("%20") == ~" "); + assert!(decode_component("%21") == ~"!"); + assert!(decode_component("%22") == ~"\""); + assert!(decode_component("%23") == ~"#"); + assert!(decode_component("%24") == ~"$"); + assert!(decode_component("%25") == ~"%"); + assert!(decode_component("%26") == ~"&"); + assert!(decode_component("%27") == ~"'"); + assert!(decode_component("%28") == ~"("); + assert!(decode_component("%29") == ~")"); + assert!(decode_component("%2A") == ~"*"); + assert!(decode_component("%2B") == ~"+"); + assert!(decode_component("%2C") == ~","); + assert!(decode_component("%2F") == ~"/"); + assert!(decode_component("%3A") == ~":"); + assert!(decode_component("%3B") == ~";"); + assert!(decode_component("%3D") == ~"="); + assert!(decode_component("%3F") == ~"?"); + assert!(decode_component("%40") == ~"@"); + assert!(decode_component("%5B") == ~"["); + assert!(decode_component("%5D") == ~"]"); } #[test] pub fn test_encode_form_urlencoded() { let mut m = LinearMap::new(); - fail_unless!(encode_form_urlencoded(&m) == ~""); + assert!(encode_form_urlencoded(&m) == ~""); m.insert(~"", ~[]); m.insert(~"foo", ~[]); - fail_unless!(encode_form_urlencoded(&m) == ~""); + assert!(encode_form_urlencoded(&m) == ~""); let mut m = LinearMap::new(); m.insert(~"foo", ~[~"bar", ~"123"]); - fail_unless!(encode_form_urlencoded(&m) == ~"foo=bar&foo=123"); + assert!(encode_form_urlencoded(&m) == ~"foo=bar&foo=123"); let mut m = LinearMap::new(); m.insert(~"foo bar", ~[~"abc", ~"12 = 34"]); - fail_unless!(encode_form_urlencoded(&m) == + assert!(encode_form_urlencoded(&m) == ~"foo+bar=abc&foo+bar=12+%3D+34"); } @@ -1075,13 +1075,13 @@ mod tests { // FIXME #4449: Commented out because this causes an ICE, but only // on FreeBSD /* - fail_unless!(decode_form_urlencoded(~[]).len() == 0); + assert!(decode_form_urlencoded(~[]).len() == 0); let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34"); let form = decode_form_urlencoded(s); - fail_unless!(form.len() == 2); - fail_unless!(form.get_ref(&~"a") == &~[~"1"]); - fail_unless!(form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"]); + assert!(form.len() == 2); + assert!(form.get_ref(&~"a") == &~[~"1"]); + assert!(form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"]); */ } } diff --git a/src/libstd/par.rs b/src/libstd/par.rs index 6f69ac4e1bd69..bb83cfc494b4c 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -68,7 +68,7 @@ fn map_slices( cast::reinterpret_cast(&slice); info!("slice: %?", (base, vec::len(slice), end - base)); - fail_unless!((vec::len(slice) == end - base)); + assert!((vec::len(slice) == end - base)); f(base, slice) } }; @@ -79,12 +79,12 @@ fn map_slices( info!("tasks spawned"); info!("num_tasks: %?", (num_tasks, futures.len())); - fail_unless!((num_tasks == futures.len())); + assert!((num_tasks == futures.len())); let r = do futures.map() |ys| { ys.get() }; - fail_unless!((r.len() == futures.len())); + assert!((r.len() == futures.len())); r } } @@ -115,7 +115,7 @@ pub fn mapi( }); let r = vec::concat(slices); info!("%?", (r.len(), xs.len())); - fail_unless!((r.len() == xs.len())); + assert!((r.len() == xs.len())); r } diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs index ff00d26882d32..1fb79fcab2823 100644 --- a/src/libstd/priority_queue.rs +++ b/src/libstd/priority_queue.rs @@ -197,87 +197,87 @@ mod tests { let mut sorted = merge_sort(data, le); let mut heap = from_vec(data); while !heap.is_empty() { - fail_unless!(heap.top() == sorted.last()); - fail_unless!(heap.pop() == sorted.pop()); + assert!(heap.top() == sorted.last()); + assert!(heap.pop() == sorted.pop()); } } #[test] fn test_push() { let mut heap = from_vec(~[2, 4, 9]); - fail_unless!(heap.len() == 3); - fail_unless!(*heap.top() == 9); + assert!(heap.len() == 3); + assert!(*heap.top() == 9); heap.push(11); - fail_unless!(heap.len() == 4); - fail_unless!(*heap.top() == 11); + assert!(heap.len() == 4); + assert!(*heap.top() == 11); heap.push(5); - fail_unless!(heap.len() == 5); - fail_unless!(*heap.top() == 11); + assert!(heap.len() == 5); + assert!(*heap.top() == 11); heap.push(27); - fail_unless!(heap.len() == 6); - fail_unless!(*heap.top() == 27); + assert!(heap.len() == 6); + assert!(*heap.top() == 27); heap.push(3); - fail_unless!(heap.len() == 7); - fail_unless!(*heap.top() == 27); + assert!(heap.len() == 7); + assert!(*heap.top() == 27); heap.push(103); - fail_unless!(heap.len() == 8); - fail_unless!(*heap.top() == 103); + assert!(heap.len() == 8); + assert!(*heap.top() == 103); } #[test] fn test_push_unique() { let mut heap = from_vec(~[~2, ~4, ~9]); - fail_unless!(heap.len() == 3); - fail_unless!(*heap.top() == ~9); + assert!(heap.len() == 3); + assert!(*heap.top() == ~9); heap.push(~11); - fail_unless!(heap.len() == 4); - fail_unless!(*heap.top() == ~11); + assert!(heap.len() == 4); + assert!(*heap.top() == ~11); heap.push(~5); - fail_unless!(heap.len() == 5); - fail_unless!(*heap.top() == ~11); + assert!(heap.len() == 5); + assert!(*heap.top() == ~11); heap.push(~27); - fail_unless!(heap.len() == 6); - fail_unless!(*heap.top() == ~27); + assert!(heap.len() == 6); + assert!(*heap.top() == ~27); heap.push(~3); - fail_unless!(heap.len() == 7); - fail_unless!(*heap.top() == ~27); + assert!(heap.len() == 7); + assert!(*heap.top() == ~27); heap.push(~103); - fail_unless!(heap.len() == 8); - fail_unless!(*heap.top() == ~103); + assert!(heap.len() == 8); + assert!(*heap.top() == ~103); } #[test] fn test_push_pop() { let mut heap = from_vec(~[5, 5, 2, 1, 3]); - fail_unless!(heap.len() == 5); - fail_unless!(heap.push_pop(6) == 6); - fail_unless!(heap.len() == 5); - fail_unless!(heap.push_pop(0) == 5); - fail_unless!(heap.len() == 5); - fail_unless!(heap.push_pop(4) == 5); - fail_unless!(heap.len() == 5); - fail_unless!(heap.push_pop(1) == 4); - fail_unless!(heap.len() == 5); + assert!(heap.len() == 5); + assert!(heap.push_pop(6) == 6); + assert!(heap.len() == 5); + assert!(heap.push_pop(0) == 5); + assert!(heap.len() == 5); + assert!(heap.push_pop(4) == 5); + assert!(heap.len() == 5); + assert!(heap.push_pop(1) == 4); + assert!(heap.len() == 5); } #[test] fn test_replace() { let mut heap = from_vec(~[5, 5, 2, 1, 3]); - fail_unless!(heap.len() == 5); - fail_unless!(heap.replace(6) == 5); - fail_unless!(heap.len() == 5); - fail_unless!(heap.replace(0) == 6); - fail_unless!(heap.len() == 5); - fail_unless!(heap.replace(4) == 5); - fail_unless!(heap.len() == 5); - fail_unless!(heap.replace(1) == 4); - fail_unless!(heap.len() == 5); + assert!(heap.len() == 5); + assert!(heap.replace(6) == 5); + assert!(heap.len() == 5); + assert!(heap.replace(0) == 6); + assert!(heap.len() == 5); + assert!(heap.replace(4) == 5); + assert!(heap.len() == 5); + assert!(heap.replace(1) == 4); + assert!(heap.len() == 5); } fn check_to_vec(data: ~[int]) { let heap = from_vec(data); - fail_unless!(merge_sort(heap.to_vec(), le) == merge_sort(data, le)); - fail_unless!(heap.to_sorted_vec() == merge_sort(data, le)); + assert!(merge_sort(heap.to_vec(), le) == merge_sort(data, le)); + assert!(heap.to_sorted_vec() == merge_sort(data, le)); } #[test] @@ -305,7 +305,7 @@ mod tests { #[test] fn test_empty_maybe_pop() { let mut heap = new::(); - fail_unless!(heap.maybe_pop().is_none()); + assert!(heap.maybe_pop().is_none()); } #[test] @@ -316,7 +316,7 @@ mod tests { #[test] fn test_empty_maybe_top() { let empty = new::(); - fail_unless!(empty.maybe_top().is_none()); + assert!(empty.maybe_top().is_none()); } #[test] diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 51cf08c8ca1fe..61f50069d8997 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -704,7 +704,7 @@ pub mod node { */ pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint, char_len: uint) -> @Node { - fail_unless!((byte_start + byte_len <= str::len(*str))); + assert!((byte_start + byte_len <= str::len(*str))); let candidate = @Leaf(Leaf { byte_offset: byte_start, byte_len: byte_len, @@ -1313,8 +1313,8 @@ mod tests { #[test] fn trivial() { - fail_unless!(char_len(empty()) == 0u); - fail_unless!(byte_len(empty()) == 0u); + assert!(char_len(empty()) == 0u); + assert!(byte_len(empty()) == 0u); } #[test] @@ -1322,8 +1322,8 @@ mod tests { let sample = @~"0123456789ABCDE"; let r = of_str(sample); - fail_unless!(char_len(r) == str::char_len(*sample)); - fail_unless!(rope_to_string(r) == *sample); + assert!(char_len(r) == str::char_len(*sample)); + assert!(rope_to_string(r) == *sample); } #[test] @@ -1338,8 +1338,8 @@ mod tests { } let sample = @*buf; let r = of_str(sample); - fail_unless!(char_len(r) == str::char_len(*sample)); - fail_unless!(rope_to_string(r) == *sample); + assert!(char_len(r) == str::char_len(*sample)); + assert!(rope_to_string(r) == *sample); let mut string_iter = 0u; let string_len = str::len(*sample); @@ -1359,7 +1359,7 @@ mod tests { } } - fail_unless!(equal); + assert!(equal); } #[test] @@ -1384,7 +1384,7 @@ mod tests { } } - fail_unless!(len == str::char_len(*sample)); + assert!(len == str::char_len(*sample)); } #[test] @@ -1405,11 +1405,11 @@ mod tests { while i < 8 { r2 = append_rope(r2, r2); i+= 1;} - fail_unless!(eq(r1, r2)); + assert!(eq(r1, r2)); let r3 = bal(r2); - fail_unless!(char_len(r1) == char_len(r3)); + assert!(char_len(r1) == char_len(r3)); - fail_unless!(eq(r1, r3)); + assert!(eq(r1, r3)); } #[test] @@ -1426,23 +1426,23 @@ mod tests { for uint::range(0u, char_len(r)) |i| { r2 = append_char(r2, char_at(r, i)); } - fail_unless!(eq(r, r2)); + assert!(eq(r, r2)); let mut r3 = empty(); for uint::range(0u, char_len(r)) |i| { r3 = prepend_char(r3, char_at(r, char_len(r) - i - 1u)); } - fail_unless!(eq(r, r3)); + assert!(eq(r, r3)); //Additional sanity checks let balr = bal(r); let bal2 = bal(r2); let bal3 = bal(r3); - fail_unless!(eq(r, balr)); - fail_unless!(eq(r, bal2)); - fail_unless!(eq(r, bal3)); - fail_unless!(eq(r2, r3)); - fail_unless!(eq(bal2, bal3)); + assert!(eq(r, balr)); + assert!(eq(r, bal2)); + assert!(eq(r, bal3)); + assert!(eq(r2, r3)); + assert!(eq(bal2, bal3)); } #[test] @@ -1457,6 +1457,6 @@ mod tests { //Same rope, obtained with rope::concat let r2 = concat(vec::from_elem(10u, chunk)); - fail_unless!(eq(r, r2)); + assert!(eq(r, r2)); } } diff --git a/src/libstd/semver.rs b/src/libstd/semver.rs index 50579db47072b..83fab365d8d62 100644 --- a/src/libstd/semver.rs +++ b/src/libstd/semver.rs @@ -239,74 +239,74 @@ pub fn parse(s: &str) -> Option { #[test] fn test_parse() { - fail_unless!(parse("") == None); - fail_unless!(parse(" ") == None); - fail_unless!(parse("1") == None); - fail_unless!(parse("1.2") == None); - fail_unless!(parse("1.2") == None); - fail_unless!(parse("1") == None); - fail_unless!(parse("1.2") == None); - fail_unless!(parse("1.2.3-") == None); - fail_unless!(parse("a.b.c") == None); - fail_unless!(parse("1.2.3 abc") == None); - - fail_unless!(parse("1.2.3") == Some(Version { + assert!(parse("") == None); + assert!(parse(" ") == None); + assert!(parse("1") == None); + assert!(parse("1.2") == None); + assert!(parse("1.2") == None); + assert!(parse("1") == None); + assert!(parse("1.2") == None); + assert!(parse("1.2.3-") == None); + assert!(parse("a.b.c") == None); + assert!(parse("1.2.3 abc") == None); + + assert!(parse("1.2.3") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[], build: ~[], })); - fail_unless!(parse(" 1.2.3 ") == Some(Version { + assert!(parse(" 1.2.3 ") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[], build: ~[], })); - fail_unless!(parse("1.2.3-alpha1") == Some(Version { + assert!(parse("1.2.3-alpha1") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[AlphaNumeric(~"alpha1")], build: ~[] })); - fail_unless!(parse(" 1.2.3-alpha1 ") == Some(Version { + assert!(parse(" 1.2.3-alpha1 ") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[AlphaNumeric(~"alpha1")], build: ~[] })); - fail_unless!(parse("1.2.3+build5") == Some(Version { + assert!(parse("1.2.3+build5") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[], build: ~[AlphaNumeric(~"build5")] })); - fail_unless!(parse(" 1.2.3+build5 ") == Some(Version { + assert!(parse(" 1.2.3+build5 ") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[], build: ~[AlphaNumeric(~"build5")] })); - fail_unless!(parse("1.2.3-alpha1+build5") == Some(Version { + assert!(parse("1.2.3-alpha1+build5") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[AlphaNumeric(~"alpha1")], build: ~[AlphaNumeric(~"build5")] })); - fail_unless!(parse(" 1.2.3-alpha1+build5 ") == Some(Version { + assert!(parse(" 1.2.3-alpha1+build5 ") == Some(Version { major: 1u, minor: 2u, patch: 3u, pre: ~[AlphaNumeric(~"alpha1")], build: ~[AlphaNumeric(~"build5")] })); - fail_unless!(parse("1.2.3-1.alpha1.9+build5.7.3aedf ") == Some(Version { + assert!(parse("1.2.3-1.alpha1.9+build5.7.3aedf ") == Some(Version { major: 1u, minor: 2u, patch: 3u, @@ -320,54 +320,54 @@ fn test_parse() { #[test] fn test_eq() { - fail_unless!(parse("1.2.3") == parse("1.2.3")); - fail_unless!(parse("1.2.3-alpha1") == parse("1.2.3-alpha1")); + assert!(parse("1.2.3") == parse("1.2.3")); + assert!(parse("1.2.3-alpha1") == parse("1.2.3-alpha1")); } #[test] fn test_ne() { - fail_unless!(parse("0.0.0") != parse("0.0.1")); - fail_unless!(parse("0.0.0") != parse("0.1.0")); - fail_unless!(parse("0.0.0") != parse("1.0.0")); - fail_unless!(parse("1.2.3-alpha") != parse("1.2.3-beta")); + assert!(parse("0.0.0") != parse("0.0.1")); + assert!(parse("0.0.0") != parse("0.1.0")); + assert!(parse("0.0.0") != parse("1.0.0")); + assert!(parse("1.2.3-alpha") != parse("1.2.3-beta")); } #[test] fn test_lt() { - fail_unless!(parse("0.0.0") < parse("1.2.3-alpha2")); - fail_unless!(parse("1.0.0") < parse("1.2.3-alpha2")); - fail_unless!(parse("1.2.0") < parse("1.2.3-alpha2")); - fail_unless!(parse("1.2.3-alpha1") < parse("1.2.3")); - fail_unless!(parse("1.2.3-alpha1") < parse("1.2.3-alpha2")); - fail_unless!(!(parse("1.2.3-alpha2") < parse("1.2.3-alpha2"))); + assert!(parse("0.0.0") < parse("1.2.3-alpha2")); + assert!(parse("1.0.0") < parse("1.2.3-alpha2")); + assert!(parse("1.2.0") < parse("1.2.3-alpha2")); + assert!(parse("1.2.3-alpha1") < parse("1.2.3")); + assert!(parse("1.2.3-alpha1") < parse("1.2.3-alpha2")); + assert!(!(parse("1.2.3-alpha2") < parse("1.2.3-alpha2"))); } #[test] fn test_le() { - fail_unless!(parse("0.0.0") <= parse("1.2.3-alpha2")); - fail_unless!(parse("1.0.0") <= parse("1.2.3-alpha2")); - fail_unless!(parse("1.2.0") <= parse("1.2.3-alpha2")); - fail_unless!(parse("1.2.3-alpha1") <= parse("1.2.3-alpha2")); - fail_unless!(parse("1.2.3-alpha2") <= parse("1.2.3-alpha2")); + assert!(parse("0.0.0") <= parse("1.2.3-alpha2")); + assert!(parse("1.0.0") <= parse("1.2.3-alpha2")); + assert!(parse("1.2.0") <= parse("1.2.3-alpha2")); + assert!(parse("1.2.3-alpha1") <= parse("1.2.3-alpha2")); + assert!(parse("1.2.3-alpha2") <= parse("1.2.3-alpha2")); } #[test] fn test_gt() { - fail_unless!(parse("1.2.3-alpha2") > parse("0.0.0")); - fail_unless!(parse("1.2.3-alpha2") > parse("1.0.0")); - fail_unless!(parse("1.2.3-alpha2") > parse("1.2.0")); - fail_unless!(parse("1.2.3-alpha2") > parse("1.2.3-alpha1")); - fail_unless!(parse("1.2.3") > parse("1.2.3-alpha2")); - fail_unless!(!(parse("1.2.3-alpha2") > parse("1.2.3-alpha2"))); + assert!(parse("1.2.3-alpha2") > parse("0.0.0")); + assert!(parse("1.2.3-alpha2") > parse("1.0.0")); + assert!(parse("1.2.3-alpha2") > parse("1.2.0")); + assert!(parse("1.2.3-alpha2") > parse("1.2.3-alpha1")); + assert!(parse("1.2.3") > parse("1.2.3-alpha2")); + assert!(!(parse("1.2.3-alpha2") > parse("1.2.3-alpha2"))); } #[test] fn test_ge() { - fail_unless!(parse("1.2.3-alpha2") >= parse("0.0.0")); - fail_unless!(parse("1.2.3-alpha2") >= parse("1.0.0")); - fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.0")); - fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha1")); - fail_unless!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha2")); + assert!(parse("1.2.3-alpha2") >= parse("0.0.0")); + assert!(parse("1.2.3-alpha2") >= parse("1.0.0")); + assert!(parse("1.2.3-alpha2") >= parse("1.2.0")); + assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha1")); + assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha2")); } #[test] @@ -388,7 +388,7 @@ fn test_spec_order() { while i < vs.len() { let a = parse(vs[i-1]).get(); let b = parse(vs[i]).get(); - fail_unless!(a < b); + assert!(a < b); i += 1; } } diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index b603e2eb1cc66..1a2d4a87d9886 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -74,7 +74,7 @@ pub fn sha1() -> @Sha1 { work_buf: @mut ~[u32]}; fn add_input(st: &mut Sha1State, msg: &const [u8]) { - fail_unless!((!st.computed)); + assert!((!st.computed)); for vec::each_const(msg) |element| { st.msg_block[st.msg_block_idx] = *element; st.msg_block_idx += 1u; @@ -90,8 +90,8 @@ pub fn sha1() -> @Sha1 { } } fn process_msg_block(st: &mut Sha1State) { - fail_unless!((vec::len(st.h) == digest_buf_len)); - fail_unless!((vec::uniq_len(st.work_buf) == work_buf_len)); + assert!((vec::len(st.h) == digest_buf_len)); + assert!((vec::uniq_len(st.work_buf) == work_buf_len)); let mut t: int; // Loop counter let mut w = st.work_buf; @@ -192,7 +192,7 @@ pub fn sha1() -> @Sha1 { * can be assumed that the message digest has been computed. */ fn pad_msg(st: &mut Sha1State) { - fail_unless!((vec::len((*st).msg_block) == msg_block_len)); + assert!((vec::len((*st).msg_block) == msg_block_len)); /* * Check to see if the current message block is too small to hold @@ -230,7 +230,7 @@ pub fn sha1() -> @Sha1 { impl Sha1 for Sha1State { fn reset(&mut self) { - fail_unless!((vec::len(self.h) == digest_buf_len)); + assert!((vec::len(self.h) == digest_buf_len)); self.len_low = 0u32; self.len_high = 0u32; self.msg_block_idx = 0u; @@ -366,13 +366,13 @@ mod tests { ]; let tests = fips_180_1_tests + wikipedia_tests; fn check_vec_eq(v0: ~[u8], v1: ~[u8]) { - fail_unless!((vec::len::(v0) == vec::len::(v1))); + assert!((vec::len::(v0) == vec::len::(v1))); let len = vec::len::(v0); let mut i = 0u; while i < len { let a = v0[i]; let b = v1[i]; - fail_unless!((a == b)); + assert!((a == b)); i += 1u; } } @@ -385,8 +385,8 @@ mod tests { check_vec_eq(t.output, out); let out_str = sh.result_str(); - fail_unless!((out_str.len() == 40)); - fail_unless!((out_str == t.output_str)); + assert!((out_str.len() == 40)); + assert!((out_str == t.output_str)); sh.reset(); } @@ -406,8 +406,8 @@ mod tests { check_vec_eq(t.output, out); let out_str = sh.result_str(); - fail_unless!((out_str.len() == 40)); - fail_unless!((out_str == t.output_str)); + assert!((out_str.len() == 40)); + assert!((out_str == t.output_str)); sh.reset(); } diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 16f7c0ba860be..b6c5ec03068cd 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -177,9 +177,9 @@ mod tests { #[test] fn test_find_mut() { let mut m = SmallIntMap::new(); - fail_unless!(m.insert(1, 12)); - fail_unless!(m.insert(2, 8)); - fail_unless!(m.insert(5, 14)); + assert!(m.insert(1, 12)); + assert!(m.insert(2, 8)); + assert!(m.insert(5, 14)); let new = 100; match m.find_mut(&5) { None => fail!(), Some(x) => *x = new @@ -190,30 +190,30 @@ mod tests { #[test] fn test_len() { let mut map = SmallIntMap::new(); - fail_unless!(map.len() == 0); - fail_unless!(map.is_empty()); - fail_unless!(map.insert(5, 20)); - fail_unless!(map.len() == 1); - fail_unless!(!map.is_empty()); - fail_unless!(map.insert(11, 12)); - fail_unless!(map.len() == 2); - fail_unless!(!map.is_empty()); - fail_unless!(map.insert(14, 22)); - fail_unless!(map.len() == 3); - fail_unless!(!map.is_empty()); + assert!(map.len() == 0); + assert!(map.is_empty()); + assert!(map.insert(5, 20)); + assert!(map.len() == 1); + assert!(!map.is_empty()); + assert!(map.insert(11, 12)); + assert!(map.len() == 2); + assert!(!map.is_empty()); + assert!(map.insert(14, 22)); + assert!(map.len() == 3); + assert!(!map.is_empty()); } #[test] fn test_clear() { let mut map = SmallIntMap::new(); - fail_unless!(map.insert(5, 20)); - fail_unless!(map.insert(11, 12)); - fail_unless!(map.insert(14, 22)); + assert!(map.insert(5, 20)); + assert!(map.insert(11, 12)); + assert!(map.insert(14, 22)); map.clear(); - fail_unless!(map.is_empty()); - fail_unless!(map.find(&5).is_none()); - fail_unless!(map.find(&11).is_none()); - fail_unless!(map.find(&14).is_none()); + assert!(map.is_empty()); + assert!(map.find(&5).is_none()); + assert!(map.find(&11).is_none()); + assert!(map.find(&14).is_none()); } #[test] @@ -238,11 +238,11 @@ mod tests { map.update_with_key(3, 2, addMoreToCount); // check the total counts - fail_unless!(map.find(&3).get() == &10); - fail_unless!(map.find(&5).get() == &3); - fail_unless!(map.find(&9).get() == &1); + assert!(map.find(&3).get() == &10); + assert!(map.find(&5).get() == &3); + assert!(map.find(&9).get() == &1); // sadly, no sevens were counted - fail_unless!(map.find(&7).is_none()); + assert!(map.find(&7).is_none()); } } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 761a17352a979..40a1289517567 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -223,7 +223,7 @@ pub fn tim_sort(array: &mut [T]) { fn binarysort(array: &mut [T], start: uint) { let size = array.len(); let mut start = start; - fail_unless!(start <= size); + assert!(start <= size); if start == 0 { start += 1; } @@ -231,7 +231,7 @@ fn binarysort(array: &mut [T], start: uint) { let pivot = array[start]; let mut left = 0; let mut right = start; - fail_unless!(left <= right); + assert!(left <= right); while left < right { let mid = (left + right) >> 1; @@ -241,7 +241,7 @@ fn binarysort(array: &mut [T], start: uint) { left = mid+1; } } - fail_unless!(left == right); + assert!(left == right); let mut n = start-left; copy_vec(array, left+1, array, left, n); @@ -272,7 +272,7 @@ fn min_run_length(n: uint) -> uint { fn count_run_ascending(array: &mut [T]) -> uint { let size = array.len(); - fail_unless!(size > 0); + assert!(size > 0); if size == 1 { return 1; } let mut run = 2; @@ -295,7 +295,7 @@ fn gallop_left(key: &const T, hint: uint) -> uint { let size = array.len(); - fail_unless!(size != 0 && hint < size); + assert!(size != 0 && hint < size); let mut last_ofs = 0; let mut ofs = 1; @@ -326,7 +326,7 @@ fn gallop_left(key: &const T, last_ofs = hint - ofs; ofs = hint - tmp; } - fail_unless!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); + assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); last_ofs += 1; while last_ofs < ofs { @@ -337,7 +337,7 @@ fn gallop_left(key: &const T, ofs = m; } } - fail_unless!(last_ofs == ofs); + assert!(last_ofs == ofs); return ofs; } @@ -346,7 +346,7 @@ fn gallop_right(key: &const T, hint: uint) -> uint { let size = array.len(); - fail_unless!(size != 0 && hint < size); + assert!(size != 0 && hint < size); let mut last_ofs = 0; let mut ofs = 1; @@ -378,7 +378,7 @@ fn gallop_right(key: &const T, ofs = hint - tmp; } - fail_unless!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); + assert!((last_ofs < ofs || last_ofs+1 < ofs+1) && ofs <= size); last_ofs += 1; while last_ofs < ofs { @@ -390,7 +390,7 @@ fn gallop_right(key: &const T, ofs = m; } } - fail_unless!(last_ofs == ofs); + assert!(last_ofs == ofs); return ofs; } @@ -420,16 +420,16 @@ impl MergeState { fn merge_at(&mut self, n: uint, array: &mut [T]) { let mut size = self.runs.len(); - fail_unless!(size >= 2); - fail_unless!(n == size-2 || n == size-3); + assert!(size >= 2); + assert!(n == size-2 || n == size-3); let mut b1 = self.runs[n].base; let mut l1 = self.runs[n].len; let b2 = self.runs[n+1].base; let l2 = self.runs[n+1].len; - fail_unless!(l1 > 0 && l2 > 0); - fail_unless!(b1 + l1 == b2); + assert!(l1 > 0 && l2 > 0); + assert!(b1 + l1 == b2); self.runs[n].len = l1 + l2; if n == size-3 { @@ -458,7 +458,7 @@ impl MergeState { fn merge_lo(&mut self, array: &mut [T], base1: uint, len1: uint, base2: uint, len2: uint) { - fail_unless!(len1 != 0 && len2 != 0 && base1+len1 == base2); + assert!(len1 != 0 && len2 != 0 && base1+len1 == base2); let mut tmp = ~[]; for uint::range(base1, base1+len1) |i| { @@ -491,7 +491,7 @@ impl MergeState { let mut break_outer = false; loop { - fail_unless!(len1 > 1 && len2 != 0); + assert!(len1 > 1 && len2 != 0); if array[c2] < tmp[c1] { array[dest] <-> array[c2]; dest += 1; c2 += 1; len2 -= 1; @@ -515,7 +515,7 @@ impl MergeState { // Start to gallop loop { - fail_unless!(len1 > 1 && len2 != 0); + assert!(len1 > 1 && len2 != 0); let tmp_view = vec::const_slice(tmp, c1, c1+len1); count1 = gallop_right(&const array[c2], tmp_view, 0); @@ -550,21 +550,21 @@ impl MergeState { self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop }; if len1 == 1 { - fail_unless!(len2 > 0); + assert!(len2 > 0); copy_vec(array, dest, array, c2, len2); array[dest+len2] <-> tmp[c1]; } else if len1 == 0 { fail!(~"Comparison violates its contract!"); } else { - fail_unless!(len2 == 0); - fail_unless!(len1 > 1); + assert!(len2 == 0); + assert!(len1 > 1); copy_vec(array, dest, tmp, c1, len1); } } fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint, base2: uint, len2: uint) { - fail_unless!(len1 != 1 && len2 != 0 && base1 + len1 == base2); + assert!(len1 != 1 && len2 != 0 && base1 + len1 == base2); let mut tmp = ~[]; for uint::range(base2, base2+len2) |i| { @@ -599,7 +599,7 @@ impl MergeState { let mut break_outer = false; loop { - fail_unless!(len1 != 0 && len2 > 1); + assert!(len1 != 0 && len2 > 1); if tmp[c2] < array[c1] { array[dest] <-> array[c1]; dest -= 1; c1 -= 1; len1 -= 1; @@ -623,7 +623,7 @@ impl MergeState { // Start to gallop loop { - fail_unless!(len2 > 1 && len1 != 0); + assert!(len2 > 1 && len1 != 0); let tmp_view = vec::mut_slice(array, base1, base1+len1); count1 = len1 - gallop_right( @@ -669,7 +669,7 @@ impl MergeState { self.min_gallop = if min_gallop < 1 { 1 } else { min_gallop }; if len2 == 1 { - fail_unless!(len1 > 0); + assert!(len1 > 0); dest -= len1; c1 -= len1; copy_vec(array, dest+1, array, c1+1, len1); @@ -677,8 +677,8 @@ impl MergeState { } else if len2 == 0 { fail!(~"Comparison violates its contract!"); } else { - fail_unless!(len1 == 0); - fail_unless!(len2 != 0); + assert!(len1 == 0); + assert!(len2 != 0); copy_vec(array, dest-(len2-1), tmp, 0, len2); } } @@ -718,7 +718,7 @@ fn copy_vec(dest: &mut [T], from: &const [T], s2: uint, len: uint) { - fail_unless!(s1+len <= dest.len() && s2+len <= from.len()); + assert!(s1+len <= dest.len() && s2+len <= from.len()); let mut slice = ~[]; for uint::range(s2, s2+len) |i| { @@ -742,7 +742,7 @@ mod test_qsort3 { let mut i = 0; while i < len { // debug!(v2[i]); - fail_unless!((v2[i] == v1[i])); + assert!((v2[i] == v1[i])); i += 1; } } @@ -787,7 +787,7 @@ mod test_qsort { let mut i = 0u; while i < len { // debug!(v2[i]); - fail_unless!((v2[i] == v1[i])); + assert!((v2[i] == v1[i])); i += 1; } } @@ -832,7 +832,7 @@ mod test_qsort { for vec::each(pairs) |p| { let (a, b) = *p; debug!("%d %d", a, b); - fail_unless!((a == b)); + assert!((a == b)); } } } @@ -853,7 +853,7 @@ mod tests { let mut i = 0u; while i < len { debug!(v3[i]); - fail_unless!((v3[i] == v2[i])); + assert!((v3[i] == v2[i])); i += 1; } } @@ -880,7 +880,7 @@ mod tests { pub fn le(a: &int, b: &int) -> bool { *a <= *b } let mut v1 = ~[3, 2, 1]; let v2 = merge_sort(v1, le); - fail_unless!(v2 == ~[1, 2, 3]); + assert!(v2 == ~[1, 2, 3]); } #[test] @@ -901,7 +901,7 @@ mod tests { let names2 = ~["Alex Andy", "Jack Brown", "joe bob", "Joe Bob", "JOE Bob", "JOE BOB", "Sally Mae"]; let names3 = merge_sort(names1, ile); - fail_unless!(names3 == names2); + assert!(names3 == names2); } } @@ -938,7 +938,7 @@ mod test_tim_sort { let mut i = 0u; while i < len { // debug!(v2[i]); - fail_unless!((v2[i] == v1[i])); + assert!((v2[i] == v1[i])); i += 1u; } } diff --git a/src/libstd/stats.rs b/src/libstd/stats.rs index 04059a4951190..6513a671ab343 100644 --- a/src/libstd/stats.rs +++ b/src/libstd/stats.rs @@ -36,22 +36,22 @@ impl<'self> Stats for &'self [f64] { } fn min(self) -> f64 { - fail_unless!(self.len() != 0); + assert!(self.len() != 0); vec::foldl(self[0], self, |p,q| cmp::min(p, *q)) } fn max(self) -> f64 { - fail_unless!(self.len() != 0); + assert!(self.len() != 0); vec::foldl(self[0], self, |p,q| cmp::max(p, *q)) } fn mean(self) -> f64 { - fail_unless!(self.len() != 0); + assert!(self.len() != 0); self.sum() / (self.len() as f64) } fn median(self) -> f64 { - fail_unless!(self.len() != 0); + assert!(self.len() != 0); let mut tmp = vec::from_slice(self); sort::tim_sort(tmp); if tmp.len() & 1 == 0 { diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index ea9455b1e981c..99b3a122d9f70 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -595,7 +595,7 @@ pub impl RWlock { do task::unkillable { let mut first_reader = false; do self.state.with |state| { - fail_unless!(!state.read_mode); + assert!(!state.read_mode); state.read_mode = true; first_reader = (state.read_count == 0); state.read_count += 1; @@ -626,8 +626,8 @@ impl<'self> Drop for RWlockReleaseRead<'self> { do task::unkillable { let mut last_reader = false; do self.lock.state.with |state| { - fail_unless!(state.read_mode); - fail_unless!(state.read_count > 0); + assert!(state.read_mode); + assert!(state.read_count > 0); state.read_count -= 1; if state.read_count == 0 { last_reader = true; @@ -663,7 +663,7 @@ impl<'self> Drop for RWlockReleaseDowngrade<'self> { let mut writer_or_last_reader = false; do self.lock.state.with |state| { if state.read_mode { - fail_unless!(state.read_count > 0); + assert!(state.read_count > 0); state.read_count -= 1; if state.read_count == 0 { // Case 1: Writer downgraded & was the last reader @@ -852,7 +852,7 @@ mod tests { access_shared(sharedstate, m, 10); let _ = p.recv(); - fail_unless!(*sharedstate == 20); + assert!(*sharedstate == 20); fn access_shared(sharedstate: &mut int, m: &Mutex, n: uint) { for n.times { @@ -874,7 +874,7 @@ mod tests { do task::spawn || { do m2.lock_cond |cond| { let woken = cond.signal(); - fail_unless!(woken); + assert!(woken); } } cond.wait(); @@ -892,7 +892,7 @@ mod tests { let _ = port.recv(); // Wait until child gets in the mutex do m.lock_cond |cond| { let woken = cond.signal(); - fail_unless!(woken); + assert!(woken); } let _ = port.recv(); // Wait until child wakes up } @@ -918,7 +918,7 @@ mod tests { for ports.each |port| { let _ = port.recv(); } do m.lock_cond |cond| { let num_woken = cond.broadcast(); - fail_unless!(num_woken == num_waiters); + assert!(num_woken == num_waiters); } // wait until all children wake up for ports.each |port| { let _ = port.recv(); } @@ -939,7 +939,7 @@ mod tests { do m.lock_cond |_x| { } }; do m2.lock_cond |cond| { - fail_unless!(!cond.signal()); + assert!(!cond.signal()); } } #[test] #[ignore(cfg(windows))] @@ -953,7 +953,7 @@ mod tests { fail!(); } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); // child task must have finished by the time try returns do m.lock { } } @@ -976,11 +976,11 @@ mod tests { cond.wait(); // block forever } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); // child task must have finished by the time try returns do m.lock_cond |cond| { let woken = cond.signal(); - fail_unless!(!woken); + assert!(!woken); } } #[test] #[ignore(cfg(windows))] @@ -1013,12 +1013,12 @@ mod tests { c.send(sibling_convos); // let parent wait on all children fail!(); }; - fail_unless!(result.is_err()); + assert!(result.is_err()); // child task must have finished by the time try returns for vec::each(p.recv()) |p| { p.recv(); } // wait on all its siblings do m.lock_cond |cond| { let woken = cond.broadcast(); - fail_unless!(woken == 0); + assert!(woken == 0); } struct SendOnFailure { c: comm::Chan<()>, @@ -1069,7 +1069,7 @@ mod tests { } } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); } #[test] #[ignore(cfg(windows))] pub fn test_mutex_no_condvars() { @@ -1077,17 +1077,17 @@ mod tests { let m = ~mutex_with_condvars(0); do m.lock_cond |cond| { cond.wait(); } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); let result = do task::try { let m = ~mutex_with_condvars(0); do m.lock_cond |cond| { cond.signal(); } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); let result = do task::try { let m = ~mutex_with_condvars(0); do m.lock_cond |cond| { cond.broadcast(); } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); } /************************************************************************ * Reader/writer lock tests @@ -1129,7 +1129,7 @@ mod tests { access_shared(sharedstate, x, mode2, 10); let _ = p.recv(); - fail_unless!(*sharedstate == 20); + assert!(*sharedstate == 20); fn access_shared(sharedstate: &mut int, x: &RWlock, mode: RWlockMode, n: uint) { @@ -1223,7 +1223,7 @@ mod tests { do task::spawn || { do x2.write_cond |cond| { let woken = cond.signal(); - fail_unless!(woken); + assert!(woken); } } cond.wait(); @@ -1242,7 +1242,7 @@ mod tests { do x.read { } // Must be able to get in as a reader in the meantime do x.write_cond |cond| { // Or as another writer let woken = cond.signal(); - fail_unless!(woken); + assert!(woken); } let _ = port.recv(); // Wait until child wakes up do x.read { } // Just for good measure @@ -1281,7 +1281,7 @@ mod tests { for ports.each |port| { let _ = port.recv(); } do lock_cond(x, dg2) |cond| { let num_woken = cond.broadcast(); - fail_unless!(num_woken == num_waiters); + assert!(num_woken == num_waiters); } // wait until all children wake up for ports.each |port| { let _ = port.recv(); } @@ -1308,7 +1308,7 @@ mod tests { fail!(); } }; - fail_unless!(result.is_err()); + assert!(result.is_err()); // child task must have finished by the time try returns do lock_rwlock_in_mode(x, mode2) { } } diff --git a/src/libstd/task_pool.rs b/src/libstd/task_pool.rs index dbfe3d6a8b57f..aed6721b78ea1 100644 --- a/src/libstd/task_pool.rs +++ b/src/libstd/task_pool.rs @@ -49,7 +49,7 @@ pub impl TaskPool { opt_sched_mode: Option, init_fn_factory: ~fn() -> ~fn(uint) -> T) -> TaskPool { - fail_unless!(n_tasks >= 1); + assert!(n_tasks >= 1); let channels = do vec::from_fn(n_tasks) |i| { let (port, chan) = comm::stream::>(); diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs index 7704ec158e565..895ccbc820b16 100644 --- a/src/libstd/tempfile.rs +++ b/src/libstd/tempfile.rs @@ -30,5 +30,5 @@ pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option { fn test_mkdtemp() { let p = mkdtemp(&Path("."), "foobar").unwrap(); os::remove_dir(&p); - fail_unless!(str::ends_with(p.to_str(), "foobar")); + assert!(str::ends_with(p.to_str(), "foobar")); } diff --git a/src/libstd/term.rs b/src/libstd/term.rs index a6c8884e05d4d..022f1f8564ece 100644 --- a/src/libstd/term.rs +++ b/src/libstd/term.rs @@ -60,7 +60,7 @@ pub fn color_supported() -> bool { } pub fn set_color(writer: @io::Writer, first_char: u8, color: u8) { - fail_unless!((color < 16u8)); + assert!((color < 16u8)); esc(writer); let mut color = color; if color >= 8u8 { writer.write(~['1' as u8, ';' as u8]); color -= 8u8; } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 853a17abb55bb..7c5591d839e20 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -282,7 +282,7 @@ pub fn run_tests_console(opts: &TestOpts, run_tests(opts, tests, |x| callback(&x, st)); - fail_unless!(st.passed + st.failed + + assert!(st.passed + st.failed + st.ignored + st.benchmarked == st.total); let success = st.failed == 0u; @@ -403,7 +403,7 @@ fn should_sort_failures_before_printing_them() { let apos = str::find_str(s, ~"a").get(); let bpos = str::find_str(s, ~"b").get(); - fail_unless!(apos < bpos); + assert!(apos < bpos); } fn use_color() -> bool { return get_concurrency() == 1; } @@ -797,7 +797,7 @@ mod tests { let ch = SharedChan(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - fail_unless!(res != TrOk); + assert!(res != TrOk); } #[test] @@ -815,7 +815,7 @@ mod tests { let ch = SharedChan(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - fail_unless!(res == TrIgnored); + assert!(res == TrIgnored); } #[test] @@ -834,7 +834,7 @@ mod tests { let ch = SharedChan(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - fail_unless!(res == TrOk); + assert!(res == TrOk); } #[test] @@ -852,7 +852,7 @@ mod tests { let ch = SharedChan(ch); run_test(false, desc, ch); let (_, res) = p.recv(); - fail_unless!(res == TrFailed); + assert!(res == TrFailed); } #[test] @@ -862,7 +862,7 @@ mod tests { either::Left(copy o) => o, _ => fail!(~"Malformed arg in first_free_arg_should_be_a_filter") }; - fail_unless!(~"filter" == opts.filter.get()); + assert!(~"filter" == opts.filter.get()); } #[test] @@ -872,7 +872,7 @@ mod tests { either::Left(copy o) => o, _ => fail!(~"Malformed arg in parse_ignored_flag") }; - fail_unless!((opts.run_ignored)); + assert!((opts.run_ignored)); } #[test] @@ -912,9 +912,9 @@ mod tests { ]; let filtered = filter_tests(&opts, tests); - fail_unless!((vec::len(filtered) == 1)); - fail_unless!((filtered[0].desc.name.to_str() == ~"1")); - fail_unless!((filtered[0].desc.ignore == false)); + assert!((vec::len(filtered) == 1)); + assert!((filtered[0].desc.name.to_str() == ~"1")); + assert!((filtered[0].desc.ignore == false)); } #[test] @@ -969,7 +969,7 @@ mod tests { for vec::each(pairs) |p| { match *p { (ref a, ref b) => { - fail_unless!((*a == b.desc.name.to_str())); + assert!((*a == b.desc.name.to_str())); } } } diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 9ac302ed890ca..3af193e87486b 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -53,7 +53,7 @@ pub struct Timespec { sec: i64, nsec: i32 } */ pub impl Timespec { fn new(sec: i64, nsec: i32) -> Timespec { - fail_unless!(nsec >= 0 && nsec < NSEC_PER_SEC); + assert!(nsec >= 0 && nsec < NSEC_PER_SEC); Timespec { sec: sec, nsec: nsec } } } @@ -883,17 +883,17 @@ mod tests { let tv1 = get_time(); debug!("tv1=%? sec + %? nsec", tv1.sec as uint, tv1.nsec as uint); - fail_unless!(tv1.sec > some_recent_date); - fail_unless!(tv1.nsec < 1000000000i32); + assert!(tv1.sec > some_recent_date); + assert!(tv1.nsec < 1000000000i32); let tv2 = get_time(); debug!("tv2=%? sec + %? nsec", tv2.sec as uint, tv2.nsec as uint); - fail_unless!(tv2.sec >= tv1.sec); - fail_unless!(tv2.sec < some_future_date); - fail_unless!(tv2.nsec < 1000000000i32); + assert!(tv2.sec >= tv1.sec); + assert!(tv2.sec < some_future_date); + assert!(tv2.nsec < 1000000000i32); if tv2.sec == tv1.sec { - fail_unless!(tv2.nsec >= tv1.nsec); + assert!(tv2.nsec >= tv1.nsec); } } @@ -902,16 +902,16 @@ mod tests { let ns1 = precise_time_ns(); debug!("s0=%s sec", float::to_str_digits(s0, 9u)); - fail_unless!(s0 > 0.); + assert!(s0 > 0.); let ns0 = (s0 * 1000000000.) as u64; debug!("ns0=%? ns", ns0); debug!("ns1=%? ns", ns0); - fail_unless!(ns1 >= ns0); + assert!(ns1 >= ns0); let ns2 = precise_time_ns(); debug!("ns2=%? ns", ns0); - fail_unless!(ns2 >= ns1); + assert!(ns2 >= ns1); } pub fn test_at_utc() { @@ -921,18 +921,18 @@ mod tests { let time = ::time::Timespec::new(1234567890, 54321); let utc = at_utc(time); - fail_unless!(utc.tm_sec == 30_i32); - fail_unless!(utc.tm_min == 31_i32); - fail_unless!(utc.tm_hour == 23_i32); - fail_unless!(utc.tm_mday == 13_i32); - fail_unless!(utc.tm_mon == 1_i32); - fail_unless!(utc.tm_year == 109_i32); - fail_unless!(utc.tm_wday == 5_i32); - fail_unless!(utc.tm_yday == 43_i32); - fail_unless!(utc.tm_isdst == 0_i32); - fail_unless!(utc.tm_gmtoff == 0_i32); - fail_unless!(utc.tm_zone == ~"UTC"); - fail_unless!(utc.tm_nsec == 54321_i32); + assert!(utc.tm_sec == 30_i32); + assert!(utc.tm_min == 31_i32); + assert!(utc.tm_hour == 23_i32); + assert!(utc.tm_mday == 13_i32); + assert!(utc.tm_mon == 1_i32); + assert!(utc.tm_year == 109_i32); + assert!(utc.tm_wday == 5_i32); + assert!(utc.tm_yday == 43_i32); + assert!(utc.tm_isdst == 0_i32); + assert!(utc.tm_gmtoff == 0_i32); + assert!(utc.tm_zone == ~"UTC"); + assert!(utc.tm_nsec == 54321_i32); } pub fn test_at() { @@ -944,23 +944,23 @@ mod tests { error!("time_at: %?", local); - fail_unless!(local.tm_sec == 30_i32); - fail_unless!(local.tm_min == 31_i32); - fail_unless!(local.tm_hour == 15_i32); - fail_unless!(local.tm_mday == 13_i32); - fail_unless!(local.tm_mon == 1_i32); - fail_unless!(local.tm_year == 109_i32); - fail_unless!(local.tm_wday == 5_i32); - fail_unless!(local.tm_yday == 43_i32); - fail_unless!(local.tm_isdst == 0_i32); - fail_unless!(local.tm_gmtoff == -28800_i32); + assert!(local.tm_sec == 30_i32); + assert!(local.tm_min == 31_i32); + assert!(local.tm_hour == 15_i32); + assert!(local.tm_mday == 13_i32); + assert!(local.tm_mon == 1_i32); + assert!(local.tm_year == 109_i32); + assert!(local.tm_wday == 5_i32); + assert!(local.tm_yday == 43_i32); + assert!(local.tm_isdst == 0_i32); + assert!(local.tm_gmtoff == -28800_i32); // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let zone = &local.tm_zone; - fail_unless!(*zone == ~"PST" || *zone == ~"Pacific Standard Time"); + assert!(*zone == ~"PST" || *zone == ~"Pacific Standard Time"); - fail_unless!(local.tm_nsec == 54321_i32); + assert!(local.tm_nsec == 54321_i32); } pub fn test_to_timespec() { @@ -970,8 +970,8 @@ mod tests { let time = ::time::Timespec::new(1234567890, 54321); let utc = at_utc(time); - fail_unless!(utc.to_timespec() == time); - fail_unless!(utc.to_local().to_timespec() == time); + assert!(utc.to_timespec() == time); + assert!(utc.to_local().to_timespec() == time); } pub fn test_conversions() { @@ -982,12 +982,12 @@ mod tests { let utc = at_utc(time); let local = at(time); - fail_unless!(local.to_local() == local); - fail_unless!(local.to_utc() == utc); - fail_unless!(local.to_utc().to_local() == local); - fail_unless!(utc.to_utc() == utc); - fail_unless!(utc.to_local() == local); - fail_unless!(utc.to_local().to_utc() == utc); + assert!(local.to_local() == local); + assert!(local.to_utc() == utc); + assert!(local.to_utc().to_local() == local); + assert!(utc.to_utc() == utc); + assert!(utc.to_local() == local); + assert!(utc.to_local().to_utc() == utc); } pub fn test_strptime() { @@ -996,41 +996,41 @@ mod tests { match strptime(~"", ~"") { Ok(ref tm) => { - fail_unless!(tm.tm_sec == 0_i32); - fail_unless!(tm.tm_min == 0_i32); - fail_unless!(tm.tm_hour == 0_i32); - fail_unless!(tm.tm_mday == 0_i32); - fail_unless!(tm.tm_mon == 0_i32); - fail_unless!(tm.tm_year == 0_i32); - fail_unless!(tm.tm_wday == 0_i32); - fail_unless!(tm.tm_isdst== 0_i32); - fail_unless!(tm.tm_gmtoff == 0_i32); - fail_unless!(tm.tm_zone == ~""); - fail_unless!(tm.tm_nsec == 0_i32); + assert!(tm.tm_sec == 0_i32); + assert!(tm.tm_min == 0_i32); + assert!(tm.tm_hour == 0_i32); + assert!(tm.tm_mday == 0_i32); + assert!(tm.tm_mon == 0_i32); + assert!(tm.tm_year == 0_i32); + assert!(tm.tm_wday == 0_i32); + assert!(tm.tm_isdst== 0_i32); + assert!(tm.tm_gmtoff == 0_i32); + assert!(tm.tm_zone == ~""); + assert!(tm.tm_nsec == 0_i32); } Err(_) => () } let format = ~"%a %b %e %T %Y"; - fail_unless!(strptime(~"", format) == Err(~"Invalid time")); - fail_unless!(strptime(~"Fri Feb 13 15:31:30", format) + assert!(strptime(~"", format) == Err(~"Invalid time")); + assert!(strptime(~"Fri Feb 13 15:31:30", format) == Err(~"Invalid time")); match strptime(~"Fri Feb 13 15:31:30 2009", format) { Err(copy e) => fail!(e), Ok(ref tm) => { - fail_unless!(tm.tm_sec == 30_i32); - fail_unless!(tm.tm_min == 31_i32); - fail_unless!(tm.tm_hour == 15_i32); - fail_unless!(tm.tm_mday == 13_i32); - fail_unless!(tm.tm_mon == 1_i32); - fail_unless!(tm.tm_year == 109_i32); - fail_unless!(tm.tm_wday == 5_i32); - fail_unless!(tm.tm_yday == 0_i32); - fail_unless!(tm.tm_isdst == 0_i32); - fail_unless!(tm.tm_gmtoff == 0_i32); - fail_unless!(tm.tm_zone == ~""); - fail_unless!(tm.tm_nsec == 0_i32); + assert!(tm.tm_sec == 30_i32); + assert!(tm.tm_min == 31_i32); + assert!(tm.tm_hour == 15_i32); + assert!(tm.tm_mday == 13_i32); + assert!(tm.tm_mon == 1_i32); + assert!(tm.tm_year == 109_i32); + assert!(tm.tm_wday == 5_i32); + assert!(tm.tm_yday == 0_i32); + assert!(tm.tm_isdst == 0_i32); + assert!(tm.tm_gmtoff == 0_i32); + assert!(tm.tm_zone == ~""); + assert!(tm.tm_nsec == 0_i32); } } @@ -1050,7 +1050,7 @@ mod tests { ~"Friday", ~"Saturday" ]) |day| { - fail_unless!(test(*day, ~"%A")); + assert!(test(*day, ~"%A")); } for vec::each([ @@ -1062,7 +1062,7 @@ mod tests { ~"Fri", ~"Sat" ]) |day| { - fail_unless!(test(*day, ~"%a")); + assert!(test(*day, ~"%a")); } for vec::each([ @@ -1079,7 +1079,7 @@ mod tests { ~"November", ~"December" ]) |day| { - fail_unless!(test(*day, ~"%B")); + assert!(test(*day, ~"%B")); } for vec::each([ @@ -1096,56 +1096,56 @@ mod tests { ~"Nov", ~"Dec" ]) |day| { - fail_unless!(test(*day, ~"%b")); + assert!(test(*day, ~"%b")); } - fail_unless!(test(~"19", ~"%C")); - fail_unless!(test(~"Fri Feb 13 23:31:30 2009", ~"%c")); - fail_unless!(test(~"02/13/09", ~"%D")); - fail_unless!(test(~"03", ~"%d")); - fail_unless!(test(~"13", ~"%d")); - fail_unless!(test(~" 3", ~"%e")); - fail_unless!(test(~"13", ~"%e")); - fail_unless!(test(~"2009-02-13", ~"%F")); - fail_unless!(test(~"03", ~"%H")); - fail_unless!(test(~"13", ~"%H")); - fail_unless!(test(~"03", ~"%I")); // FIXME (#2350): flesh out - fail_unless!(test(~"11", ~"%I")); // FIXME (#2350): flesh out - fail_unless!(test(~"044", ~"%j")); - fail_unless!(test(~" 3", ~"%k")); - fail_unless!(test(~"13", ~"%k")); - fail_unless!(test(~" 1", ~"%l")); - fail_unless!(test(~"11", ~"%l")); - fail_unless!(test(~"03", ~"%M")); - fail_unless!(test(~"13", ~"%M")); - fail_unless!(test(~"\n", ~"%n")); - fail_unless!(test(~"am", ~"%P")); - fail_unless!(test(~"pm", ~"%P")); - fail_unless!(test(~"AM", ~"%p")); - fail_unless!(test(~"PM", ~"%p")); - fail_unless!(test(~"23:31", ~"%R")); - fail_unless!(test(~"11:31:30 AM", ~"%r")); - fail_unless!(test(~"11:31:30 PM", ~"%r")); - fail_unless!(test(~"03", ~"%S")); - fail_unless!(test(~"13", ~"%S")); - fail_unless!(test(~"15:31:30", ~"%T")); - fail_unless!(test(~"\t", ~"%t")); - fail_unless!(test(~"1", ~"%u")); - fail_unless!(test(~"7", ~"%u")); - fail_unless!(test(~"13-Feb-2009", ~"%v")); - fail_unless!(test(~"0", ~"%w")); - fail_unless!(test(~"6", ~"%w")); - fail_unless!(test(~"2009", ~"%Y")); - fail_unless!(test(~"09", ~"%y")); - fail_unless!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone == + assert!(test(~"19", ~"%C")); + assert!(test(~"Fri Feb 13 23:31:30 2009", ~"%c")); + assert!(test(~"02/13/09", ~"%D")); + assert!(test(~"03", ~"%d")); + assert!(test(~"13", ~"%d")); + assert!(test(~" 3", ~"%e")); + assert!(test(~"13", ~"%e")); + assert!(test(~"2009-02-13", ~"%F")); + assert!(test(~"03", ~"%H")); + assert!(test(~"13", ~"%H")); + assert!(test(~"03", ~"%I")); // FIXME (#2350): flesh out + assert!(test(~"11", ~"%I")); // FIXME (#2350): flesh out + assert!(test(~"044", ~"%j")); + assert!(test(~" 3", ~"%k")); + assert!(test(~"13", ~"%k")); + assert!(test(~" 1", ~"%l")); + assert!(test(~"11", ~"%l")); + assert!(test(~"03", ~"%M")); + assert!(test(~"13", ~"%M")); + assert!(test(~"\n", ~"%n")); + assert!(test(~"am", ~"%P")); + assert!(test(~"pm", ~"%P")); + assert!(test(~"AM", ~"%p")); + assert!(test(~"PM", ~"%p")); + assert!(test(~"23:31", ~"%R")); + assert!(test(~"11:31:30 AM", ~"%r")); + assert!(test(~"11:31:30 PM", ~"%r")); + assert!(test(~"03", ~"%S")); + assert!(test(~"13", ~"%S")); + assert!(test(~"15:31:30", ~"%T")); + assert!(test(~"\t", ~"%t")); + assert!(test(~"1", ~"%u")); + assert!(test(~"7", ~"%u")); + assert!(test(~"13-Feb-2009", ~"%v")); + assert!(test(~"0", ~"%w")); + assert!(test(~"6", ~"%w")); + assert!(test(~"2009", ~"%Y")); + assert!(test(~"09", ~"%y")); + assert!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone == ~"UTC"); - fail_unless!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone == + assert!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone == ~""); - fail_unless!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff == + assert!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff == 0); - fail_unless!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff == + assert!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff == 0); - fail_unless!(test(~"%", ~"%%")); + assert!(test(~"%", ~"%%")); } pub fn test_ctime() { @@ -1158,8 +1158,8 @@ mod tests { error!("test_ctime: %? %?", utc.ctime(), local.ctime()); - fail_unless!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); - fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); + assert!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); + assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); } pub fn test_strftime() { @@ -1170,69 +1170,69 @@ mod tests { let utc = at_utc(time); let local = at(time); - fail_unless!(local.strftime(~"") == ~""); - fail_unless!(local.strftime(~"%A") == ~"Friday"); - fail_unless!(local.strftime(~"%a") == ~"Fri"); - fail_unless!(local.strftime(~"%B") == ~"February"); - fail_unless!(local.strftime(~"%b") == ~"Feb"); - fail_unless!(local.strftime(~"%C") == ~"20"); - fail_unless!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009"); - fail_unless!(local.strftime(~"%D") == ~"02/13/09"); - fail_unless!(local.strftime(~"%d") == ~"13"); - fail_unless!(local.strftime(~"%e") == ~"13"); - fail_unless!(local.strftime(~"%F") == ~"2009-02-13"); - // fail_unless!(local.strftime("%G") == "2009"); - // fail_unless!(local.strftime("%g") == "09"); - fail_unless!(local.strftime(~"%H") == ~"15"); - fail_unless!(local.strftime(~"%I") == ~"03"); - fail_unless!(local.strftime(~"%j") == ~"044"); - fail_unless!(local.strftime(~"%k") == ~"15"); - fail_unless!(local.strftime(~"%l") == ~" 3"); - fail_unless!(local.strftime(~"%M") == ~"31"); - fail_unless!(local.strftime(~"%m") == ~"02"); - fail_unless!(local.strftime(~"%n") == ~"\n"); - fail_unless!(local.strftime(~"%P") == ~"pm"); - fail_unless!(local.strftime(~"%p") == ~"PM"); - fail_unless!(local.strftime(~"%R") == ~"15:31"); - fail_unless!(local.strftime(~"%r") == ~"03:31:30 PM"); - fail_unless!(local.strftime(~"%S") == ~"30"); - fail_unless!(local.strftime(~"%s") == ~"1234567890"); - fail_unless!(local.strftime(~"%T") == ~"15:31:30"); - fail_unless!(local.strftime(~"%t") == ~"\t"); - // fail_unless!(local.strftime("%U") == "06"); - fail_unless!(local.strftime(~"%u") == ~"5"); - // fail_unless!(local.strftime("%V") == "07"); - fail_unless!(local.strftime(~"%v") == ~"13-Feb-2009"); - // fail_unless!(local.strftime("%W") == "06"); - fail_unless!(local.strftime(~"%w") == ~"5"); + assert!(local.strftime(~"") == ~""); + assert!(local.strftime(~"%A") == ~"Friday"); + assert!(local.strftime(~"%a") == ~"Fri"); + assert!(local.strftime(~"%B") == ~"February"); + assert!(local.strftime(~"%b") == ~"Feb"); + assert!(local.strftime(~"%C") == ~"20"); + assert!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009"); + assert!(local.strftime(~"%D") == ~"02/13/09"); + assert!(local.strftime(~"%d") == ~"13"); + assert!(local.strftime(~"%e") == ~"13"); + assert!(local.strftime(~"%F") == ~"2009-02-13"); + // assert!(local.strftime("%G") == "2009"); + // assert!(local.strftime("%g") == "09"); + assert!(local.strftime(~"%H") == ~"15"); + assert!(local.strftime(~"%I") == ~"03"); + assert!(local.strftime(~"%j") == ~"044"); + assert!(local.strftime(~"%k") == ~"15"); + assert!(local.strftime(~"%l") == ~" 3"); + assert!(local.strftime(~"%M") == ~"31"); + assert!(local.strftime(~"%m") == ~"02"); + assert!(local.strftime(~"%n") == ~"\n"); + assert!(local.strftime(~"%P") == ~"pm"); + assert!(local.strftime(~"%p") == ~"PM"); + assert!(local.strftime(~"%R") == ~"15:31"); + assert!(local.strftime(~"%r") == ~"03:31:30 PM"); + assert!(local.strftime(~"%S") == ~"30"); + assert!(local.strftime(~"%s") == ~"1234567890"); + assert!(local.strftime(~"%T") == ~"15:31:30"); + assert!(local.strftime(~"%t") == ~"\t"); + // assert!(local.strftime("%U") == "06"); + assert!(local.strftime(~"%u") == ~"5"); + // assert!(local.strftime("%V") == "07"); + assert!(local.strftime(~"%v") == ~"13-Feb-2009"); + // assert!(local.strftime("%W") == "06"); + assert!(local.strftime(~"%w") == ~"5"); // handle "%X" // handle "%x" - fail_unless!(local.strftime(~"%Y") == ~"2009"); - fail_unless!(local.strftime(~"%y") == ~"09"); + assert!(local.strftime(~"%Y") == ~"2009"); + assert!(local.strftime(~"%y") == ~"09"); // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let zone = local.strftime(~"%Z"); - fail_unless!(zone == ~"PST" || zone == ~"Pacific Standard Time"); + assert!(zone == ~"PST" || zone == ~"Pacific Standard Time"); - fail_unless!(local.strftime(~"%z") == ~"-0800"); - fail_unless!(local.strftime(~"%%") == ~"%"); + assert!(local.strftime(~"%z") == ~"-0800"); + assert!(local.strftime(~"%%") == ~"%"); // FIXME (#2350): We should probably standardize on the timezone // abbreviation. let rfc822 = local.rfc822(); let prefix = ~"Fri, 13 Feb 2009 15:31:30 "; - fail_unless!(rfc822 == prefix + ~"PST" || + assert!(rfc822 == prefix + ~"PST" || rfc822 == prefix + ~"Pacific Standard Time"); - fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); - fail_unless!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800"); - fail_unless!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00"); + assert!(local.ctime() == ~"Fri Feb 13 15:31:30 2009"); + assert!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800"); + assert!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00"); - fail_unless!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); - fail_unless!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT"); - fail_unless!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000"); - fail_unless!(utc.rfc3339() == ~"2009-02-13T23:31:30Z"); + assert!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009"); + assert!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT"); + assert!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000"); + assert!(utc.rfc3339() == ~"2009-02-13T23:31:30Z"); } pub fn test_timespec_eq_ord() { @@ -1244,28 +1244,28 @@ mod tests { let d = &Timespec::new(2, 1); let e = &Timespec::new(2, 1); - fail_unless!(eq(d, e)); - fail_unless!(ne(c, e)); + assert!(eq(d, e)); + assert!(ne(c, e)); - fail_unless!(lt(a, b)); - fail_unless!(lt(b, c)); - fail_unless!(lt(c, d)); + assert!(lt(a, b)); + assert!(lt(b, c)); + assert!(lt(c, d)); - fail_unless!(le(a, b)); - fail_unless!(le(b, c)); - fail_unless!(le(c, d)); - fail_unless!(le(d, e)); - fail_unless!(le(e, d)); + assert!(le(a, b)); + assert!(le(b, c)); + assert!(le(c, d)); + assert!(le(d, e)); + assert!(le(e, d)); - fail_unless!(ge(b, a)); - fail_unless!(ge(c, b)); - fail_unless!(ge(d, c)); - fail_unless!(ge(e, d)); - fail_unless!(ge(d, e)); + assert!(ge(b, a)); + assert!(ge(c, b)); + assert!(ge(d, c)); + assert!(ge(e, d)); + assert!(ge(d, e)); - fail_unless!(gt(b, a)); - fail_unless!(gt(c, b)); - fail_unless!(gt(d, c)); + assert!(gt(b, a)); + assert!(gt(c, b)); + assert!(gt(d, c)); } #[test] diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index d72bfe73dd666..229d1a07caaab 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -261,14 +261,14 @@ mod test { match recv_timeout(hl_loop, 10u, &test_po) { Some(val) => { - fail_unless!(val == expected); + assert!(val == expected); successes += 1; } _ => failures += 1 }; } - fail_unless!(successes > times / 2); + assert!(successes > times / 2); } #[test] @@ -292,6 +292,6 @@ mod test { }; } - fail_unless!(successes > times / 2); + assert!(successes > times / 2); } } diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 9a184ca868234..d0868da4408d4 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -725,24 +725,24 @@ mod test_treemap { #[test] fn find_empty() { - let m = TreeMap::new::(); fail_unless!(m.find(&5) == None); + let m = TreeMap::new::(); assert!(m.find(&5) == None); } #[test] fn find_not_found() { let mut m = TreeMap::new(); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.insert(5, 3)); - fail_unless!(m.insert(9, 3)); - fail_unless!(m.find(&2) == None); + assert!(m.insert(1, 2)); + assert!(m.insert(5, 3)); + assert!(m.insert(9, 3)); + assert!(m.find(&2) == None); } #[test] fn test_find_mut() { let mut m = TreeMap::new(); - fail_unless!(m.insert(1, 12)); - fail_unless!(m.insert(2, 8)); - fail_unless!(m.insert(5, 14)); + assert!(m.insert(1, 12)); + assert!(m.insert(2, 8)); + assert!(m.insert(5, 14)); let new = 100; match m.find_mut(&5) { None => fail!(), Some(x) => *x = new @@ -753,24 +753,24 @@ mod test_treemap { #[test] fn insert_replace() { let mut m = TreeMap::new(); - fail_unless!(m.insert(5, 2)); - fail_unless!(m.insert(2, 9)); - fail_unless!(!m.insert(2, 11)); - fail_unless!(m.find(&2).unwrap() == &11); + assert!(m.insert(5, 2)); + assert!(m.insert(2, 9)); + assert!(!m.insert(2, 11)); + assert!(m.find(&2).unwrap() == &11); } #[test] fn test_clear() { let mut m = TreeMap::new(); m.clear(); - fail_unless!(m.insert(5, 11)); - fail_unless!(m.insert(12, -3)); - fail_unless!(m.insert(19, 2)); + assert!(m.insert(5, 11)); + assert!(m.insert(12, -3)); + assert!(m.insert(19, 2)); m.clear(); - fail_unless!(m.find(&5).is_none()); - fail_unless!(m.find(&12).is_none()); - fail_unless!(m.find(&19).is_none()); - fail_unless!(m.is_empty()); + assert!(m.find(&5).is_none()); + assert!(m.find(&12).is_none()); + assert!(m.find(&19).is_none()); + assert!(m.is_empty()); } #[test] @@ -785,28 +785,28 @@ mod test_treemap { m.insert(copy k1, copy v1); m.insert(copy k2, copy v2); - fail_unless!(m.find(&k2) == Some(&v2)); - fail_unless!(m.find(&k1) == Some(&v1)); + assert!(m.find(&k2) == Some(&v2)); + assert!(m.find(&k1) == Some(&v1)); } fn check_equal(ctrl: &[(K, V)], map: &TreeMap) { - fail_unless!(ctrl.is_empty() == map.is_empty()); + assert!(ctrl.is_empty() == map.is_empty()); for ctrl.each |x| { let &(k, v) = x; - fail_unless!(map.find(&k).unwrap() == &v) + assert!(map.find(&k).unwrap() == &v) } for map.each |&(map_k, map_v)| { let mut found = false; for ctrl.each |x| { let &(ctrl_k, ctrl_v) = x; if *map_k == ctrl_k { - fail_unless!(*map_v == ctrl_v); + assert!(*map_v == ctrl_v); found = true; break; } } - fail_unless!(found); + assert!(found); } } @@ -814,12 +814,12 @@ mod test_treemap { parent: &~TreeNode) { match *node { Some(ref r) => { - fail_unless!(r.key.cmp(&parent.key) == Less); - fail_unless!(r.level == parent.level - 1); // left is black + assert!(r.key.cmp(&parent.key) == Less); + assert!(r.level == parent.level - 1); // left is black check_left(&r.left, r); check_right(&r.right, r, false); } - None => fail_unless!(parent.level == 1) // parent is leaf + None => assert!(parent.level == 1) // parent is leaf } } @@ -828,15 +828,15 @@ mod test_treemap { parent_red: bool) { match *node { Some(ref r) => { - fail_unless!(r.key.cmp(&parent.key) == Greater); + assert!(r.key.cmp(&parent.key) == Greater); let red = r.level == parent.level; - if parent_red { fail_unless!(!red) } // no dual horizontal links + if parent_red { assert!(!red) } // no dual horizontal links // Right red or black - fail_unless!(red || r.level == parent.level - 1); + assert!(red || r.level == parent.level - 1); check_left(&r.left, r); check_right(&r.right, r, red); } - None => fail_unless!(parent.level == 1) // parent is leaf + None => assert!(parent.level == 1) // parent is leaf } } @@ -856,7 +856,7 @@ mod test_treemap { let mut ctrl = ~[]; check_equal(ctrl, &map); - fail_unless!(map.find(&5).is_none()); + assert!(map.find(&5).is_none()); let rng = rand::seeded_rng(&[42]); @@ -865,7 +865,7 @@ mod test_treemap { let k = rng.gen_int(); let v = rng.gen_int(); if !ctrl.contains(&(k, v)) { - fail_unless!(map.insert(k, v)); + assert!(map.insert(k, v)); ctrl.push((k, v)); check_structure(&map); check_equal(ctrl, &map); @@ -875,7 +875,7 @@ mod test_treemap { for 30.times { let r = rng.gen_uint_range(0, ctrl.len()); let (key, _) = vec::remove(&mut ctrl, r); - fail_unless!(map.remove(&key)); + assert!(map.remove(&key)); check_structure(&map); check_equal(ctrl, &map); } @@ -885,36 +885,36 @@ mod test_treemap { #[test] fn test_len() { let mut m = TreeMap::new(); - fail_unless!(m.insert(3, 6)); - fail_unless!(m.len() == 1); - fail_unless!(m.insert(0, 0)); - fail_unless!(m.len() == 2); - fail_unless!(m.insert(4, 8)); - fail_unless!(m.len() == 3); - fail_unless!(m.remove(&3)); - fail_unless!(m.len() == 2); - fail_unless!(!m.remove(&5)); - fail_unless!(m.len() == 2); - fail_unless!(m.insert(2, 4)); - fail_unless!(m.len() == 3); - fail_unless!(m.insert(1, 2)); - fail_unless!(m.len() == 4); + assert!(m.insert(3, 6)); + assert!(m.len() == 1); + assert!(m.insert(0, 0)); + assert!(m.len() == 2); + assert!(m.insert(4, 8)); + assert!(m.len() == 3); + assert!(m.remove(&3)); + assert!(m.len() == 2); + assert!(!m.remove(&5)); + assert!(m.len() == 2); + assert!(m.insert(2, 4)); + assert!(m.len() == 3); + assert!(m.insert(1, 2)); + assert!(m.len() == 4); } #[test] fn test_each() { let mut m = TreeMap::new(); - fail_unless!(m.insert(3, 6)); - fail_unless!(m.insert(0, 0)); - fail_unless!(m.insert(4, 8)); - fail_unless!(m.insert(2, 4)); - fail_unless!(m.insert(1, 2)); + assert!(m.insert(3, 6)); + assert!(m.insert(0, 0)); + assert!(m.insert(4, 8)); + assert!(m.insert(2, 4)); + assert!(m.insert(1, 2)); let mut n = 0; for m.each |&(k, v)| { - fail_unless!(*k == n); - fail_unless!(*v == n * 2); + assert!(*k == n); + assert!(*v == n * 2); n += 1; } } @@ -923,16 +923,16 @@ mod test_treemap { fn test_each_reverse() { let mut m = TreeMap::new(); - fail_unless!(m.insert(3, 6)); - fail_unless!(m.insert(0, 0)); - fail_unless!(m.insert(4, 8)); - fail_unless!(m.insert(2, 4)); - fail_unless!(m.insert(1, 2)); + assert!(m.insert(3, 6)); + assert!(m.insert(0, 0)); + assert!(m.insert(4, 8)); + assert!(m.insert(2, 4)); + assert!(m.insert(1, 2)); let mut n = 4; for m.each_reverse |&(k, v)| { - fail_unless!(*k == n); - fail_unless!(*v == n * 2); + assert!(*k == n); + assert!(*v == n * 2); n -= 1; } } @@ -942,17 +942,17 @@ mod test_treemap { let mut a = TreeMap::new(); let mut b = TreeMap::new(); - fail_unless!(a == b); - fail_unless!(a.insert(0, 5)); - fail_unless!(a != b); - fail_unless!(b.insert(0, 4)); - fail_unless!(a != b); - fail_unless!(a.insert(5, 19)); - fail_unless!(a != b); - fail_unless!(!b.insert(0, 5)); - fail_unless!(a != b); - fail_unless!(b.insert(5, 19)); - fail_unless!(a == b); + assert!(a == b); + assert!(a.insert(0, 5)); + assert!(a != b); + assert!(b.insert(0, 4)); + assert!(a != b); + assert!(a.insert(5, 19)); + assert!(a != b); + assert!(!b.insert(0, 5)); + assert!(a != b); + assert!(b.insert(5, 19)); + assert!(a == b); } #[test] @@ -960,17 +960,17 @@ mod test_treemap { let mut a = TreeMap::new(); let mut b = TreeMap::new(); - fail_unless!(!(a < b) && !(b < a)); - fail_unless!(b.insert(0, 5)); - fail_unless!(a < b); - fail_unless!(a.insert(0, 7)); - fail_unless!(!(a < b) && !(b < a)); - fail_unless!(b.insert(-2, 0)); - fail_unless!(b < a); - fail_unless!(a.insert(-5, 2)); - fail_unless!(a < b); - fail_unless!(a.insert(6, 2)); - fail_unless!(a < b && !(b < a)); + assert!(!(a < b) && !(b < a)); + assert!(b.insert(0, 5)); + assert!(a < b); + assert!(a.insert(0, 7)); + assert!(!(a < b) && !(b < a)); + assert!(b.insert(-2, 0)); + assert!(b < a); + assert!(a.insert(-5, 2)); + assert!(a < b); + assert!(a.insert(6, 2)); + assert!(a < b && !(b < a)); } #[test] @@ -978,13 +978,13 @@ mod test_treemap { let mut a = TreeMap::new(); let mut b = TreeMap::new(); - fail_unless!(a <= b && a >= b); - fail_unless!(a.insert(1, 1)); - fail_unless!(a > b && a >= b); - fail_unless!(b < a && b <= a); - fail_unless!(b.insert(2, 2)); - fail_unless!(b > a && b >= a); - fail_unless!(a < b && a <= b); + assert!(a <= b && a >= b); + assert!(a.insert(1, 1)); + assert!(a > b && a >= b); + assert!(b < a && b <= a); + assert!(b.insert(2, 2)); + assert!(b > a && b >= a); + assert!(a < b && a <= b); } #[test] @@ -996,22 +996,22 @@ mod test_treemap { let (x4, y4) = (29, 5); let (x5, y5) = (103, 3); - fail_unless!(m.insert(x1, y1)); - fail_unless!(m.insert(x2, y2)); - fail_unless!(m.insert(x3, y3)); - fail_unless!(m.insert(x4, y4)); - fail_unless!(m.insert(x5, y5)); + assert!(m.insert(x1, y1)); + assert!(m.insert(x2, y2)); + assert!(m.insert(x3, y3)); + assert!(m.insert(x4, y4)); + assert!(m.insert(x5, y5)); let m = m; let mut a = m.iter(); - fail_unless!(map_next(&mut a).unwrap() == (&x1, &y1)); - fail_unless!(map_next(&mut a).unwrap() == (&x2, &y2)); - fail_unless!(map_next(&mut a).unwrap() == (&x3, &y3)); - fail_unless!(map_next(&mut a).unwrap() == (&x4, &y4)); - fail_unless!(map_next(&mut a).unwrap() == (&x5, &y5)); + assert!(map_next(&mut a).unwrap() == (&x1, &y1)); + assert!(map_next(&mut a).unwrap() == (&x2, &y2)); + assert!(map_next(&mut a).unwrap() == (&x3, &y3)); + assert!(map_next(&mut a).unwrap() == (&x4, &y4)); + assert!(map_next(&mut a).unwrap() == (&x5, &y5)); - fail_unless!(map_next(&mut a).is_none()); + assert!(map_next(&mut a).is_none()); let mut b = m.iter(); @@ -1020,7 +1020,7 @@ mod test_treemap { let mut i = 0; for map_advance(&mut b) |x| { - fail_unless!(expected[i] == x); + assert!(expected[i] == x); i += 1; if i == 2 { @@ -1029,7 +1029,7 @@ mod test_treemap { } for map_advance(&mut b) |x| { - fail_unless!(expected[i] == x); + assert!(expected[i] == x); i += 1; } } @@ -1043,80 +1043,80 @@ mod test_set { fn test_clear() { let mut s = TreeSet::new(); s.clear(); - fail_unless!(s.insert(5)); - fail_unless!(s.insert(12)); - fail_unless!(s.insert(19)); + assert!(s.insert(5)); + assert!(s.insert(12)); + assert!(s.insert(19)); s.clear(); - fail_unless!(!s.contains(&5)); - fail_unless!(!s.contains(&12)); - fail_unless!(!s.contains(&19)); - fail_unless!(s.is_empty()); + assert!(!s.contains(&5)); + assert!(!s.contains(&12)); + assert!(!s.contains(&19)); + assert!(s.is_empty()); } #[test] fn test_disjoint() { let mut xs = TreeSet::new(); let mut ys = TreeSet::new(); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(xs.insert(5)); - fail_unless!(ys.insert(11)); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(xs.insert(7)); - fail_unless!(xs.insert(19)); - fail_unless!(xs.insert(4)); - fail_unless!(ys.insert(2)); - fail_unless!(ys.insert(-11)); - fail_unless!(xs.is_disjoint(&ys)); - fail_unless!(ys.is_disjoint(&xs)); - fail_unless!(ys.insert(7)); - fail_unless!(!xs.is_disjoint(&ys)); - fail_unless!(!ys.is_disjoint(&xs)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(xs.insert(5)); + assert!(ys.insert(11)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(xs.insert(7)); + assert!(xs.insert(19)); + assert!(xs.insert(4)); + assert!(ys.insert(2)); + assert!(ys.insert(-11)); + assert!(xs.is_disjoint(&ys)); + assert!(ys.is_disjoint(&xs)); + assert!(ys.insert(7)); + assert!(!xs.is_disjoint(&ys)); + assert!(!ys.is_disjoint(&xs)); } #[test] fn test_subset_and_superset() { let mut a = TreeSet::new(); - fail_unless!(a.insert(0)); - fail_unless!(a.insert(5)); - fail_unless!(a.insert(11)); - fail_unless!(a.insert(7)); + assert!(a.insert(0)); + assert!(a.insert(5)); + assert!(a.insert(11)); + assert!(a.insert(7)); let mut b = TreeSet::new(); - fail_unless!(b.insert(0)); - fail_unless!(b.insert(7)); - fail_unless!(b.insert(19)); - fail_unless!(b.insert(250)); - fail_unless!(b.insert(11)); - fail_unless!(b.insert(200)); + assert!(b.insert(0)); + assert!(b.insert(7)); + assert!(b.insert(19)); + assert!(b.insert(250)); + assert!(b.insert(11)); + assert!(b.insert(200)); - fail_unless!(!a.is_subset(&b)); - fail_unless!(!a.is_superset(&b)); - fail_unless!(!b.is_subset(&a)); - fail_unless!(!b.is_superset(&a)); + assert!(!a.is_subset(&b)); + assert!(!a.is_superset(&b)); + assert!(!b.is_subset(&a)); + assert!(!b.is_superset(&a)); - fail_unless!(b.insert(5)); + assert!(b.insert(5)); - fail_unless!(a.is_subset(&b)); - fail_unless!(!a.is_superset(&b)); - fail_unless!(!b.is_subset(&a)); - fail_unless!(b.is_superset(&a)); + assert!(a.is_subset(&b)); + assert!(!a.is_superset(&b)); + assert!(!b.is_subset(&a)); + assert!(b.is_superset(&a)); } #[test] fn test_each() { let mut m = TreeSet::new(); - fail_unless!(m.insert(3)); - fail_unless!(m.insert(0)); - fail_unless!(m.insert(4)); - fail_unless!(m.insert(2)); - fail_unless!(m.insert(1)); + assert!(m.insert(3)); + assert!(m.insert(0)); + assert!(m.insert(4)); + assert!(m.insert(2)); + assert!(m.insert(1)); let mut n = 0; for m.each |x| { - fail_unless!(*x == n); + assert!(*x == n); n += 1 } } @@ -1125,15 +1125,15 @@ mod test_set { fn test_each_reverse() { let mut m = TreeSet::new(); - fail_unless!(m.insert(3)); - fail_unless!(m.insert(0)); - fail_unless!(m.insert(4)); - fail_unless!(m.insert(2)); - fail_unless!(m.insert(1)); + assert!(m.insert(3)); + assert!(m.insert(0)); + assert!(m.insert(4)); + assert!(m.insert(2)); + assert!(m.insert(1)); let mut n = 4; for m.each_reverse |x| { - fail_unless!(*x == n); + assert!(*x == n); n -= 1 } } @@ -1143,15 +1143,15 @@ mod test_set { let mut set_a = TreeSet::new(); let mut set_b = TreeSet::new(); - for a.each |x| { fail_unless!(set_a.insert(*x)) } - for b.each |y| { fail_unless!(set_b.insert(*y)) } + for a.each |x| { assert!(set_a.insert(*x)) } + for b.each |y| { assert!(set_b.insert(*y)) } let mut i = 0; for f(&set_a, &set_b) |x| { - fail_unless!(*x == expected[i]); + assert!(*x == expected[i]); i += 1; } - fail_unless!(i == expected.len()); + assert!(i == expected.len()); } #[test] diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index 4fdd4e286da1a..77996de6d8394 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -224,25 +224,25 @@ mod tests { #[test] fn test_is_digit() { - fail_unless!((unicode::icu::is_digit('0'))); - fail_unless!((!unicode::icu::is_digit('m'))); + assert!((unicode::icu::is_digit('0'))); + assert!((!unicode::icu::is_digit('m'))); } #[test] fn test_is_lower() { - fail_unless!((unicode::icu::is_lower('m'))); - fail_unless!((!unicode::icu::is_lower('M'))); + assert!((unicode::icu::is_lower('m'))); + assert!((!unicode::icu::is_lower('M'))); } #[test] fn test_is_space() { - fail_unless!((unicode::icu::is_space(' '))); - fail_unless!((!unicode::icu::is_space('m'))); + assert!((unicode::icu::is_space(' '))); + assert!((!unicode::icu::is_space('m'))); } #[test] fn test_is_upper() { - fail_unless!((unicode::icu::is_upper('M'))); - fail_unless!((!unicode::icu::is_upper('m'))); + assert!((unicode::icu::is_upper('M'))); + assert!((!unicode::icu::is_upper('m'))); } } diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 1c7a7c22a9d15..fe40fc6a78b41 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -188,7 +188,7 @@ extern fn tear_down_walk_cb(handle: *libc::c_void, arg: *libc::c_void) { // pretty much, if we still have an active handle and it is *not* // the async handle that facilities global loop communication, we // want to barf out and fail - fail_unless!(handle == arg); + assert!(handle == arg); } extern fn tear_down_close_cb(handle: *ll::uv_async_t) { diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index f6cc35e0c9ea0..7582a7cff513c 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -1339,7 +1339,7 @@ pub mod test { stream as *libc::c_void); let err_msg = get_last_err_info(test_loop); debug!(err_msg); - fail_unless!(false); + assert!(false); } debug!(~"finishing on_connect_cb"); } @@ -1411,12 +1411,12 @@ pub mod test { } else { debug!(~"tcp_connect() failure"); - fail_unless!(false); + assert!(false); } } else { debug!(~"tcp_init() failure"); - fail_unless!(false); + assert!(false); } loop_delete(test_loop); } @@ -1492,7 +1492,7 @@ pub mod test { debug!(get_last_err_info( get_loop_for_uv_handle(client_stream_ptr as *libc::c_void))); - fail_unless!(false); + assert!(false); } } else { @@ -1552,19 +1552,19 @@ pub mod test { else { debug!("server_connection_cb: bad read:%d", read_result as int); - fail_unless!(false); + assert!(false); } } else { debug!("server_connection_cb: bad accept: %d", accept_result as int); - fail_unless!(false); + assert!(false); } } else { debug!("server_connection_cb: bad client init: %d", client_init_result as int); - fail_unless!(false); + assert!(false); } } } @@ -1683,25 +1683,25 @@ pub mod test { else { debug!("uv_async_init failure: %d", async_result as int); - fail_unless!(false); + assert!(false); } } else { debug!("non-zero result on uv_listen: %d", listen_result as int); - fail_unless!(false); + assert!(false); } } else { debug!("non-zero result on uv_tcp_bind: %d", bind_result as int); - fail_unless!(false); + assert!(false); } } else { debug!("non-zero result on uv_tcp_init: %d", tcp_init_result as int); - fail_unless!(false); + assert!(false); } loop_delete(test_loop); } @@ -1749,8 +1749,8 @@ pub mod test { let msg_from_client = server_port.recv(); let msg_from_server = client_port.recv(); - fail_unless!(str::contains(msg_from_client, kill_server_msg)); - fail_unless!(str::contains(msg_from_server, server_resp_msg)); + assert!(str::contains(msg_from_client, kill_server_msg)); + assert!(str::contains(msg_from_server, server_resp_msg)); } } @@ -1794,7 +1794,7 @@ pub mod test { t_name, rust_size, foreign_size as uint); debug!(output); } - fail_unless!(sizes_match); + assert!(sizes_match); } } @@ -1859,7 +1859,7 @@ pub mod test { // .. can't get the uv::ll::sockaddr_in6 to == 28 :/ // .. so the type always appears to be 32 in size.. which is // good, i guess.. better too big than too little - fail_unless!((4u+foreign_handle_size as uint) == + assert!((4u+foreign_handle_size as uint) == rust_handle_size); } } @@ -1874,7 +1874,7 @@ pub mod test { foreign_handle_size as uint, rust_handle_size); debug!(output); // FIXME #1645 .. see note above about struct padding - fail_unless!((4u+foreign_handle_size as uint) == + assert!((4u+foreign_handle_size as uint) == rust_handle_size); } } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index b086670956e24..7a8aff121a86d 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -246,7 +246,7 @@ pub impl FileMap { fn next_line(&self, +pos: BytePos) { // the new charpos must be > the last one (or it's the first one). let lines = &mut *self.lines; - fail_unless!((lines.len() == 0) || (lines[lines.len() - 1] < pos)); + assert!((lines.len() == 0) || (lines[lines.len() - 1] < pos)); self.lines.push(pos); } @@ -264,7 +264,7 @@ pub impl FileMap { } pub fn record_multibyte_char(&self, pos: BytePos, bytes: uint) { - fail_unless!(bytes >=2 && bytes <= 4); + assert!(bytes >=2 && bytes <= 4); let mbc = MultiByteChar { pos: pos, bytes: bytes, @@ -387,7 +387,7 @@ pub impl CodeMap { pub fn span_to_snippet(&self, sp: span) -> ~str { let begin = self.lookup_byte_offset(sp.lo); let end = self.lookup_byte_offset(sp.hi); - fail_unless!(begin.fm.start_pos == end.fm.start_pos); + assert!(begin.fm.start_pos == end.fm.start_pos); return str::slice(*begin.fm.src, begin.pos.to_uint(), end.pos.to_uint()).to_owned(); } @@ -449,7 +449,7 @@ priv impl CodeMap { debug!("codemap: char pos %? is on the line at char pos %?", chpos, linechpos); debug!("codemap: byte is on line: %?", line); - fail_unless!(chpos >= linechpos); + assert!(chpos >= linechpos); return Loc { file: f, line: line, @@ -488,7 +488,7 @@ priv impl CodeMap { total_extra_bytes += mbc.bytes; // We should never see a byte position in the middle of a // character - fail_unless!(bpos == mbc.pos + assert!(bpos == mbc.pos || bpos.to_uint() >= mbc.pos.to_uint() + mbc.bytes); } else { break; diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 6f49fe02239d3..09498f09a2927 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -449,19 +449,6 @@ pub fn core_macros() -> ~str { ) ) - macro_rules! fail_unless( - ($cond:expr) => { - if !$cond { - ::core::sys::fail_assert(stringify!($cond), file!(), line!()) - } - }; - ($cond:expr, $msg:expr) => { - if !$cond { - ::core::sys::fail_assert($msg, file!(), line!()) - } - } - ) - macro_rules! assert( ($cond:expr) => { if !$cond { diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 99033b3b3ccec..ca8a17dad67c0 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -54,7 +54,7 @@ impl gen_send for message { message(ref _id, span, ref tys, this, Some(ref next_state)) => { debug!("pipec: next state exists"); let next = this.proto.get_state(next_state.state); - fail_unless!(next_state.tys.len() == + assert!(next_state.tys.len() == next.generics.ty_params.len()); let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str())); let args_ast = vec::map2(arg_names, *tys, |n, t| cx.arg(*n, *t)); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index e6619d6dcfae0..f74fbbc3c03f7 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -407,7 +407,7 @@ pub fn parse( } } - fail_unless!(cur_eis.len() > 0u); + assert!(cur_eis.len() > 0u); } } diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 0804951327a22..f90ff21cdf004 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -48,7 +48,7 @@ pub fn is_doc_comment(s: &str) -> bool { } pub fn doc_comment_style(comment: &str) -> ast::attr_style { - fail_unless!(is_doc_comment(comment)); + assert!(is_doc_comment(comment)); if comment.starts_with(~"//!") || comment.starts_with(~"/*!") { ast::attr_inner } else { @@ -134,7 +134,7 @@ fn read_to_eol(rdr: @mut StringReader) -> ~str { fn read_one_line_comment(rdr: @mut StringReader) -> ~str { let val = read_to_eol(rdr); - fail_unless!((val[0] == '/' as u8 && val[1] == '/' as u8) || + assert!((val[0] == '/' as u8 && val[1] == '/' as u8) || (val[0] == '#' as u8 && val[1] == '!' as u8)); return val; } @@ -247,7 +247,7 @@ fn read_block_comment(rdr: @mut StringReader, bump(rdr); } if !is_block_non_doc_comment(curr_line) { return; } - fail_unless!(!curr_line.contains_char('\n')); + assert!(!curr_line.contains_char('\n')); lines.push(curr_line); } else { let mut level: int = 1; diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index ffd2a1d801c96..17d6ba3ac9378 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -187,7 +187,7 @@ pub fn bump(rdr: @mut StringReader) { rdr.last_pos = rdr.pos; let current_byte_offset = byte_offset(rdr).to_uint();; if current_byte_offset < (*rdr.src).len() { - fail_unless!(rdr.curr != -1 as char); + assert!(rdr.curr != -1 as char); let last_char = rdr.curr; let next = str::char_range_at(*rdr.src, current_byte_offset); let byte_offset_diff = next.next - current_byte_offset; @@ -314,7 +314,7 @@ fn consume_any_line_comment(rdr: @mut StringReader) } pub fn is_block_non_doc_comment(s: &str) -> bool { - fail_unless!(s.len() >= 1u); + assert!(s.len() >= 1u); str::all_between(s, 1u, s.len() - 1u, |ch| ch == '*') } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index cdb67129c355b..22e659fa5744e 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -214,7 +214,7 @@ pub fn next_node_id(sess: @mut ParseSess) -> node_id { let rv = sess.next_id; sess.next_id += 1; // ID 0 is reserved for the crate and doesn't actually exist in the AST - fail_unless!(rv != 0); + assert!(rv != 0); return rv; } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index d93e5995d4f8e..ac0e42fc65d8f 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2529,7 +2529,7 @@ pub impl Parser { fn parse_block(&self) -> blk { let (attrs, blk) = self.parse_inner_attrs_and_block(false); - fail_unless!(vec::is_empty(attrs)); + assert!(vec::is_empty(attrs)); return blk; } @@ -3922,7 +3922,7 @@ pub impl Parser { foreign_items_allowed: bool, macros_allowed: bool ) -> item_or_view_item { - fail_unless!(items_allowed != foreign_items_allowed); + assert!(items_allowed != foreign_items_allowed); maybe_whole!(iovi self, nt_item); let lo = self.span.lo; @@ -4333,13 +4333,13 @@ pub impl Parser { view_items.push(view_item); } iovi_item(item) => { - fail_unless!(items_allowed); + assert!(items_allowed); items.push(item); attrs = self.parse_outer_attributes(); break; } iovi_foreign_item(foreign_item) => { - fail_unless!(foreign_items_allowed); + assert!(foreign_items_allowed); foreign_items.push(foreign_item); attrs = self.parse_outer_attributes(); break; @@ -4364,11 +4364,11 @@ pub impl Parser { view_items.push(view_item); } iovi_item(item) => { - fail_unless!(items_allowed); + assert!(items_allowed); items.push(item) } iovi_foreign_item(foreign_item) => { - fail_unless!(foreign_items_allowed); + assert!(foreign_items_allowed); foreign_items.push(foreign_item); } } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index af9cb7b841ef6..e742bdc056aa0 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -117,7 +117,7 @@ pub fn tok_str(++t: token) -> ~str { pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint, lim: uint) -> ~str { let n = vec::len(toks); - fail_unless!(n == vec::len(szs)); + assert!(n == vec::len(szs)); let mut i = left; let mut L = lim; let mut s = ~"["; @@ -369,12 +369,12 @@ pub impl Printer { } else { self.top += 1u; self.top %= self.buf_len; - fail_unless!((self.top != self.bottom)); + assert!((self.top != self.bottom)); } self.scan_stack[self.top] = x; } fn scan_pop(&mut self) -> uint { - fail_unless!((!self.scan_stack_empty)); + assert!((!self.scan_stack_empty)); let x = self.scan_stack[self.top]; if self.top == self.bottom { self.scan_stack_empty = true; @@ -382,11 +382,11 @@ pub impl Printer { return x; } fn scan_top(&mut self) -> uint { - fail_unless!((!self.scan_stack_empty)); + assert!((!self.scan_stack_empty)); return self.scan_stack[self.top]; } fn scan_pop_bottom(&mut self) -> uint { - fail_unless!((!self.scan_stack_empty)); + assert!((!self.scan_stack_empty)); let x = self.scan_stack[self.bottom]; if self.top == self.bottom { self.scan_stack_empty = true; @@ -396,7 +396,7 @@ pub impl Printer { fn advance_right(&mut self) { self.right += 1u; self.right %= self.buf_len; - fail_unless!((self.right != self.left)); + assert!((self.right != self.left)); } fn advance_left(&mut self, ++x: token, L: int) { debug!("advnce_left ~[%u,%u], sizeof(%u)=%d", self.left, self.right, @@ -406,7 +406,7 @@ pub impl Printer { match x { BREAK(b) => self.left_total += b.blank_space, STRING(_, len) => { - fail_unless!((len == L)); self.left_total += len; + assert!((len == L)); self.left_total += len; } _ => () } @@ -498,7 +498,7 @@ pub impl Printer { END => { debug!("print END -> pop END"); let print_stack = &*self.print_stack; - fail_unless!((print_stack.len() != 0u)); + assert!((print_stack.len() != 0u)); self.print_stack.pop(); } BREAK(b) => { @@ -532,8 +532,8 @@ pub impl Printer { } STRING(s, len) => { debug!("print STRING(%s)", *s); - fail_unless!((L == len)); - // fail_unless!(L <= space); + assert!((L == len)); + // assert!(L <= space); self.space -= len; self.print_str(*s); } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 66907471c98f6..7ca5fba4c8193 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1294,8 +1294,8 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { print_fn_block_args(s, decl); space(s.s); // } - fail_unless!(body.node.stmts.is_empty()); - fail_unless!(body.node.expr.is_some()); + assert!(body.node.stmts.is_empty()); + assert!(body.node.expr.is_some()); // we extract the block, so as not to create another set of boxes match body.node.expr.get().node { ast::expr_block(ref blk) => { @@ -1445,7 +1445,7 @@ pub fn print_decl(s: @ps, decl: @ast::decl) { // if any are mut, all are mut if locs.any(|l| l.node.is_mutbl) { - fail_unless!(locs.all(|l| l.node.is_mutbl)); + assert!(locs.all(|l| l.node.is_mutbl)); word_nbsp(s, ~"mut"); } @@ -2080,7 +2080,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) { pub fn print_comment(s: @ps, cmnt: comments::cmnt) { match cmnt.style { comments::mixed => { - fail_unless!((vec::len(cmnt.lines) == 1u)); + assert!((vec::len(cmnt.lines) == 1u)); zerobreak(s.s); word(s.s, cmnt.lines[0]); zerobreak(s.s); diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs index 171a5319291aa..d6ebf4d346bcc 100644 --- a/src/test/bench/core-map.rs +++ b/src/test/bench/core-map.rs @@ -34,13 +34,13 @@ fn ascending>(map: &mut M, n_keys: uint) { do timed("search") { for uint::range(0, n_keys) |i| { - fail_unless!(map.find(&i).unwrap() == &(i + 1)); + assert!(map.find(&i).unwrap() == &(i + 1)); } } do timed("remove") { for uint::range(0, n_keys) |i| { - fail_unless!(map.remove(&i)); + assert!(map.remove(&i)); } } } @@ -56,13 +56,13 @@ fn descending>(map: &mut M, n_keys: uint) { do timed("search") { for uint::range_rev(n_keys, 0) |i| { - fail_unless!(map.find(&i).unwrap() == &(i + 1)); + assert!(map.find(&i).unwrap() == &(i + 1)); } } do timed("remove") { for uint::range_rev(n_keys, 0) |i| { - fail_unless!(map.remove(&i)); + assert!(map.remove(&i)); } } } @@ -77,13 +77,13 @@ fn vector>(map: &mut M, n_keys: uint, dist: &[uint]) { do timed("search") { for uint::range(0, n_keys) |i| { - fail_unless!(map.find(&dist[i]).unwrap() == &(i + 1)); + assert!(map.find(&dist[i]).unwrap() == &(i + 1)); } } do timed("remove") { for uint::range(0, n_keys) |i| { - fail_unless!(map.remove(&dist[i])); + assert!(map.remove(&dist[i])); } } } diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs index adfde66e57a01..a3210108dcc17 100644 --- a/src/test/bench/core-set.rs +++ b/src/test/bench/core-set.rs @@ -42,7 +42,7 @@ pub impl Results { } for uint::range(0, num_keys) |i| { - fail_unless!(set.contains(&i)); + assert!(set.contains(&i)); } } } @@ -64,7 +64,7 @@ pub impl Results { do timed(&mut self.delete_ints) { for uint::range(0, num_keys) |i| { - fail_unless!(set.remove(&i)); + assert!(set.remove(&i)); } } } @@ -82,7 +82,7 @@ pub impl Results { for uint::range(0, num_keys) |i| { let s = uint::to_str(i); - fail_unless!(set.contains(&s)); + assert!(set.contains(&s)); } } } @@ -104,7 +104,7 @@ pub impl Results { } do timed(&mut self.delete_strings) { for uint::range(0, num_keys) |i| { - fail_unless!(set.remove(&uint::to_str(i))); + assert!(set.remove(&uint::to_str(i))); } } } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 899b86b5cfb03..a156f915faca7 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -300,7 +300,7 @@ fn pbfs(&&graph: arc::ARC, key: node_id) -> bfs_result { }; result }; - fail_unless!((colors.len() == old_len)); + assert!((colors.len() == old_len)); } // Convert the results. @@ -468,7 +468,7 @@ fn main() { if do_validate { let start = time::precise_time_s(); - fail_unless!((validate(copy edges, *root, bfs_tree))); + assert!((validate(copy edges, *root, bfs_tree))); let stop = time::precise_time_s(); io::stdout().write_line( @@ -488,7 +488,7 @@ fn main() { if do_validate { let start = time::precise_time_s(); - fail_unless!((validate(copy edges, *root, bfs_tree))); + assert!((validate(copy edges, *root, bfs_tree))); let stop = time::precise_time_s(); io::stdout().write_line( @@ -508,7 +508,7 @@ fn main() { if do_validate { let start = time::precise_time_s(); - fail_unless!((validate(copy edges, *root, bfs_tree))); + assert!((validate(copy edges, *root, bfs_tree))); let stop = time::precise_time_s(); io::stdout().write_line(fmt!("Validation completed in %? seconds.", diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs index 5ae1f79630432..50647e8c100dc 100644 --- a/src/test/bench/msgsend-pipes-shared.rs +++ b/src/test/bench/msgsend-pipes-shared.rs @@ -95,7 +95,7 @@ fn run(args: &[~str]) { io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed)); let thruput = ((size / workers * workers) as float) / (elapsed as float); io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput)); - fail_unless!(result == num_bytes * size); + assert!(result == num_bytes * size); } fn main() { diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs index db1aaf9bcdbd4..77e64818f7e6c 100644 --- a/src/test/bench/msgsend-pipes.rs +++ b/src/test/bench/msgsend-pipes.rs @@ -92,7 +92,7 @@ fn run(args: &[~str]) { io::stdout().write_str(fmt!("Test took %? seconds\n", elapsed)); let thruput = ((size / workers * workers) as float) / (elapsed as float); io::stdout().write_str(fmt!("Throughput=%f per sec\n", thruput)); - fail_unless!(result == num_bytes * size); + assert!(result == num_bytes * size); } fn main() { diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 77cd7890f2987..a90afd418d881 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -73,7 +73,7 @@ fn stress_task(&&id: int) { let mut i = 0; loop { let n = 15; - fail_unless!((fib(n) == fib(n))); + assert!((fib(n) == fib(n))); i += 1; error!("%d: Completed %d iterations", id, i); } diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs index 930e3d8a60898..4b0d34d231511 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) { fn check_sequential(min: uint, max: uint, map: &SmallIntMap) { for uint::range(min, max) |i| { - fail_unless!(*map.get(&i) == i + 22u); + assert!(*map.get(&i) == i + 22u); } } diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index 09c9e27d4dbfe..9221da8b55738 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -63,7 +63,7 @@ pub impl Sudoku { } pub fn read(reader: @io::Reader) -> Sudoku { - fail_unless!(reader.read_line() == ~"9,9"); /* assert first line is exactly "9,9" */ + assert!(reader.read_line() == ~"9,9"); /* assert first line is exactly "9,9" */ let mut g = vec::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] }); while !reader.eof() { @@ -212,30 +212,30 @@ static default_solution: [[u8, ..9], ..9] = [ #[test] fn colors_new_works() { - fail_unless!(*Colors::new(1) == 1022u16); - fail_unless!(*Colors::new(2) == 1020u16); - fail_unless!(*Colors::new(3) == 1016u16); - fail_unless!(*Colors::new(4) == 1008u16); - fail_unless!(*Colors::new(5) == 992u16); - fail_unless!(*Colors::new(6) == 960u16); - fail_unless!(*Colors::new(7) == 896u16); - fail_unless!(*Colors::new(8) == 768u16); - fail_unless!(*Colors::new(9) == 512u16); + assert!(*Colors::new(1) == 1022u16); + assert!(*Colors::new(2) == 1020u16); + assert!(*Colors::new(3) == 1016u16); + assert!(*Colors::new(4) == 1008u16); + assert!(*Colors::new(5) == 992u16); + assert!(*Colors::new(6) == 960u16); + assert!(*Colors::new(7) == 896u16); + assert!(*Colors::new(8) == 768u16); + assert!(*Colors::new(9) == 512u16); } #[test] fn colors_next_works() { - fail_unless!(Colors(0).next() == 0u8); - fail_unless!(Colors(2).next() == 1u8); - fail_unless!(Colors(4).next() == 2u8); - fail_unless!(Colors(8).next() == 3u8); - fail_unless!(Colors(16).next() == 4u8); - fail_unless!(Colors(32).next() == 5u8); - fail_unless!(Colors(64).next() == 6u8); - fail_unless!(Colors(128).next() == 7u8); - fail_unless!(Colors(256).next() == 8u8); - fail_unless!(Colors(512).next() == 9u8); - fail_unless!(Colors(1024).next() == 0u8); + assert!(Colors(0).next() == 0u8); + assert!(Colors(2).next() == 1u8); + assert!(Colors(4).next() == 2u8); + assert!(Colors(8).next() == 3u8); + assert!(Colors(16).next() == 4u8); + assert!(Colors(32).next() == 5u8); + assert!(Colors(64).next() == 6u8); + assert!(Colors(128).next() == 7u8); + assert!(Colors(256).next() == 8u8); + assert!(Colors(512).next() == 9u8); + assert!(Colors(1024).next() == 0u8); } #[test] @@ -247,7 +247,7 @@ fn colors_remove_works() { colors.remove(1); // THEN - fail_unless!(colors.next() == 2u8); + assert!(colors.next() == 2u8); } #[test] @@ -260,7 +260,7 @@ fn check_default_sudoku_solution() { sudoku.solve(); // THEN - fail_unless!(sudoku.equal(&solution)); + assert!(sudoku.equal(&solution)); } fn main() { diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs index 889a2836c0ca9..d7514320e36d5 100644 --- a/src/test/bench/task-perf-linked-failure.rs +++ b/src/test/bench/task-perf-linked-failure.rs @@ -51,7 +51,7 @@ fn spawn_supervised_blocking(myname: &str, +f: ~fn()) { task::task().future_result(|+r| res = Some(r)).supervised().spawn(f); error!("%s group waiting", myname); let x = res.unwrap().recv(); - fail_unless!(x == task::Success); + assert!(x == task::Success); } fn main() { @@ -81,5 +81,5 @@ fn main() { error!("Grandparent group wakes up and fails"); fail!(); }; - fail_unless!(x.is_err()); + assert!(x.is_err()); } diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs index 1e21af7b3f054..e2dd13a4405d1 100644 --- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs @@ -18,5 +18,5 @@ fn main() { //~^ ERROR cannot infer an appropriate lifetime } // Adding this line causes a method unification failure instead - // do (&option::unwrap(y)).read |state| { fail_unless!(*state == 1); } + // do (&option::unwrap(y)).read |state| { assert!(*state == 1); } } diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs index b1375cc7980c8..78a50a4f21242 100644 --- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs @@ -18,5 +18,5 @@ fn main() { y = Some(write_mode); } // Adding this line causes a method unification failure instead - // do (&option::unwrap(y)).write |state| { fail_unless!(*state == 1); } + // do (&option::unwrap(y)).write |state| { assert!(*state == 1); } } diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs index 000d03ea73c0d..ecd31d0dde456 100644 --- a/src/test/compile-fail/autoderef-full-lval.rs +++ b/src/test/compile-fail/autoderef-full-lval.rs @@ -22,10 +22,10 @@ fn main() { let b: clam = clam{x: @10, y: @20}; let z: int = a.x + b.y; //~ ERROR binary operation + cannot be applied to type `@int` debug!(z); - fail_unless!((z == 21)); + assert!((z == 21)); let forty: fish = fish{a: @40}; let two: fish = fish{a: @2}; let answer: int = forty.a + two.a; //~ ERROR binary operation + cannot be applied to type `@int` debug!(answer); - fail_unless!((answer == 42)); + assert!((answer == 42)); } diff --git a/src/test/compile-fail/bind-by-move-no-guards.rs b/src/test/compile-fail/bind-by-move-no-guards.rs index 4a90d2f4b7fcf..ffc160ac11118 100644 --- a/src/test/compile-fail/bind-by-move-no-guards.rs +++ b/src/test/compile-fail/bind-by-move-no-guards.rs @@ -14,7 +14,7 @@ fn main() { c.send(false); match x { Some(z) if z.recv() => { fail!() }, //~ ERROR cannot bind by-move into a pattern guard - Some(z) => { fail_unless!(!z.recv()); }, + Some(z) => { assert!(!z.recv()); }, None => fail!() } } diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs index b4b10db939847..42c5ffe3e916b 100644 --- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs +++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs @@ -19,5 +19,5 @@ fn compute1() -> float { fn main() { let x = compute1(); debug!(x); - fail_unless!((x == -4f)); + assert!((x == -4f)); } diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs index 332ec3fe697d0..14cb37d775c43 100644 --- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs +++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs @@ -16,8 +16,8 @@ fn box_imm() { let mut v = ~3; do borrow(v) |w| { //~ NOTE loan of mutable local variable granted here v = ~4; //~ ERROR assigning to captured outer mutable variable in a stack closure prohibited due to outstanding loan - fail_unless!(*v == 3); - fail_unless!(*w == 4); + assert!(*v == 3); + assert!(*w == 4); } } diff --git a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs index b5c8f509167e3..aad86241e9a43 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 { } fn main() { - fail_unless!(destructure(Some(22)) == 22); + assert!(destructure(Some(22)) == 22); } diff --git a/src/test/compile-fail/cast-from-nil.rs b/src/test/compile-fail/cast-from-nil.rs index 1c2a3e1742672..558a54787183d 100644 --- a/src/test/compile-fail/cast-from-nil.rs +++ b/src/test/compile-fail/cast-from-nil.rs @@ -9,4 +9,4 @@ // except according to those terms. // error-pattern: cast from nil: `()` as `u32` -fn main() { let u = (fail_unless!(true) as u32); } +fn main() { let u = (assert!(true) as u32); } diff --git a/src/test/compile-fail/crateresolve5.rs b/src/test/compile-fail/crateresolve5.rs index 96e88f99bcb18..1ad190827dae9 100644 --- a/src/test/compile-fail/crateresolve5.rs +++ b/src/test/compile-fail/crateresolve5.rs @@ -18,5 +18,5 @@ extern mod cr5_2 (name = "crateresolve5", vers = "0.2"); fn main() { // Nominal types from two multiple versions of a crate are different types - fail_unless!(cr5_1::nominal() == cr5_2::nominal()); //~ ERROR mismatched types: expected + assert!(cr5_1::nominal() == cr5_2::nominal()); //~ ERROR mismatched types: expected } diff --git a/src/test/compile-fail/do2.rs b/src/test/compile-fail/do2.rs index 89821f9751396..4466c07518fec 100644 --- a/src/test/compile-fail/do2.rs +++ b/src/test/compile-fail/do2.rs @@ -11,6 +11,6 @@ fn f(f: @fn(int) -> bool) -> bool { f(10i) } fn main() { - fail_unless!(do f() |i| { i == 10i } == 10i); + assert!(do f() |i| { i == 10i } == 10i); //~^ ERROR: expected `bool` but found `int` } diff --git a/src/test/compile-fail/issue-1896-1.rs b/src/test/compile-fail/issue-1896-1.rs index e42382fc2aa48..fc5132d65104f 100644 --- a/src/test/compile-fail/issue-1896-1.rs +++ b/src/test/compile-fail/issue-1896-1.rs @@ -20,5 +20,5 @@ fn main () { let myInt: uint = (aFn.theFn)(); - fail_unless!(myInt == 10); + assert!(myInt == 10); } diff --git a/src/test/compile-fail/issue-2467.rs b/src/test/compile-fail/issue-2467.rs index aec14e7b71919..fd6e5a762b248 100644 --- a/src/test/compile-fail/issue-2467.rs +++ b/src/test/compile-fail/issue-2467.rs @@ -12,5 +12,5 @@ enum test { thing = 3u } //~ ERROR mismatched types //~^ ERROR expected signed integer constant fn main() { error!(thing as int); - fail_unless!((thing as int == 3)); + assert!((thing as int == 3)); } diff --git a/src/test/compile-fail/issue-2548.rs b/src/test/compile-fail/issue-2548.rs index f8f973dbc6bed..9c2d7baa23c26 100644 --- a/src/test/compile-fail/issue-2548.rs +++ b/src/test/compile-fail/issue-2548.rs @@ -38,8 +38,8 @@ fn main() { let mut v = ~[]; v = ~[(res)] + v; //~ instantiating a type parameter with an incompatible type `foo`, which does not fulfill `Copy` - fail_unless!((v.len() == 2)); + assert!((v.len() == 2)); } - fail_unless!(*x == 1); + assert!(*x == 1); } diff --git a/src/test/compile-fail/issue-2969.rs b/src/test/compile-fail/issue-2969.rs index 5e6fa6e95f87d..927e81db5c1c4 100644 --- a/src/test/compile-fail/issue-2969.rs +++ b/src/test/compile-fail/issue-2969.rs @@ -15,5 +15,5 @@ fn main() let mut x = [1, 2, 4]; let v : &int = &x[2]; x[2] = 6; - fail_unless!(*v == 6); + assert!(*v == 6); } diff --git a/src/test/compile-fail/issue-3888.rs b/src/test/compile-fail/issue-3888.rs index d9ea384d820c4..35f8557c32b60 100644 --- a/src/test/compile-fail/issue-3888.rs +++ b/src/test/compile-fail/issue-3888.rs @@ -25,17 +25,17 @@ fn vec_peek<'r, T>(v: &'r [T]) -> Option< (&'r T, &'r [T]) > { fn test_peek_empty_stack() { let v : &[int] = &[]; - fail_unless!((None == vec_peek(v))); + assert!((None == vec_peek(v))); } fn test_peek_empty_unique() { let v : ~[int] = ~[]; - fail_unless!((None == vec_peek(v))); + assert!((None == vec_peek(v))); } fn test_peek_empty_managed() { let v : @[int] = @[]; - fail_unless!((None == vec_peek(v))); + assert!((None == vec_peek(v))); } diff --git a/src/test/compile-fail/issue-511.rs b/src/test/compile-fail/issue-511.rs index 632b15dadd46b..90c46e5d602c9 100644 --- a/src/test/compile-fail/issue-511.rs +++ b/src/test/compile-fail/issue-511.rs @@ -12,7 +12,7 @@ extern mod std; use core::cmp::Eq; fn f(o: &mut Option) { - fail_unless!(*o == option::None); + assert!(*o == option::None); } fn main() { diff --git a/src/test/compile-fail/issue-818.rs b/src/test/compile-fail/issue-818.rs index 0de7276fc8cd3..df08652ea0ad8 100644 --- a/src/test/compile-fail/issue-818.rs +++ b/src/test/compile-fail/issue-818.rs @@ -20,5 +20,5 @@ mod ctr { fn main() { let c = ctr::new(42); let c2 = ctr::inc(c); - fail_unless!(*c2 == 5); //~ ERROR can only dereference enums with a single, public variant + assert!(*c2 == 5); //~ ERROR can only dereference enums with a single, public variant } diff --git a/src/test/compile-fail/kindck-owned-trait-contains.rs b/src/test/compile-fail/kindck-owned-trait-contains.rs index dadc66b5029c7..f5153265308e1 100644 --- a/src/test/compile-fail/kindck-owned-trait-contains.rs +++ b/src/test/compile-fail/kindck-owned-trait-contains.rs @@ -27,5 +27,5 @@ fn main() { let x: &'blk int = &3; repeater(@x) }; - fail_unless!(3 == *(y.get())); //~ ERROR reference is not valid + assert!(3 == *(y.get())); //~ ERROR reference is not valid } diff --git a/src/test/compile-fail/kindck-owned-trait-scoped.rs b/src/test/compile-fail/kindck-owned-trait-scoped.rs index 34ceb67f24343..bb0ba87c098cf 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: T) { let v = &3; struct F { f: T } let x = @F {f:t} as @foo; - fail_unless!(x.foo(v) == 3); + assert!(x.foo(v) == 3); } fn to_foo_2(t: T) -> @foo { diff --git a/src/test/compile-fail/mod_file_correct_spans.rs b/src/test/compile-fail/mod_file_correct_spans.rs index 832e6d8a6a79a..f8ea5dda18336 100644 --- a/src/test/compile-fail/mod_file_correct_spans.rs +++ b/src/test/compile-fail/mod_file_correct_spans.rs @@ -13,5 +13,5 @@ mod mod_file_aux; fn main() { - fail_unless!(mod_file_aux::bar() == 10); //~ ERROR unresolved name + assert!(mod_file_aux::bar() == 10); //~ ERROR unresolved name } diff --git a/src/test/compile-fail/mod_file_not_exist.rs b/src/test/compile-fail/mod_file_not_exist.rs index d742ad04d768c..17ca8dca27352 100644 --- a/src/test/compile-fail/mod_file_not_exist.rs +++ b/src/test/compile-fail/mod_file_not_exist.rs @@ -11,5 +11,5 @@ mod not_a_real_file; //~ ERROR not_a_real_file.rs fn main() { - fail_unless!(mod_file_aux::bar() == 10); + assert!(mod_file_aux::bar() == 10); } diff --git a/src/test/compile-fail/mod_file_with_path_attr.rs b/src/test/compile-fail/mod_file_with_path_attr.rs index 2f71f4d22f903..827c77bda471d 100644 --- a/src/test/compile-fail/mod_file_with_path_attr.rs +++ b/src/test/compile-fail/mod_file_with_path_attr.rs @@ -12,5 +12,5 @@ mod m; //~ ERROR not_a_real_file.rs fn main() { - fail_unless!(m::foo() == 10); + assert!(m::foo() == 10); } diff --git a/src/test/compile-fail/mode-inference-fail.rs b/src/test/compile-fail/mode-inference-fail.rs index d9f6cf8b2d722..4994bb323d9c5 100644 --- a/src/test/compile-fail/mode-inference-fail.rs +++ b/src/test/compile-fail/mode-inference-fail.rs @@ -18,6 +18,6 @@ fn apply_int(f: &fn(int) -> int, a: int) -> int { f(a) } fn main() { let f = {|i| i}; - fail_unless!(apply_int(f, 2) == 2); - fail_unless!(apply(f, 2) == 2); //~ ERROR expected argument mode && + assert!(apply_int(f, 2) == 2); + assert!(apply(f, 2) == 2); //~ ERROR expected argument mode && } diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 5e17b168d5555..da75dfd010685 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -19,10 +19,10 @@ fn main() { do task::spawn() { let v = *arc::get(&arc_v); - fail_unless!(v[3] == 4); + assert!(v[3] == 4); }; - fail_unless!((*arc::get(&arc_v))[2] == 3); + assert!((*arc::get(&arc_v))[2] == 3); info!(arc_v); } diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index 90faec802a421..75cd706985c64 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -17,10 +17,10 @@ fn main() { do task::spawn() { //~ NOTE `arc_v` moved into closure environment here let v = *arc::get(&arc_v); - fail_unless!(v[3] == 4); + assert!(v[3] == 4); }; - fail_unless!((*arc::get(&arc_v))[2] == 3); //~ ERROR use of moved value: `arc_v` + assert!((*arc::get(&arc_v))[2] == 3); //~ ERROR use of moved value: `arc_v` info!(arc_v); } diff --git a/src/test/compile-fail/noncopyable-match-pattern.rs b/src/test/compile-fail/noncopyable-match-pattern.rs index 0623f93a38bfb..e8b01765a447d 100644 --- a/src/test/compile-fail/noncopyable-match-pattern.rs +++ b/src/test/compile-fail/noncopyable-match-pattern.rs @@ -12,7 +12,7 @@ fn main() { let x = Some(unstable::exclusive(false)); match x { Some(copy z) => { //~ ERROR copying a value of non-copyable type - do z.with |b| { fail_unless!(!*b); } + do z.with |b| { assert!(!*b); } } None => fail!() } diff --git a/src/test/compile-fail/omitted-arg-wrong-types.rs b/src/test/compile-fail/omitted-arg-wrong-types.rs index 0ab53da0c4ae7..a44c113269b98 100644 --- a/src/test/compile-fail/omitted-arg-wrong-types.rs +++ b/src/test/compile-fail/omitted-arg-wrong-types.rs @@ -12,9 +12,9 @@ fn let_in(x: T, f: &fn(T)) {} fn main() { - let_in(3u, |i| { fail_unless!(i == 3); }); + let_in(3u, |i| { assert!(i == 3); }); //~^ ERROR expected `uint` but found `int` - let_in(3, |i| { fail_unless!(i == 3u); }); + let_in(3, |i| { assert!(i == 3u); }); //~^ ERROR expected `int` but found `uint` } diff --git a/src/test/compile-fail/private-struct-field-cross-crate.rs b/src/test/compile-fail/private-struct-field-cross-crate.rs index 1df102a751a3c..5a8f80845e16f 100644 --- a/src/test/compile-fail/private-struct-field-cross-crate.rs +++ b/src/test/compile-fail/private-struct-field-cross-crate.rs @@ -14,5 +14,5 @@ use cci_class::kitties::*; fn main() { let nyan : cat = cat(52u, 99); - fail_unless!((nyan.meows == 52u)); //~ ERROR field `meows` is private + assert!((nyan.meows == 52u)); //~ ERROR field `meows` is private } diff --git a/src/test/compile-fail/private-struct-field.rs b/src/test/compile-fail/private-struct-field.rs index 86a14587006ec..2f6a51e163729 100644 --- a/src/test/compile-fail/private-struct-field.rs +++ b/src/test/compile-fail/private-struct-field.rs @@ -20,5 +20,5 @@ mod cat { fn main() { let nyan = cat::new_cat(); - fail_unless!(nyan.meows == 52); //~ ERROR field `meows` is private + assert!(nyan.meows == 52); //~ ERROR field `meows` is private } diff --git a/src/test/compile-fail/regions-glb-free-free.rs b/src/test/compile-fail/regions-glb-free-free.rs index 1ae97d690ac24..9a4974849a50d 100644 --- a/src/test/compile-fail/regions-glb-free-free.rs +++ b/src/test/compile-fail/regions-glb-free-free.rs @@ -37,5 +37,5 @@ mod argparse { fn main () { let f : argparse::Flag = argparse::flag(~"flag", ~"My flag"); let updated_flag = f.set_desc(~"My new flag"); - fail_unless!(updated_flag.desc == "My new flag"); + assert!(updated_flag.desc == "My new flag"); } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs index 7e96ecd4142a7..a8b7ae1b9c8e4 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs @@ -19,7 +19,7 @@ fn x_coord<'r>(p: &'r point) -> &'r int { fn foo(p: @point) -> &int { let xc = x_coord(p); //~ ERROR illegal borrow - fail_unless!(*xc == 3); + assert!(*xc == 3); return xc; } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs index d982d3c95a578..bf8f227b5730e 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs +++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs @@ -19,10 +19,10 @@ fn foo(cond: &fn() -> bool, box: &fn() -> @int) { // of this borrow is the fn body as a whole. y = borrow(x); //~ ERROR illegal borrow: cannot root managed value long enough - fail_unless!(*x == *y); + assert!(*x == *y); if cond() { break; } } - fail_unless!(*y != 0); + assert!(*y != 0); } fn main() {} diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs index 2f455e89dff90..ff75ba4473de7 100644 --- a/src/test/compile-fail/regions-trait-1.rs +++ b/src/test/compile-fail/regions-trait-1.rs @@ -34,5 +34,5 @@ fn get_v(gc: @get_ctxt) -> uint { fn main() { let ctxt = ctxt { v: 22u }; let hc = has_ctxt { c: &ctxt }; - fail_unless!(get_v(@hc as @get_ctxt) == 22u); + assert!(get_v(@hc as @get_ctxt) == 22u); } diff --git a/src/test/compile-fail/regions-var-type-out-of-scope.rs b/src/test/compile-fail/regions-var-type-out-of-scope.rs index cd395fe4dd15a..7d75ac7434931 100644 --- a/src/test/compile-fail/regions-var-type-out-of-scope.rs +++ b/src/test/compile-fail/regions-var-type-out-of-scope.rs @@ -15,7 +15,7 @@ fn foo(cond: bool) { if cond { x = &3; //~ ERROR illegal borrow: borrowed value does not live long enough - fail_unless!((*x == 3)); + assert!((*x == 3)); } } diff --git a/src/test/compile-fail/tag-type-args.rs b/src/test/compile-fail/tag-type-args.rs index b13835a89d4f8..f2ef1d1952505 100644 --- a/src/test/compile-fail/tag-type-args.rs +++ b/src/test/compile-fail/tag-type-args.rs @@ -12,6 +12,6 @@ enum quux { bar } -fn foo(c: quux) { fail_unless!((false)); } +fn foo(c: quux) { assert!((false)); } fn main() { fail!(); } diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs index fab31f88e5475..dd0ae87f3118d 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: B) -> int { fn main() { let x = 3i; - fail_unless!(call_it(x) == 22); + assert!(call_it(x) == 22); } diff --git a/src/test/pretty/do1.rs b/src/test/pretty/do1.rs index 950d7b37aa237..6f9aa28f11a93 100644 --- a/src/test/pretty/do1.rs +++ b/src/test/pretty/do1.rs @@ -12,4 +12,4 @@ fn f(f: @fn(int)) { f(10) } -fn main() { do f |i| { fail_unless!(i == 10) } } +fn main() { do f |i| { assert!(i == 10) } } diff --git a/src/test/pretty/record-trailing-comma.rs b/src/test/pretty/record-trailing-comma.rs index fc80c75e53271..1ea0e10413271 100644 --- a/src/test/pretty/record-trailing-comma.rs +++ b/src/test/pretty/record-trailing-comma.rs @@ -18,5 +18,5 @@ struct Thing { fn main() { let sth = Thing{x: 0, y: 1,}; let sth2 = Thing{y: 9 , ..sth}; - fail_unless!(sth.x + sth2.y == 9); + assert!(sth.x + sth2.y == 9); } diff --git a/src/test/run-fail/assert-as-macro.rs b/src/test/run-fail/assert-as-macro.rs index 8bb1e278fd166..07813b91e571d 100644 --- a/src/test/run-fail/assert-as-macro.rs +++ b/src/test/run-fail/assert-as-macro.rs @@ -1,6 +1,6 @@ // error-pattern:assertion failed: 1 == 2 fn main() { - fail_unless!(1 == 2); + assert!(1 == 2); } diff --git a/src/test/run-fail/fail.rs b/src/test/run-fail/fail.rs index 23207dcf43706..42cf79af66ee8 100644 --- a/src/test/run-fail/fail.rs +++ b/src/test/run-fail/fail.rs @@ -12,4 +12,4 @@ // error-pattern:1 == 2 -fn main() { fail_unless!((1 == 2)); } +fn main() { assert!((1 == 2)); } diff --git a/src/test/run-fail/issue-2761.rs b/src/test/run-fail/issue-2761.rs index cf35d9624f3b0..95050a4dcf19e 100644 --- a/src/test/run-fail/issue-2761.rs +++ b/src/test/run-fail/issue-2761.rs @@ -11,5 +11,5 @@ // error-pattern:custom message fn main() { - fail_unless!(false, "custom message"); + assert!(false, "custom message"); } diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs index 458ec11c67431..054d6f697ae34 100644 --- a/src/test/run-fail/linked-failure.rs +++ b/src/test/run-fail/linked-failure.rs @@ -13,7 +13,7 @@ // error-pattern:1 == 2 extern mod std; -fn child() { fail_unless!((1 == 2)); } +fn child() { assert!((1 == 2)); } fn main() { let (p, _c) = comm::stream::(); diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs index 1955a29058fb7..3dc87e190a5d8 100644 --- a/src/test/run-fail/linked-failure4.rs +++ b/src/test/run-fail/linked-failure4.rs @@ -11,7 +11,7 @@ // error-pattern:1 == 2 -fn child() { fail_unless!((1 == 2)); } +fn child() { assert!((1 == 2)); } fn parent() { let (p, _c) = comm::stream::(); diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs index f7ece96fd6e31..38b73ea56980e 100644 --- a/src/test/run-fail/str-overrun.rs +++ b/src/test/run-fail/str-overrun.rs @@ -15,5 +15,5 @@ fn main() { let s: ~str = ~"hello"; // Bounds-check failure. - fail_unless!((s[5] == 0x0 as u8)); + assert!((s[5] == 0x0 as u8)); } diff --git a/src/test/run-fail/task-spawn-barefn.rs b/src/test/run-fail/task-spawn-barefn.rs index 17838348b82fe..11c9de6e14f45 100644 --- a/src/test/run-fail/task-spawn-barefn.rs +++ b/src/test/run-fail/task-spawn-barefn.rs @@ -17,5 +17,5 @@ fn main() { } fn startfn() { - fail_unless!(str::is_empty(~"Ensure that the child task runs by failing")); + assert!(str::is_empty(~"Ensure that the child task runs by failing")); } diff --git a/src/test/run-fail/unwind-alt.rs b/src/test/run-fail/unwind-alt.rs index 035afa781dee5..41cf92d92b855 100644 --- a/src/test/run-fail/unwind-alt.rs +++ b/src/test/run-fail/unwind-alt.rs @@ -16,7 +16,7 @@ fn test_box() { fn test_str() { let res = match false { true => { ~"happy" }, _ => fail!(~"non-exhaustive match failure") }; - fail_unless!(res == ~"happy"); + assert!(res == ~"happy"); } fn main() { test_box(); diff --git a/src/test/run-fail/unwind-assert.rs b/src/test/run-fail/unwind-assert.rs index 1d5397e7d3889..0e685a7a4693d 100644 --- a/src/test/run-fail/unwind-assert.rs +++ b/src/test/run-fail/unwind-assert.rs @@ -12,5 +12,5 @@ fn main() { let a = @0; - fail_unless!(false); + assert!(false); } diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs index 4617642524952..ab9dcf32781be 100644 --- a/src/test/run-fail/vec-overrun.rs +++ b/src/test/run-fail/vec-overrun.rs @@ -14,8 +14,8 @@ fn main() { let v: ~[int] = ~[10]; let x: int = 0; - fail_unless!((v[x] == 10)); + assert!((v[x] == 10)); // Bounds-check failure. - fail_unless!((v[x + 2] == 20)); + assert!((v[x + 2] == 20)); } diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs index c01dbf03455cb..6f403fd772193 100644 --- a/src/test/run-fail/vec-underrun.rs +++ b/src/test/run-fail/vec-underrun.rs @@ -14,8 +14,8 @@ fn main() { let v: ~[int] = ~[10, 20]; let x: int = 0; - fail_unless!((v[x] == 10)); + assert!((v[x] == 10)); // Bounds-check failure. - fail_unless!((v[x - 1] == 20)); + assert!((v[x - 1] == 20)); } diff --git a/src/test/run-fail/zip-different-lengths.rs b/src/test/run-fail/zip-different-lengths.rs index 5eae7fca8217e..87bb866904638 100644 --- a/src/test/run-fail/zip-different-lengths.rs +++ b/src/test/run-fail/zip-different-lengths.rs @@ -15,7 +15,7 @@ extern mod std; use core::vec::{same_length, zip}; fn enum_chars(start: u8, end: u8) -> ~[char] { - fail_unless!(start < end); + assert!(start < end); let mut i = start; let mut r = ~[]; while i <= end { r.push(i as char); i += 1 as u8; } @@ -23,7 +23,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] { } fn enum_uints(start: uint, end: uint) -> ~[uint] { - fail_unless!(start < end); + assert!(start < end); let mut i = start; let mut r = ~[]; while i <= end { r.push(i); i += 1; } @@ -35,7 +35,7 @@ fn main() { let chars = enum_chars(a, j); let ints = enum_uints(k, l); - fail_unless!(same_length(chars, ints)); + assert!(same_length(chars, ints)); let ps = zip(chars, ints); fail!(~"the impossible happened"); } diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs index 779fd3e490416..9c7caebc2eb6e 100644 --- a/src/test/run-pass-fulldeps/qquote.rs +++ b/src/test/run-pass-fulldeps/qquote.rs @@ -84,7 +84,7 @@ fn check_pp(cx: fake_ext_ctxt, stdout().write_line(s); if expect != ~"" { error!("expect: '%s', got: '%s'", expect, s); - fail_unless!(s == expect); + assert!(s == expect); } } diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs index f9ba6ed7f5438..e3a544af309b2 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: A, b: u16) -> @fn() -> (A, u16) { pub fn main() { let (a, b) = f(22_u64, 44u16)(); debug!("a=%? b=%?", a, b); - fail_unless!(a == 22u64); - fail_unless!(b == 44u16); + assert!(a == 22u64); + assert!(b == 44u16); } diff --git a/src/test/run-pass/alignment-gep-tup-like-2.rs b/src/test/run-pass/alignment-gep-tup-like-2.rs index 22855bce28fca..847e6fce8ee61 100644 --- a/src/test/run-pass/alignment-gep-tup-like-2.rs +++ b/src/test/run-pass/alignment-gep-tup-like-2.rs @@ -35,6 +35,6 @@ pub fn main() { make_cycle(z); let (a, b) = z(); debug!("a=%u b=%u", *a as uint, b as uint); - fail_unless!(*a == x); - fail_unless!(b == y); + assert!(*a == x); + assert!(b == y); } diff --git a/src/test/run-pass/alt-implicit-copy-unique.rs b/src/test/run-pass/alt-implicit-copy-unique.rs index c00b185d131aa..0497f11202f3b 100644 --- a/src/test/run-pass/alt-implicit-copy-unique.rs +++ b/src/test/run-pass/alt-implicit-copy-unique.rs @@ -14,7 +14,7 @@ pub fn main() { let mut x = ~Pair {a: ~10, b: ~20}; match x { ~Pair {a: ref mut a, b: ref mut b} => { - fail_unless!(**a == 10); *a = ~30; fail_unless!(**a == 30); + assert!(**a == 10); *a = ~30; assert!(**a == 30); } } } diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs index 131869a0c4ef4..8e71d8d4a6708 100644 --- a/src/test/run-pass/alt-pattern-drop.rs +++ b/src/test/run-pass/alt-pattern-drop.rs @@ -25,7 +25,7 @@ fn foo(s: @int) { _ => { debug!("?"); fail!(); } } debug!(::core::sys::refcount(s)); - fail_unless!((::core::sys::refcount(s) == count + 1u)); + assert!((::core::sys::refcount(s) == count + 1u)); let _ = ::core::sys::refcount(s); // don't get bitten by last-use. } @@ -39,5 +39,5 @@ pub fn main() { debug!("%u", ::core::sys::refcount(s)); let count2 = ::core::sys::refcount(s); let _ = ::core::sys::refcount(s); // don't get bitten by last-use. - fail_unless!(count == count2); + assert!(count == count2); } diff --git a/src/test/run-pass/alt-pattern-lit.rs b/src/test/run-pass/alt-pattern-lit.rs index 37f924dd1beb4..d6a8afbc4e734 100644 --- a/src/test/run-pass/alt-pattern-lit.rs +++ b/src/test/run-pass/alt-pattern-lit.rs @@ -18,4 +18,4 @@ fn altlit(f: int) -> int { } } -pub fn main() { fail_unless!((altlit(10) == 20)); fail_unless!((altlit(11) == 22)); } +pub fn main() { assert!((altlit(10) == 20)); assert!((altlit(11) == 22)); } diff --git a/src/test/run-pass/alt-ref-binding-in-guard-3256.rs b/src/test/run-pass/alt-ref-binding-in-guard-3256.rs index ece2943a1c12e..1ece3b5fd93b6 100644 --- a/src/test/run-pass/alt-ref-binding-in-guard-3256.rs +++ b/src/test/run-pass/alt-ref-binding-in-guard-3256.rs @@ -12,7 +12,7 @@ pub fn main() { let x = Some(unstable::exclusive(true)); match x { Some(ref z) if z.with(|b| *b) => { - do z.with |b| { fail_unless!(*b); } + do z.with |b| { assert!(*b); } }, _ => fail!() } diff --git a/src/test/run-pass/alt-ref-binding-mut-option.rs b/src/test/run-pass/alt-ref-binding-mut-option.rs index f6c5e64b35361..9ef414d1170be 100644 --- a/src/test/run-pass/alt-ref-binding-mut-option.rs +++ b/src/test/run-pass/alt-ref-binding-mut-option.rs @@ -14,5 +14,5 @@ pub fn main() { None => {} Some(ref mut p) => { *p += 1; } } - fail_unless!(v == Some(23)); + assert!(v == Some(23)); } diff --git a/src/test/run-pass/alt-ref-binding-mut.rs b/src/test/run-pass/alt-ref-binding-mut.rs index c8b1822e5fad4..2bd55b46784b8 100644 --- a/src/test/run-pass/alt-ref-binding-mut.rs +++ b/src/test/run-pass/alt-ref-binding-mut.rs @@ -21,5 +21,5 @@ fn destructure(x: &mut Rec) { pub fn main() { let mut v = Rec {f: 22}; destructure(&mut v); - fail_unless!(v.f == 23); + assert!(v.f == 23); } diff --git a/src/test/run-pass/alt-ref-binding.rs b/src/test/run-pass/alt-ref-binding.rs index 8b25d329b9a38..23b3062a83a8f 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 { } pub fn main() { - fail_unless!(destructure(Some(22)) == 22); + assert!(destructure(Some(22)) == 22); } diff --git a/src/test/run-pass/alt-str.rs b/src/test/run-pass/alt-str.rs index 4a362ca8e8783..e41ec8a99e93f 100644 --- a/src/test/run-pass/alt-str.rs +++ b/src/test/run-pass/alt-str.rs @@ -24,7 +24,7 @@ pub fn main() { } let x = match ~"a" { ~"a" => 1, ~"b" => 2, _ => fail!() }; - fail_unless!((x == 1)); + assert!((x == 1)); match ~"a" { ~"a" => { } ~"b" => { }, _ => fail!() } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index 8051a14dac875..e2e1bf540c2ce 100644 --- a/src/test/run-pass/alt-tag.rs +++ b/src/test/run-pass/alt-tag.rs @@ -32,7 +32,7 @@ pub fn main() { let gray: color = rgb(127, 127, 127); let clear: color = rgba(50, 150, 250, 0); let red: color = hsl(0, 255, 255); - fail_unless!((process(gray) == 127)); - fail_unless!((process(clear) == 0)); - fail_unless!((process(red) == 255)); + assert!((process(gray) == 127)); + assert!((process(clear) == 0)); + assert!((process(red) == 255)); } diff --git a/src/test/run-pass/alt-unique-bind.rs b/src/test/run-pass/alt-unique-bind.rs index 6412cc7ffd58a..2fb0a345157ee 100644 --- a/src/test/run-pass/alt-unique-bind.rs +++ b/src/test/run-pass/alt-unique-bind.rs @@ -12,7 +12,7 @@ pub fn main() { match ~100 { ~x => { debug!("%?", x); - fail_unless!(x == 100); + assert!(x == 100); } } } diff --git a/src/test/run-pass/alt-with-ret-arm.rs b/src/test/run-pass/alt-with-ret-arm.rs index ad4d87fb87c80..d5d2e20cba3d5 100644 --- a/src/test/run-pass/alt-with-ret-arm.rs +++ b/src/test/run-pass/alt-with-ret-arm.rs @@ -16,6 +16,6 @@ pub fn main() { None => return (), Some(num) => num as u32 }; - fail_unless!(f == 1234u32); + assert!(f == 1234u32); error!(f) } diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs index 11f988bc2961b..d61c1214633fc 100644 --- a/src/test/run-pass/argument-passing.rs +++ b/src/test/run-pass/argument-passing.rs @@ -23,9 +23,9 @@ fn f2(a: int, f: &fn(int)) -> int { f(1); return a; } pub fn main() { let mut a = X {x: 1}, b = 2, c = 3; - fail_unless!((f1(&mut a, &mut b, c) == 6)); - fail_unless!((a.x == 0)); - fail_unless!((b == 10)); - fail_unless!((f2(a.x, |x| a.x = 50) == 0)); - fail_unless!((a.x == 50)); + assert!((f1(&mut a, &mut b, c) == 6)); + assert!((a.x == 0)); + assert!((b == 10)); + assert!((f2(a.x, |x| a.x = 50) == 0)); + assert!((a.x == 50)); } diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs index adfc1033d972b..a0512ffff2a4f 100644 --- a/src/test/run-pass/arith-0.rs +++ b/src/test/run-pass/arith-0.rs @@ -13,5 +13,5 @@ pub fn main() { let a: int = 10; debug!(a); - fail_unless!((a * (a - 1) == 90)); + assert!((a * (a - 1) == 90)); } diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs index 1b98cf4dc5c39..c0db96f99c7f4 100644 --- a/src/test/run-pass/arith-1.rs +++ b/src/test/run-pass/arith-1.rs @@ -12,22 +12,22 @@ pub fn main() { let i32_a: int = 10; - fail_unless!((i32_a == 10)); - fail_unless!((i32_a - 10 == 0)); - fail_unless!((i32_a / 10 == 1)); - fail_unless!((i32_a - 20 == -10)); - fail_unless!((i32_a << 10 == 10240)); - fail_unless!((i32_a << 16 == 655360)); - fail_unless!((i32_a * 16 == 160)); - fail_unless!((i32_a * i32_a * i32_a == 1000)); - fail_unless!((i32_a * i32_a * i32_a * i32_a == 10000)); - fail_unless!((i32_a * i32_a / i32_a * i32_a == 100)); - fail_unless!((i32_a * (i32_a - 1) << 2 + i32_a == 368640)); + assert!((i32_a == 10)); + assert!((i32_a - 10 == 0)); + assert!((i32_a / 10 == 1)); + assert!((i32_a - 20 == -10)); + assert!((i32_a << 10 == 10240)); + assert!((i32_a << 16 == 655360)); + assert!((i32_a * 16 == 160)); + assert!((i32_a * i32_a * i32_a == 1000)); + assert!((i32_a * i32_a * i32_a * i32_a == 10000)); + assert!((i32_a * i32_a / i32_a * i32_a == 100)); + assert!((i32_a * (i32_a - 1) << 2 + i32_a == 368640)); let i32_b: int = 0x10101010; - fail_unless!((i32_b + 1 - 1 == i32_b)); - fail_unless!((i32_b << 1 == i32_b << 1)); - fail_unless!((i32_b >> 1 == i32_b >> 1)); - fail_unless!((i32_b & i32_b << 1 == 0)); + assert!((i32_b + 1 - 1 == i32_b)); + assert!((i32_b << 1 == i32_b << 1)); + assert!((i32_b >> 1 == i32_b >> 1)); + assert!((i32_b & i32_b << 1 == 0)); debug!(i32_b | i32_b << 1); - fail_unless!((i32_b | i32_b << 1 == 0x30303030)); + assert!((i32_b | i32_b << 1 == 0x30303030)); } diff --git a/src/test/run-pass/arith-2.rs b/src/test/run-pass/arith-2.rs index 3ca889428d7e4..70df6e46e59d7 100644 --- a/src/test/run-pass/arith-2.rs +++ b/src/test/run-pass/arith-2.rs @@ -12,6 +12,6 @@ pub fn main() { let i32_c: int = 0x10101010; - fail_unless!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) == + assert!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) == i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3)); } diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs index 45bd35a68af54..a921d9f7ddc7b 100644 --- a/src/test/run-pass/arith-unsigned.rs +++ b/src/test/run-pass/arith-unsigned.rs @@ -13,24 +13,24 @@ // Unsigned integer operations pub fn main() { - fail_unless!((0u8 < 255u8)); - fail_unless!((0u8 <= 255u8)); - fail_unless!((255u8 > 0u8)); - fail_unless!((255u8 >= 0u8)); - fail_unless!((250u8 / 10u8 == 25u8)); - fail_unless!((255u8 % 10u8 == 5u8)); - fail_unless!((0u16 < 60000u16)); - fail_unless!((0u16 <= 60000u16)); - fail_unless!((60000u16 > 0u16)); - fail_unless!((60000u16 >= 0u16)); - fail_unless!((60000u16 / 10u16 == 6000u16)); - fail_unless!((60005u16 % 10u16 == 5u16)); - fail_unless!((0u32 < 4000000000u32)); - fail_unless!((0u32 <= 4000000000u32)); - fail_unless!((4000000000u32 > 0u32)); - fail_unless!((4000000000u32 >= 0u32)); - fail_unless!((4000000000u32 / 10u32 == 400000000u32)); - fail_unless!((4000000005u32 % 10u32 == 5u32)); + assert!((0u8 < 255u8)); + assert!((0u8 <= 255u8)); + assert!((255u8 > 0u8)); + assert!((255u8 >= 0u8)); + assert!((250u8 / 10u8 == 25u8)); + assert!((255u8 % 10u8 == 5u8)); + assert!((0u16 < 60000u16)); + assert!((0u16 <= 60000u16)); + assert!((60000u16 > 0u16)); + assert!((60000u16 >= 0u16)); + assert!((60000u16 / 10u16 == 6000u16)); + assert!((60005u16 % 10u16 == 5u16)); + assert!((0u32 < 4000000000u32)); + assert!((0u32 <= 4000000000u32)); + assert!((4000000000u32 > 0u32)); + assert!((4000000000u32 >= 0u32)); + assert!((4000000000u32 / 10u32 == 400000000u32)); + assert!((4000000005u32 % 10u32 == 5u32)); // 64-bit numbers have some flakiness yet. Not tested } diff --git a/src/test/run-pass/artificial-block.rs b/src/test/run-pass/artificial-block.rs index e3159df837852..7bc1354c3cefe 100644 --- a/src/test/run-pass/artificial-block.rs +++ b/src/test/run-pass/artificial-block.rs @@ -10,4 +10,4 @@ fn f() -> int { { return 3; } } -pub fn main() { fail_unless!((f() == 3)); } +pub fn main() { assert!((f() == 3)); } diff --git a/src/test/run-pass/assign-assign.rs b/src/test/run-pass/assign-assign.rs index f3a792d6cca6d..dc0850b24f1f6 100644 --- a/src/test/run-pass/assign-assign.rs +++ b/src/test/run-pass/assign-assign.rs @@ -12,21 +12,21 @@ fn test_assign() { let mut x: int; let mut y: () = x = 10; - fail_unless!((x == 10)); + assert!((x == 10)); let mut z = x = 11; - fail_unless!((x == 11)); + assert!((x == 11)); z = x = 12; - fail_unless!((x == 12)); + assert!((x == 12)); } fn test_assign_op() { let mut x: int = 0; let mut y: () = x += 10; - fail_unless!((x == 10)); + assert!((x == 10)); let mut z = x += 11; - fail_unless!((x == 21)); + assert!((x == 21)); z = x += 12; - fail_unless!((x == 33)); + assert!((x == 33)); } pub fn main() { test_assign(); test_assign_op(); } diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index c9e42aadfd446..c557aa7e22383 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -41,17 +41,17 @@ fn length>(x: T) -> uint { pub fn main() { let x = ~[0,1,2,3]; // Call a method - for x.iterate() |y| { fail_unless!(x[*y] == *y); } + for x.iterate() |y| { assert!(x[*y] == *y); } // Call a parameterized function - fail_unless!(length(x.clone()) == vec::len(x)); + assert!(length(x.clone()) == vec::len(x)); // Call a parameterized function, with type arguments that require // a borrow - fail_unless!(length::(x) == vec::len(x)); + assert!(length::(x) == vec::len(x)); // Now try it with a type that *needs* to be borrowed let z = [0,1,2,3]; // Call a method - for z.iterate() |y| { fail_unless!(z[*y] == *y); } + for z.iterate() |y| { assert!(z[*y] == *y); } // Call a parameterized function - fail_unless!(length::(z) == vec::len(z)); + assert!(length::(z) == vec::len(z)); } diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs index 1a8ad446c7954..c4d4f305a62db 100644 --- a/src/test/run-pass/auto-encode.rs +++ b/src/test/run-pass/auto-encode.rs @@ -34,7 +34,7 @@ fn test_prettyprint>( a.encode(&prettyprint::Serializer(w)) }; debug!("s == %?", s); - fail_unless!(s == *expected); + assert!(s == *expected); } fn test_ebml MyIter for &'self [int] { - fn test_imm(&self) { fail_unless!(self[0] == 1) } - fn test_const(&const self) { fail_unless!(self[0] == 1) } + fn test_imm(&self) { assert!(self[0] == 1) } + fn test_const(&const self) { assert!(self[0] == 1) } } impl<'self> MyIter for &'self str { - fn test_imm(&self) { fail_unless!(*self == "test") } - fn test_const(&const self) { fail_unless!(*self == "test") } + fn test_imm(&self) { assert!(*self == "test") } + fn test_const(&const self) { assert!(*self == "test") } } pub fn main() { diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index 2d2e909a5f987..03e847e237d3a 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -22,5 +22,5 @@ pub fn main() { let mut v = ~[1]; v.push_val(2); v.push_val(3); - fail_unless!(v == ~[1, 2, 3]); + assert!(v == ~[1, 2, 3]); } diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index 44688a8dfce96..afaafd45b7b6f 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -13,7 +13,7 @@ fn f(x: ~[T]) -> T { return x[0]; } fn g(act: &fn(~[int]) -> int) -> int { return act(~[1, 2, 3]); } pub fn main() { - fail_unless!((g(f) == 1)); + assert!((g(f) == 1)); let f1: &fn(~[~str]) -> ~str = f; - fail_unless!((f1(~[~"x", ~"y", ~"z"]) == ~"x")); + assert!((f1(~[~"x", ~"y", ~"z"]) == ~"x")); } diff --git a/src/test/run-pass/autoderef-method-newtype.rs b/src/test/run-pass/autoderef-method-newtype.rs index a4dbab49c0c4d..2d6f03c1daf20 100644 --- a/src/test/run-pass/autoderef-method-newtype.rs +++ b/src/test/run-pass/autoderef-method-newtype.rs @@ -20,5 +20,5 @@ struct foo(uint); pub fn main() { let x = foo(3u); - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs index 3fabb95f2a351..32f09369d9817 100644 --- a/src/test/run-pass/autoderef-method-on-trait.rs +++ b/src/test/run-pass/autoderef-method-on-trait.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @(@3u as @double); - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs index e6efa6dc633d7..eaef1ae3477a7 100644 --- a/src/test/run-pass/autoderef-method-priority.rs +++ b/src/test/run-pass/autoderef-method-priority.rs @@ -25,5 +25,5 @@ impl double for @uint { pub fn main() { let x = @3u; - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs index a54e77476cf7c..c04efd7e18f54 100644 --- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs +++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs @@ -18,5 +18,5 @@ impl double for @uint { pub fn main() { let x = @@@@@3u; - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs index dde6ae9e5de48..0a2a93d40d186 100644 --- a/src/test/run-pass/autoderef-method-twice.rs +++ b/src/test/run-pass/autoderef-method-twice.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @@3u; - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs index f6e04c79d454a..b704011ad9882 100644 --- a/src/test/run-pass/autoderef-method.rs +++ b/src/test/run-pass/autoderef-method.rs @@ -18,5 +18,5 @@ impl double for uint { pub fn main() { let x = @3u; - fail_unless!(x.double() == 6u); + assert!(x.double() == 6u); } diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs index 0b872569f19bc..5325242b99c33 100644 --- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs +++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs @@ -26,5 +26,5 @@ impl Foo for uint { pub fn main() { let x = @3u; - fail_unless!(x.foo() == ~"@3"); + assert!(x.foo() == ~"@3"); } diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs index 5e28f193357ca..41aa204279689 100644 --- a/src/test/run-pass/big-literals.rs +++ b/src/test/run-pass/big-literals.rs @@ -11,11 +11,11 @@ // except according to those terms. pub fn main() { - fail_unless!(0xffffffffu32 == (-1 as u32)); - fail_unless!(4294967295u32 == (-1 as u32)); - fail_unless!(0xffffffffffffffffu64 == (-1 as u64)); - fail_unless!(18446744073709551615u64 == (-1 as u64)); + assert!(0xffffffffu32 == (-1 as u32)); + assert!(4294967295u32 == (-1 as u32)); + assert!(0xffffffffffffffffu64 == (-1 as u64)); + assert!(18446744073709551615u64 == (-1 as u64)); - fail_unless!(-2147483648i32 - 1i32 == 2147483647i32); - fail_unless!(-9223372036854775808i64 - 1i64 == 9223372036854775807i64); + assert!(-2147483648i32 - 1i32 == 2147483647i32); + assert!(-9223372036854775808i64 - 1i64 == 9223372036854775807i64); } diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs index 2153db5e40c81..50dbefdd086a9 100644 --- a/src/test/run-pass/binary-minus-without-space.rs +++ b/src/test/run-pass/binary-minus-without-space.rs @@ -12,5 +12,5 @@ pub fn main() { match -1 { -1 => {}, _ => fail!(~"wat") } - fail_unless!(1-1 == 0); + assert!(1-1 == 0); } diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs index 3f5547df17d8f..e0a2d1ffa1c95 100644 --- a/src/test/run-pass/binops.rs +++ b/src/test/run-pass/binops.rs @@ -11,55 +11,55 @@ // Binop corner cases fn test_nil() { - fail_unless!((() == ())); - fail_unless!((!(() != ()))); - fail_unless!((!(() < ()))); - fail_unless!((() <= ())); - fail_unless!((!(() > ()))); - fail_unless!((() >= ())); + assert!((() == ())); + assert!((!(() != ()))); + assert!((!(() < ()))); + assert!((() <= ())); + assert!((!(() > ()))); + assert!((() >= ())); } fn test_bool() { - fail_unless!((!(true < false))); - fail_unless!((!(true <= false))); - fail_unless!((true > false)); - fail_unless!((true >= false)); + assert!((!(true < false))); + assert!((!(true <= false))); + assert!((true > false)); + assert!((true >= false)); - fail_unless!((false < true)); - fail_unless!((false <= true)); - fail_unless!((!(false > true))); - fail_unless!((!(false >= true))); + assert!((false < true)); + assert!((false <= true)); + assert!((!(false > true))); + assert!((!(false >= true))); // Bools support bitwise binops - fail_unless!((false & false == false)); - fail_unless!((true & false == false)); - fail_unless!((true & true == true)); - fail_unless!((false | false == false)); - fail_unless!((true | false == true)); - fail_unless!((true | true == true)); - fail_unless!((false ^ false == false)); - fail_unless!((true ^ false == true)); - fail_unless!((true ^ true == false)); + assert!((false & false == false)); + assert!((true & false == false)); + assert!((true & true == true)); + assert!((false | false == false)); + assert!((true | false == true)); + assert!((true | true == true)); + assert!((false ^ false == false)); + assert!((true ^ false == true)); + assert!((true ^ true == false)); } fn test_char() { let ch10 = 10 as char; let ch4 = 4 as char; let ch2 = 2 as char; - fail_unless!((ch10 + ch4 == 14 as char)); - fail_unless!((ch10 - ch4 == 6 as char)); - fail_unless!((ch10 * ch4 == 40 as char)); - fail_unless!((ch10 / ch4 == ch2)); - fail_unless!((ch10 % ch4 == ch2)); - fail_unless!((ch10 >> ch2 == ch2)); - fail_unless!((ch10 << ch4 == 160 as char)); - fail_unless!((ch10 | ch4 == 14 as char)); - fail_unless!((ch10 & ch2 == ch2)); - fail_unless!((ch10 ^ ch2 == 8 as char)); + assert!((ch10 + ch4 == 14 as char)); + assert!((ch10 - ch4 == 6 as char)); + assert!((ch10 * ch4 == 40 as char)); + assert!((ch10 / ch4 == ch2)); + assert!((ch10 % ch4 == ch2)); + assert!((ch10 >> ch2 == ch2)); + assert!((ch10 << ch4 == 160 as char)); + assert!((ch10 | ch4 == 14 as char)); + assert!((ch10 & ch2 == ch2)); + assert!((ch10 ^ ch2 == 8 as char)); } fn test_box() { - fail_unless!((@10 == @10)); + assert!((@10 == @10)); } fn test_ptr() { @@ -68,14 +68,14 @@ fn test_ptr() { let p2: *u8 = ::core::cast::reinterpret_cast(&0); let p3: *u8 = ::core::cast::reinterpret_cast(&1); - fail_unless!(p1 == p2); - fail_unless!(p1 != p3); - fail_unless!(p1 < p3); - fail_unless!(p1 <= p3); - fail_unless!(p3 > p1); - fail_unless!(p3 >= p3); - fail_unless!(p1 <= p2); - fail_unless!(p1 >= p2); + assert!(p1 == p2); + assert!(p1 != p3); + assert!(p1 < p3); + assert!(p1 <= p3); + assert!(p3 > p1); + assert!(p3 >= p3); + assert!(p1 <= p2); + assert!(p1 >= p2); } } @@ -110,11 +110,11 @@ fn test_class() { (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&q))), (::core::cast::reinterpret_cast::<*p, uint>(&ptr::addr_of(&r)))); } - fail_unless!((q == r)); + assert!((q == r)); r.y = 17; - fail_unless!((r.y != q.y)); - fail_unless!((r.y == 17)); - fail_unless!((q != r)); + assert!((r.y != q.y)); + assert!((r.y == 17)); + assert!((q != r)); } pub fn main() { diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index ec324bcf33bcc..1a67329ff82b0 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -12,12 +12,12 @@ #[cfg(target_arch = "x86")] fn target() { - fail_unless!((-1000 as uint >> 3u == 536870787u)); + assert!((-1000 as uint >> 3u == 536870787u)); } #[cfg(target_arch = "x86_64")] fn target() { - fail_unless!((-1000 as uint >> 3u == 2305843009213693827u)); + assert!((-1000 as uint >> 3u == 2305843009213693827u)); } fn general() { @@ -28,14 +28,14 @@ fn general() { a = a ^ b; debug!(a); debug!(b); - fail_unless!((b == 1)); - fail_unless!((a == 2)); - fail_unless!((!0xf0 & 0xff == 0xf)); - fail_unless!((0xf0 | 0xf == 0xff)); - fail_unless!((0xf << 4 == 0xf0)); - fail_unless!((0xf0 >> 4 == 0xf)); - fail_unless!((-16 >> 2 == -4)); - fail_unless!((0b1010_1010 | 0b0101_0101 == 0xff)); + assert!((b == 1)); + assert!((a == 2)); + assert!((!0xf0 & 0xff == 0xf)); + assert!((0xf0 | 0xf == 0xff)); + assert!((0xf << 4 == 0xf0)); + assert!((0xf0 >> 4 == 0xf)); + assert!((-16 >> 2 == -4)); + assert!((0b1010_1010 | 0b0101_0101 == 0xff)); } pub fn main() { diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs index f0dafa0805ebc..22d495e2c1ba2 100644 --- a/src/test/run-pass/block-arg-call-as.rs +++ b/src/test/run-pass/block-arg-call-as.rs @@ -24,9 +24,9 @@ fn asBlock( f : &fn()->uint ) -> uint { pub fn main() { let x = asSendfn(|| 22u); - fail_unless!((x == 22u)); + assert!((x == 22u)); let x = asLambda(|| 22u); - fail_unless!((x == 22u)); + assert!((x == 22u)); let x = asBlock(|| 22u); - fail_unless!((x == 22u)); + assert!((x == 22u)); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs index b46aad9984564..74756d27fe763 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs @@ -14,5 +14,5 @@ pub fn main() { // Trailing expressions don't require parentheses: let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; - fail_unless!(y == 15f); + assert!(y == 15f); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs index b2e1bc515865a..4cadb883d9962 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-block-arg.rs @@ -12,5 +12,5 @@ pub fn main() { fn f(i: &fn() -> uint) -> uint { i() } let v = ~[-1f, 0f, 1f, 2f, 3f]; let z = do do vec::foldl(f, v) |x, _y| { x } { 22u }; - fail_unless!(z == 22u); + assert!(z == 22u); } diff --git a/src/test/run-pass/block-arg-can-be-followed-by-call.rs b/src/test/run-pass/block-arg-can-be-followed-by-call.rs index bbdbfc74b0e21..ac584324cece8 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-call.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-call.rs @@ -12,5 +12,5 @@ pub fn main() { fn f(i: uint) -> uint { i } let v = ~[-1f, 0f, 1f, 2f, 3f]; let z = do vec::foldl(f, v) |x, _y| { x } (22u); - fail_unless!(z == 22u); + assert!(z == 22u); } diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs index f74c531503f5e..ce0b85f414b39 100644 --- a/src/test/run-pass/block-arg-in-parentheses.rs +++ b/src/test/run-pass/block-arg-in-parentheses.rs @@ -28,9 +28,9 @@ fn w_ret(v: ~[int]) -> int { } pub fn main() { - fail_unless!(w_semi(~[0, 1, 2, 3]) == -10); - fail_unless!(w_paren1(~[0, 1, 2, 3]) == -4); - fail_unless!(w_paren2(~[0, 1, 2, 3]) == -4); - fail_unless!(w_ret(~[0, 1, 2, 3]) == -4); + assert!(w_semi(~[0, 1, 2, 3]) == -10); + assert!(w_paren1(~[0, 1, 2, 3]) == -4); + assert!(w_paren2(~[0, 1, 2, 3]) == -4); + assert!(w_ret(~[0, 1, 2, 3]) == -4); } diff --git a/src/test/run-pass/block-arg-used-as-any.rs b/src/test/run-pass/block-arg-used-as-any.rs index ae110a0477374..d8aeba355d147 100644 --- a/src/test/run-pass/block-arg-used-as-any.rs +++ b/src/test/run-pass/block-arg-used-as-any.rs @@ -14,5 +14,5 @@ fn call_any(f: &fn() -> uint) -> uint { pub fn main() { let x_r = do call_any { 22u }; - fail_unless!(x_r == 22u); + assert!(x_r == 22u); } diff --git a/src/test/run-pass/block-arg-used-as-lambda.rs b/src/test/run-pass/block-arg-used-as-lambda.rs index 6d26ede8e3abf..2a7bfe4e32876 100644 --- a/src/test/run-pass/block-arg-used-as-lambda.rs +++ b/src/test/run-pass/block-arg-used-as-lambda.rs @@ -19,6 +19,6 @@ pub fn main() { let x_r = x(22u); let y_r = y(x_r); - fail_unless!(x_r == 44u); - fail_unless!(y_r == 88u); + assert!(x_r == 44u); + assert!(y_r == 88u); } diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index fa8687e839ca2..4fecbd4e956b3 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -19,20 +19,20 @@ pub fn main() { // Usable at all: let mut any_negative = do vec::any(v) |e| { float::is_negative(*e) }; - fail_unless!(any_negative); + assert!(any_negative); // Higher precedence than assignments: any_negative = do vec::any(v) |e| { float::is_negative(*e) }; - fail_unless!(any_negative); + assert!(any_negative); // Higher precedence than unary operations: let abs_v = do vec::map(v) |e| { float::abs(*e) }; - fail_unless!(do vec::all(abs_v) |e| { float::is_nonnegative(*e) }); - fail_unless!(!do vec::any(abs_v) |e| { float::is_negative(*e) }); + assert!(do vec::all(abs_v) |e| { float::is_nonnegative(*e) }); + assert!(!do vec::any(abs_v) |e| { float::is_negative(*e) }); // Usable in funny statement-like forms: if !do vec::any(v) |e| { float::is_positive(*e) } { - fail_unless!(false); + assert!(false); } match do vec::all(v) |e| { float::is_negative(*e) } { true => { fail!(~"incorrect answer."); } @@ -51,12 +51,12 @@ pub fn main() { let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y }; - fail_unless!(w == y); - fail_unless!(y == z); + assert!(w == y); + assert!(y == z); // In the tail of a block let w = if true { do vec::any(abs_v) |e| { float::is_nonnegative(*e) } } else { false }; - fail_unless!(w); + assert!(w); } diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs index 39e19cfec97a2..d8f6f167f208a 100644 --- a/src/test/run-pass/block-expr-precedence.rs +++ b/src/test/run-pass/block-expr-precedence.rs @@ -58,8 +58,8 @@ pub fn main() { let num = 12; - fail_unless!(if (true) { 12 } else { 12 } - num == 0); - fail_unless!(12 - if (true) { 12 } else { 12 } == 0); + assert!(if (true) { 12 } else { 12 } - num == 0); + assert!(12 - if (true) { 12 } else { 12 } == 0); if (true) { 12; } {-num}; if (true) { 12; }; {-num}; if (true) { 12; };;; -num; diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs index dc8ad25e27606..5a4b2f8bfd663 100644 --- a/src/test/run-pass/block-fn-coerce.rs +++ b/src/test/run-pass/block-fn-coerce.rs @@ -11,7 +11,7 @@ fn force(f: &fn() -> int) -> int { return f(); } pub fn main() { fn f() -> int { return 7; } - fail_unless!((force(f) == 7)); + assert!((force(f) == 7)); let g = {||force(f)}; - fail_unless!((g() == 7)); + assert!((g() == 7)); } diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs index e60563827795b..0a3458ed8141a 100644 --- a/src/test/run-pass/block-iter-1.rs +++ b/src/test/run-pass/block-iter-1.rs @@ -21,5 +21,5 @@ pub fn main() { } }); error!(odds); - fail_unless!((odds == 4)); + assert!((odds == 4)); } diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs index 96336f5569c19..e5c527db5566b 100644 --- a/src/test/run-pass/block-iter-2.rs +++ b/src/test/run-pass/block-iter-2.rs @@ -21,5 +21,5 @@ pub fn main() { }); }); error!(sum); - fail_unless!((sum == 225)); + assert!((sum == 225)); } diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs index 28875da25a643..d4783e1c7dd2b 100644 --- a/src/test/run-pass/block-vec-map2.rs +++ b/src/test/run-pass/block-vec-map2.rs @@ -16,5 +16,5 @@ pub fn main() { ~[true, false, false, true, true], |i, b| if *b { -(*i) } else { *i } ); error!(v.clone()); - fail_unless!((v == ~[-1, 2, 3, -4, -5])); + assert!((v == ~[-1, 2, 3, -4, -5])); } diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs index 656abab0cc103..3d659d5d25673 100644 --- a/src/test/run-pass/bool-not.rs +++ b/src/test/run-pass/bool-not.rs @@ -13,6 +13,6 @@ // -*- rust -*- pub fn main() { - if !false { fail_unless!((true)); } else { fail_unless!((false)); } - if !true { fail_unless!((false)); } else { fail_unless!((true)); } + if !false { assert!((true)); } else { assert!((false)); } + if !true { assert!((false)); } else { assert!((true)); } } diff --git a/src/test/run-pass/borrowck-borrow-from-at-vec.rs b/src/test/run-pass/borrowck-borrow-from-at-vec.rs index 6757f8655f119..e5f2a18df63cf 100644 --- a/src/test/run-pass/borrowck-borrow-from-at-vec.rs +++ b/src/test/run-pass/borrowck-borrow-from-at-vec.rs @@ -16,5 +16,5 @@ fn sum_slice(x: &[int]) -> int { pub fn main() { let x = @[1, 2, 3]; - fail_unless!(sum_slice(x) == 6); + assert!(sum_slice(x) == 6); } diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs index f2e0b6c9ca0f4..401985023bcc7 100644 --- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs +++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs @@ -15,8 +15,8 @@ fn borrow(x: &int, f: &fn(x: &int)) { fn test1(x: @~int) { do borrow(&*x.clone()) |p| { let x_a = ptr::addr_of(&(**x)); - fail_unless!((x_a as uint) != ptr::to_uint(p)); - fail_unless!(unsafe{*x_a} == *p); + assert!((x_a as uint) != ptr::to_uint(p)); + assert!(unsafe{*x_a} == *p); } } diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs index 764f551048171..e9d4a24806819 100644 --- a/src/test/run-pass/borrowck-fixed-length-vecs.rs +++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs @@ -11,5 +11,5 @@ pub fn main() { let x = [22]; let y = &x[0]; - fail_unless!(*y == 22); + assert!(*y == 22); } diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs index a90381ad63130..6929a98d9e1a9 100644 --- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs +++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs @@ -19,5 +19,5 @@ fn has_mut_vec(+v: ~[int]) -> int { } pub fn main() { - fail_unless!(has_mut_vec(~[1, 2, 3]) == 6); + assert!(has_mut_vec(~[1, 2, 3]) == 6); } diff --git a/src/test/run-pass/borrowck-preserve-box-in-discr.rs b/src/test/run-pass/borrowck-preserve-box-in-discr.rs index ba1c6aec215c8..7e871bc7caaec 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-discr.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-discr.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x = @F {f: ~3}; match x { @F {f: ref b_x} => { - fail_unless!(**b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(**b_x))); + assert!(**b_x == 3); + assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(**b_x))); x = @F {f: ~4}; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint); - fail_unless!(**b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x))); + assert!(**b_x == 3); + assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x))); } } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs index 795b074e37c4f..a22dc6215251d 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-field.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - fail_unless!(before == after); + assert!(before == after); } struct F { f: ~int } @@ -22,12 +22,12 @@ struct F { f: ~int } pub fn main() { let mut x = @F {f: ~3}; do borrow(x.f) |b_x| { - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); x = @F {f: ~4}; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint); - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-pat.rs b/src/test/run-pass/borrowck-preserve-box-in-pat.rs index 374283ffb8ace..f9991199c8128 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-pat.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-pat.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x = @mut @F {f: ~3}; match x { @@F{f: ref b_x} => { - fail_unless!(**b_x == 3); - fail_unless!(ptr::addr_of(&(x.f)) == ptr::addr_of(b_x)); + assert!(**b_x == 3); + assert!(ptr::addr_of(&(x.f)) == ptr::addr_of(b_x)); *x = @F {f: ~4}; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(**b_x)) as uint); - fail_unless!(**b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x))); + assert!(**b_x == 3); + assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(**b_x))); } } } diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs index 11ec78b681cbb..990473256461e 100644 --- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs +++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - fail_unless!(before == after); + assert!(before == after); } struct F { f: ~int } @@ -22,12 +22,12 @@ struct F { f: ~int } pub fn main() { let mut x = ~@F{f: ~3}; do borrow(x.f) |b_x| { - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); *x = @F{f: ~4}; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint); - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs index 8d625476f57dc..0fe3b7947f466 100644 --- a/src/test/run-pass/borrowck-preserve-box.rs +++ b/src/test/run-pass/borrowck-preserve-box.rs @@ -14,18 +14,18 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - fail_unless!(before == after); + assert!(before == after); } pub fn main() { let mut x = @3; do borrow(x) |b_x| { - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x)) == ptr::addr_of(&(*b_x))); x = @22; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint); - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x)) != ptr::addr_of(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-preserve-cond-box.rs b/src/test/run-pass/borrowck-preserve-cond-box.rs index 808f333dbf195..18c185cfef1c3 100644 --- a/src/test/run-pass/borrowck-preserve-cond-box.rs +++ b/src/test/run-pass/borrowck-preserve-cond-box.rs @@ -25,13 +25,13 @@ fn testfn(cond: bool) { } debug!("*r = %d, exp = %d", *r, exp); - fail_unless!(*r == exp); + assert!(*r == exp); x = @5; y = @6; debug!("*r = %d, exp = %d", *r, exp); - fail_unless!(*r == exp); + assert!(*r == exp); } pub fn main() { diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs index fcb84eaaf00ab..5939391413c3e 100644 --- a/src/test/run-pass/borrowck-preserve-expl-deref.rs +++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs @@ -14,7 +14,7 @@ fn borrow(x: &int, f: &fn(x: &int)) { let before = *x; f(x); let after = *x; - fail_unless!(before == after); + assert!(before == after); } struct F { f: ~int } @@ -22,12 +22,12 @@ struct F { f: ~int } pub fn main() { let mut x = @F {f: ~3}; do borrow((*x).f) |b_x| { - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) == ptr::addr_of(&(*b_x))); x = @F {f: ~4}; debug!("ptr::addr_of(*b_x) = %x", ptr::addr_of(&(*b_x)) as uint); - fail_unless!(*b_x == 3); - fail_unless!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); + assert!(*b_x == 3); + assert!(ptr::addr_of(&(*x.f)) != ptr::addr_of(&(*b_x))); } } diff --git a/src/test/run-pass/borrowck-univariant-enum.rs b/src/test/run-pass/borrowck-univariant-enum.rs index e43bcecaa9f66..3ec061c2dea61 100644 --- a/src/test/run-pass/borrowck-univariant-enum.rs +++ b/src/test/run-pass/borrowck-univariant-enum.rs @@ -25,5 +25,5 @@ pub fn main() { *x * b } }; - fail_unless!(z == 18); + assert!(z == 18); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-2.rs b/src/test/run-pass/borrowed-ptr-pattern-2.rs index e1e5d6854283d..b15f9e76234a7 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-2.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-2.rs @@ -16,6 +16,6 @@ fn foo(s: &~str) -> bool { } pub fn main() { - fail_unless!(foo(&~"kitty")); - fail_unless!(!foo(&~"gata")); + assert!(foo(&~"kitty")); + assert!(!foo(&~"gata")); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-3.rs b/src/test/run-pass/borrowed-ptr-pattern-3.rs index 4bdecd5eeec0e..030e055c4ccb7 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-3.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-3.rs @@ -16,6 +16,6 @@ fn foo<'r>(s: &'r uint) -> bool { } pub fn main() { - fail_unless!(foo(&3)); - fail_unless!(!foo(&4)); + assert!(foo(&3)); + assert!(!foo(&4)); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs index 1f7464c3ad42b..d49ea86402a5f 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs @@ -10,7 +10,7 @@ pub fn main() { let (&x, &y, &z) = (&3, &'a', &@"No pets!"); - fail_unless!(x == 3); - fail_unless!(y == 'a'); - fail_unless!(z == @"No pets!"); + assert!(x == 3); + assert!(y == 'a'); + assert!(z == @"No pets!"); } diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index ebd5cf41db550..dc620d0733d75 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, y: &'r Option) -> &'r Option { pub fn main() { let x = None; let y = Some(3); - fail_unless!(select(&x, &y).get() == 3); + assert!(select(&x, &y).get() == 3); } diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs index e092dea3d1cad..44485b5c8df82 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(x: &T) -> T{ } pub fn main() { - fail_unless!(foo(&3) == 3); - fail_unless!(foo(&'a') == 'a'); - fail_unless!(foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool"); + assert!(foo(&3) == 3); + assert!(foo(&'a') == 'a'); + assert!(foo(&@"Dogs rule, cats drool") == @"Dogs rule, cats drool"); } diff --git a/src/test/run-pass/box-compare.rs b/src/test/run-pass/box-compare.rs index bceedcad4a81d..b68ecd3f4d3e0 100644 --- a/src/test/run-pass/box-compare.rs +++ b/src/test/run-pass/box-compare.rs @@ -11,7 +11,7 @@ pub fn main() { - fail_unless!((@1 < @3)); - fail_unless!((@@~"hello " > @@~"hello")); - fail_unless!((@@@~"hello" != @@@~"there")); + assert!((@1 < @3)); + assert!((@@~"hello " > @@~"hello")); + assert!((@@@~"hello" != @@@~"there")); } diff --git a/src/test/run-pass/box-pattern.rs b/src/test/run-pass/box-pattern.rs index fb88fce4232cc..89f62adcdee4f 100644 --- a/src/test/run-pass/box-pattern.rs +++ b/src/test/run-pass/box-pattern.rs @@ -12,7 +12,7 @@ struct Foo {a: int, b: uint} enum bar { u(@Foo), w(int), } pub fn main() { - fail_unless!(match u(@Foo{a: 10, b: 40u}) { + assert!(match u(@Foo{a: 10, b: 40u}) { u(@Foo{a: a, b: b}) => { a + (b as int) } _ => { 66 } } == 50); diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index 81ccfe5f4fafc..96fc7b84bcd9c 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 = Box {c: @foo}; debug!("see what's in our box"); - fail_unless!((unbox::(bfoo) == foo)); + assert!((unbox::(bfoo) == foo)); } diff --git a/src/test/run-pass/box.rs b/src/test/run-pass/box.rs index 12276e4cfa665..4c394a601b4cd 100644 --- a/src/test/run-pass/box.rs +++ b/src/test/run-pass/box.rs @@ -10,4 +10,4 @@ -pub fn main() { let x: @int = @10; fail_unless!((*x == 10)); } +pub fn main() { let x: @int = @10; assert!((*x == 10)); } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index f65e8481562dc..b3f524c0ad713 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -13,21 +13,21 @@ pub fn main() { let mut i = 0; while i < 20 { i += 1; if i == 10 { break; } } - fail_unless!((i == 10)); + assert!((i == 10)); loop { i += 1; if i == 20 { break; } } - fail_unless!((i == 20)); + assert!((i == 20)); for vec::each(~[1, 2, 3, 4, 5, 6]) |x| { - if *x == 3 { break; } fail_unless!((*x <= 3)); + if *x == 3 { break; } assert!((*x <= 3)); } i = 0; - while i < 10 { i += 1; if i % 2 == 0 { loop; } fail_unless!((i % 2 != 0)); } + while i < 10 { i += 1; if i % 2 == 0 { loop; } assert!((i % 2 != 0)); } i = 0; loop { - i += 1; if i % 2 == 0 { loop; } fail_unless!((i % 2 != 0)); + i += 1; if i % 2 == 0 { loop; } assert!((i % 2 != 0)); if i >= 10 { break; } } for vec::each(~[1, 2, 3, 4, 5, 6]) |x| { if *x % 2 == 0 { loop; } - fail_unless!((*x % 2 != 0)); + assert!((*x % 2 != 0)); } } diff --git a/src/test/run-pass/by-val-and-by-move.rs b/src/test/run-pass/by-val-and-by-move.rs index 673c558f98cf0..47d2f9e1df080 100644 --- a/src/test/run-pass/by-val-and-by-move.rs +++ b/src/test/run-pass/by-val-and-by-move.rs @@ -22,5 +22,5 @@ fn free(-_t: T) { pub fn main() { let z = @3; - fail_unless!(3 == it_takes_two(z, z)); + assert!(3 == it_takes_two(z, z)); } diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs index b23e2147f96a0..a87dbaab5c99b 100644 --- a/src/test/run-pass/c-stack-returning-int64.rs +++ b/src/test/run-pass/c-stack-returning-int64.rs @@ -29,8 +29,8 @@ fn atoll(s: ~str) -> i64 { pub fn main() { unsafe { - fail_unless!(atol(~"1024") * 10 == atol(~"10240")); - fail_unless!((atoll(~"11111111111111111") * 10i64) + assert!(atol(~"1024") * 10 == atol(~"10240")); + assert!((atoll(~"11111111111111111") * 10i64) == atoll(~"111111111111111110")); } } diff --git a/src/test/run-pass/call-closure-from-overloaded-op.rs b/src/test/run-pass/call-closure-from-overloaded-op.rs index 39864059fcd48..8832620c4bfc7 100644 --- a/src/test/run-pass/call-closure-from-overloaded-op.rs +++ b/src/test/run-pass/call-closure-from-overloaded-op.rs @@ -13,5 +13,5 @@ fn foo() -> int { 22 } pub fn main() { let mut x: ~[@fn() -> int] = ~[]; x.push(foo); - fail_unless!((x[0])() == 22); + assert!((x[0])() == 22); } diff --git a/src/test/run-pass/cap-clause-move.rs b/src/test/run-pass/cap-clause-move.rs index 44f9b3e990e9a..7731ef8908de7 100644 --- a/src/test/run-pass/cap-clause-move.rs +++ b/src/test/run-pass/cap-clause-move.rs @@ -12,20 +12,20 @@ pub fn main() { let x = ~1; let y = ptr::addr_of(&(*x)) as uint; let lam_move: @fn() -> uint = || ptr::addr_of(&(*x)) as uint; - fail_unless!(lam_move() == y); + assert!(lam_move() == y); let x = ~2; let y = ptr::addr_of(&(*x)) as uint; let lam_move: @fn() -> uint = || ptr::addr_of(&(*x)) as uint; - fail_unless!(lam_move() == y); + assert!(lam_move() == y); let x = ~3; let y = ptr::addr_of(&(*x)) as uint; let snd_move: ~fn() -> uint = || ptr::addr_of(&(*x)) as uint; - fail_unless!(snd_move() == y); + assert!(snd_move() == y); let x = ~4; let y = ptr::addr_of(&(*x)) as uint; let lam_move: ~fn() -> uint = || ptr::addr_of(&(*x)) as uint; - fail_unless!(lam_move() == y); + assert!(lam_move() == y); } diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs index 97400198167d9..1df1f3b4c8b4f 100644 --- a/src/test/run-pass/cast.rs +++ b/src/test/run-pass/cast.rs @@ -14,13 +14,13 @@ // -*- rust -*- pub fn main() { let i: int = 'Q' as int; - fail_unless!((i == 0x51)); + assert!((i == 0x51)); let u: u32 = i as u32; - fail_unless!((u == 0x51 as u32)); - fail_unless!((u == 'Q' as u32)); - fail_unless!((i as u8 == 'Q' as u8)); - fail_unless!((i as u8 as i8 == 'Q' as u8 as i8)); - fail_unless!((0x51 as char == 'Q')); - fail_unless!((true == 1 as bool)); - fail_unless!((0 as u32 == false as u32)); + assert!((u == 0x51 as u32)); + assert!((u == 'Q' as u32)); + assert!((i as u8 == 'Q' as u8)); + assert!((i as u8 as i8 == 'Q' as u8 as i8)); + assert!((0x51 as char == 'Q')); + assert!((true == 1 as bool)); + assert!((0 as u32 == false as u32)); } diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs index 7e30910b169a9..e6ec46acd23e3 100644 --- a/src/test/run-pass/cci_borrow.rs +++ b/src/test/run-pass/cci_borrow.rs @@ -18,5 +18,5 @@ pub fn main() { let p = @22u; let r = foo(p); debug!("r=%u", r); - fail_unless!(r == 22u); + assert!(r == 22u); } diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs index 2366582a4ed96..db25b36aa6169 100644 --- a/src/test/run-pass/cci_impl_exe.rs +++ b/src/test/run-pass/cci_impl_exe.rs @@ -23,6 +23,6 @@ pub fn main() { //let bt1 = sys::frame_address(); //debug!("%?", bt1); - //fail_unless!(bt0 == bt1); + //assert!(bt0 == bt1); } } diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs index 55ecf317f8514..5511301911089 100644 --- a/src/test/run-pass/cci_iter_exe.rs +++ b/src/test/run-pass/cci_iter_exe.rs @@ -20,6 +20,6 @@ pub fn main() { //debug!("%?", bt0); do cci_iter_lib::iter(~[1, 2, 3]) |i| { io::print(fmt!("%d", i)); - //fail_unless!(bt0 == sys::rusti::frame_address(2u32)); + //assert!(bt0 == sys::rusti::frame_address(2u32)); } } diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs index 56b4275959912..f6bfa25d94d86 100644 --- a/src/test/run-pass/cci_nested_exe.rs +++ b/src/test/run-pass/cci_nested_exe.rs @@ -18,12 +18,12 @@ pub fn main() { let lst = new_int_alist(); alist_add(lst, 22, ~"hi"); alist_add(lst, 44, ~"ho"); - fail_unless!(alist_get(lst, 22) == ~"hi"); - fail_unless!(alist_get(lst, 44) == ~"ho"); + assert!(alist_get(lst, 22) == ~"hi"); + assert!(alist_get(lst, 44) == ~"ho"); let lst = new_int_alist_2(); alist_add(lst, 22, ~"hi"); alist_add(lst, 44, ~"ho"); - fail_unless!(alist_get(lst, 22) == ~"hi"); - fail_unless!(alist_get(lst, 44) == ~"ho"); + assert!(alist_get(lst, 22) == ~"hi"); + assert!(alist_get(lst, 44) == ~"ho"); } diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs index f2e6eeb31fff4..a1c2666b2e517 100644 --- a/src/test/run-pass/cci_no_inline_exe.rs +++ b/src/test/run-pass/cci_no_inline_exe.rs @@ -28,6 +28,6 @@ pub fn main() { //let bt1 = sys::frame_address(); //debug!("%?", bt1); - //fail_unless!(bt0 != bt1); + //assert!(bt0 != bt1); } } diff --git a/src/test/run-pass/cfgs-on-items.rs b/src/test/run-pass/cfgs-on-items.rs index 47aa683ecd22d..ed025623ac311 100644 --- a/src/test/run-pass/cfgs-on-items.rs +++ b/src/test/run-pass/cfgs-on-items.rs @@ -26,6 +26,6 @@ fn foo2() -> int { 3 } fn main() { - fail_unless!(1 == foo1()); - fail_unless!(3 == foo2()); + assert!(1 == foo1()); + assert!(3 == foo2()); } diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs index d1d1cc84d3896..bcfc6a3ccd9a6 100644 --- a/src/test/run-pass/char.rs +++ b/src/test/run-pass/char.rs @@ -13,11 +13,11 @@ pub fn main() { let c: char = 'x'; let d: char = 'x'; - fail_unless!((c == 'x')); - fail_unless!(('x' == c)); - fail_unless!((c == c)); - fail_unless!((c == d)); - fail_unless!((d == c)); - fail_unless!((d == 'x')); - fail_unless!(('x' == d)); + assert!((c == 'x')); + assert!(('x' == c)); + assert!((c == c)); + assert!((c == d)); + assert!((d == c)); + assert!((d == 'x')); + assert!(('x' == d)); } diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs index 5f3650d3aec25..68bc567cf5108 100644 --- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs +++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs @@ -17,7 +17,7 @@ use cci_class_cast::kitty::*; fn print_out(thing: @ToStr, expected: ~str) { let actual = thing.to_str(); debug!("%s", actual); - fail_unless!((actual == expected)); + assert!((actual == expected)); } pub fn main() { diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate.rs b/src/test/run-pass/class-cast-to-trait-cross-crate.rs index c3f5db0b1005c..10cce8cf56a47 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(thing: T, expected: str) { let actual = thing.to_str(); debug!("%s", actual); - fail_unless!((actual == expected)); + assert!((actual == expected)); } pub fn main() { diff --git a/src/test/run-pass/class-cast-to-trait-multiple-types.rs b/src/test/run-pass/class-cast-to-trait-multiple-types.rs index eefa78cc3c9af..be63e3394789e 100644 --- a/src/test/run-pass/class-cast-to-trait-multiple-types.rs +++ b/src/test/run-pass/class-cast-to-trait-multiple-types.rs @@ -88,6 +88,6 @@ pub fn main() { let whitefang : dog = dog(); annoy_neighbors(@(copy nyan) as @noisy); annoy_neighbors(@(copy whitefang) as @noisy); - fail_unless!((nyan.meow_count() == 10u)); - fail_unless!((*whitefang.volume == 1)); + assert!((nyan.meow_count() == 10u)); + assert!((*whitefang.volume == 1)); } diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs index 6a665f770ffdd..6684a729d23bb 100644 --- a/src/test/run-pass/class-exports.rs +++ b/src/test/run-pass/class-exports.rs @@ -34,5 +34,5 @@ mod kitty { } pub fn main() { - fail_unless!((cat(~"Spreckles").get_name() == ~"Spreckles")); + assert!((cat(~"Spreckles").get_name() == ~"Spreckles")); } diff --git a/src/test/run-pass/class-impl-parameterized-trait.rs b/src/test/run-pass/class-impl-parameterized-trait.rs index 87573b84dc885..53ae0021a91b9 100644 --- a/src/test/run-pass/class-impl-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-parameterized-trait.rs @@ -78,6 +78,6 @@ pub fn main() { for uint::range(1u, 5u) |_i| { nyan.speak(); } // cat returns true if uint input is greater than // the number of meows so far - fail_unless!((nyan.get(1))); - fail_unless!((!nyan.get(10))); + assert!((nyan.get(1))); + assert!((!nyan.get(10))); } diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index bc6972bfb2753..30ca5ea3881c9 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -135,11 +135,11 @@ priv impl cat { pub fn main() { let mut nyan: cat<~str> = cat::new(0, 2, ~"nyan"); for uint::range(1, 5) |_| { nyan.speak(); } - fail_unless!((*nyan.find(&1).unwrap() == ~"nyan")); - fail_unless!((nyan.find(&10) == None)); + assert!((*nyan.find(&1).unwrap() == ~"nyan")); + assert!((nyan.find(&10) == None)); let mut spotty: cat = cat::new(2, 57, tuxedo); for uint::range(0, 6) |_| { spotty.speak(); } - fail_unless!((spotty.len() == 8)); - fail_unless!((spotty.contains_key(&2))); - fail_unless!((spotty.get(&3) == &tuxedo)); + assert!((spotty.len() == 8)); + assert!((spotty.contains_key(&2))); + assert!((spotty.get(&3) == &tuxedo)); } diff --git a/src/test/run-pass/class-implement-trait-cross-crate.rs b/src/test/run-pass/class-implement-trait-cross-crate.rs index ed3e3e38c93ba..226dbe535fa13 100644 --- a/src/test/run-pass/class-implement-trait-cross-crate.rs +++ b/src/test/run-pass/class-implement-trait-cross-crate.rs @@ -60,7 +60,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat { pub fn main() { let mut nyan = cat(0u, 2, ~"nyan"); nyan.eat(); - fail_unless!((!nyan.eat())); + assert!((!nyan.eat())); for uint::range(1u, 10u) |_i| { nyan.speak(); }; - fail_unless!((nyan.eat())); + assert!((nyan.eat())); } diff --git a/src/test/run-pass/class-implement-traits.rs b/src/test/run-pass/class-implement-traits.rs index 7cd2753ee1548..ebc4668e70f40 100644 --- a/src/test/run-pass/class-implement-traits.rs +++ b/src/test/run-pass/class-implement-traits.rs @@ -65,7 +65,7 @@ fn make_speak(mut c: C) { pub fn main() { let mut nyan = cat(0u, 2, ~"nyan"); nyan.eat(); - fail_unless!((!nyan.eat())); + assert!((!nyan.eat())); for uint::range(1u, 10u) |_i| { make_speak(nyan); }; - fail_unless!((nyan.eat())); + assert!((nyan.eat())); } diff --git a/src/test/run-pass/class-implements-multiple-traits.rs b/src/test/run-pass/class-implements-multiple-traits.rs index 22519be081774..3a5bd648639a6 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(critter: T) -> bool { pub fn main() { let nyan : cat = cat(0u, 2, "nyan"); annoy_neighbors(nyan as noisy); - fail_unless!((nyan.meow_count() == 10u)); - fail_unless!((bite_everything(nyan as bitey))); - fail_unless!((scratched_something(nyan as scratchy))); + assert!((nyan.meow_count() == 10u)); + assert!((bite_everything(nyan as bitey))); + assert!((scratched_something(nyan as scratchy))); } diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs index cb266c1f9b49d..a6ab91a2c8822 100644 --- a/src/test/run-pass/class-method-cross-crate.rs +++ b/src/test/run-pass/class-method-cross-crate.rs @@ -16,7 +16,7 @@ use cci_class_2::kitties::*; pub fn main() { let nyan : cat = cat(52u, 99); let kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(); } diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs index 2664841e3e4b2..8e5843c6a85be 100644 --- a/src/test/run-pass/class-methods-cross-crate.rs +++ b/src/test/run-pass/class-methods-cross-crate.rs @@ -16,8 +16,8 @@ use cci_class_3::kitties::*; pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(); - fail_unless!((nyan.meow_count() == 53u)); + assert!((nyan.meow_count() == 53u)); } diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs index 0168db2b7b5c7..1c4c83999f7df 100644 --- a/src/test/run-pass/class-methods.rs +++ b/src/test/run-pass/class-methods.rs @@ -29,8 +29,8 @@ fn cat(in_x: uint, in_y: int) -> cat { pub fn main() { let mut nyan: cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(); - fail_unless!((nyan.meow_count() == 53u)); + assert!((nyan.meow_count() == 53u)); } diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs index e87cbc383bc64..cde171a44e243 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 = cat::(52u, 99, ~['p']); let mut kitty = cat(1000u, 2, ~[~"tabby"]); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(~[1u,2u,3u]); - fail_unless!((nyan.meow_count() == 55u)); + assert!((nyan.meow_count() == 55u)); kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); - fail_unless!((kitty.meow_count() == 1004u)); + assert!((kitty.meow_count() == 1004u)); } diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index 95db23f6c5afe..adcab8b40aa47 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(in_x : uint, in_y : int, +in_info: ~[U]) -> cat { pub fn main() { let mut nyan : cat = cat::(52u, 99, ~[9]); let mut kitty = cat(1000u, 2, ~[~"tabby"]); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(~[1,2,3]); - fail_unless!((nyan.meow_count() == 55u)); + assert!((nyan.meow_count() == 55u)); kitty.speak(~[~"meow", ~"mew", ~"purr", ~"chirp"]); - fail_unless!((kitty.meow_count() == 1004u)); + assert!((kitty.meow_count() == 1004u)); } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index 168f2d872e737..e058b3331b386 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -62,7 +62,7 @@ impl ToStr for cat { fn print_out(thing: @ToStr, expected: ~str) { let actual = thing.to_str(); debug!("%s", actual); - fail_unless!((actual == expected)); + assert!((actual == expected)); } pub fn main() { diff --git a/src/test/run-pass/class-trait-bounded-param.rs b/src/test/run-pass/class-trait-bounded-param.rs index e525312d6da5b..f4fd548a8e44f 100644 --- a/src/test/run-pass/class-trait-bounded-param.rs +++ b/src/test/run-pass/class-trait-bounded-param.rs @@ -31,5 +31,5 @@ pub fn main() { let m = int_hash(); m.insert(1, 2); m.insert(3, 4); - fail_unless!(iter::to_vec(keys(m)) == ~[1, 3]); + assert!(iter::to_vec(keys(m)) == ~[1, 3]); } diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs index 2999f38caecd0..6a8a47990b844 100644 --- a/src/test/run-pass/classes-cross-crate.rs +++ b/src/test/run-pass/classes-cross-crate.rs @@ -16,7 +16,7 @@ use cci_class_4::kitties::*; pub fn main() { let mut nyan = cat(0u, 2, ~"nyan"); nyan.eat(); - fail_unless!((!nyan.eat())); + assert!((!nyan.eat())); for uint::range(1u, 10u) |_i| { nyan.speak(); }; - fail_unless!((nyan.eat())); + assert!((nyan.eat())); } diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs index b1deb5b5e1a4c..6c35d113e0e39 100644 --- a/src/test/run-pass/classes-simple-cross-crate.rs +++ b/src/test/run-pass/classes-simple-cross-crate.rs @@ -16,6 +16,6 @@ use cci_class::kitties::*; pub fn main() { let nyan : cat = cat(52u, 99); let kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); } diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs index bb2da08d5a168..cd318ab6c6b7e 100644 --- a/src/test/run-pass/classes-simple-method.rs +++ b/src/test/run-pass/classes-simple-method.rs @@ -28,7 +28,7 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); nyan.speak(); } diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs index 850e34db6d121..0af281bdce40d 100644 --- a/src/test/run-pass/classes-simple.rs +++ b/src/test/run-pass/classes-simple.rs @@ -24,6 +24,6 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); let mut kitty = cat(1000u, 2); - fail_unless!((nyan.how_hungry == 99)); - fail_unless!((kitty.how_hungry == 2)); + assert!((nyan.how_hungry == 99)); + assert!((kitty.how_hungry == 2)); } diff --git a/src/test/run-pass/classes.rs b/src/test/run-pass/classes.rs index 136573fe05bc6..523469041416a 100644 --- a/src/test/run-pass/classes.rs +++ b/src/test/run-pass/classes.rs @@ -51,7 +51,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat { pub fn main() { let mut nyan = cat(0u, 2, ~"nyan"); nyan.eat(); - fail_unless!((!nyan.eat())); + assert!((!nyan.eat())); for uint::range(1u, 10u) |_i| { nyan.speak(); }; - fail_unless!((nyan.eat())); + assert!((nyan.eat())); } diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs index 84bcc66397001..41f76b1b4f2f3 100644 --- a/src/test/run-pass/cleanup-copy-mode.rs +++ b/src/test/run-pass/cleanup-copy-mode.rs @@ -12,7 +12,7 @@ fn adder(+x: @int, +y: @int) -> int { return *x + *y; } fn failer() -> @int { fail!(); } pub fn main() { - fail_unless!(result::is_err(&task::try(|| { + assert!(result::is_err(&task::try(|| { adder(@2, failer()); () }))); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index 08ff8b1ab4fdd..f0734e285b261 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -13,8 +13,8 @@ extern mod std; fn f(x : @{a:int, b:int}) { - fail_unless!((x.a == 10)); - fail_unless!((x.b == 12)); + assert!((x.a == 10)); + assert!((x.b == 12)); } pub fn main() { diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs index 5a853d9fe21d9..0cff05ed19f27 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: A, b: u16) -> @fn() -> (A, u16) { pub fn main() { let (a, b) = f(22_u64, 44u16)(); debug!("a=%? b=%?", a, b); - fail_unless!(a == 22u64); - fail_unless!(b == 44u16); + assert!(a == 22u64); + assert!(b == 44u16); } diff --git a/src/test/run-pass/closure-inference.rs b/src/test/run-pass/closure-inference.rs index e61636a323a65..6cdb8f393d526 100644 --- a/src/test/run-pass/closure-inference.rs +++ b/src/test/run-pass/closure-inference.rs @@ -16,5 +16,5 @@ fn apply(f: &fn(A) -> A, v: A) -> A { f(v) } pub fn main() { let f = {|i| foo(i)}; - fail_unless!(apply(f, 2) == 3); + assert!(apply(f, 2) == 3); } diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs index 05926761897c3..4e2972394453f 100644 --- a/src/test/run-pass/closure-inference2.rs +++ b/src/test/run-pass/closure-inference2.rs @@ -12,6 +12,6 @@ pub fn main() { let f = {|i| i}; - fail_unless!(f(2) == 2); - fail_unless!(f(5) == 5); + assert!(f(2) == 2); + assert!(f(5) == 5); } diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs index 12ca00fedd3f9..c4bed1e7d7da4 100644 --- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs @@ -12,5 +12,5 @@ fn foo(speaker: &const SpeechMaker) -> uint { pub fn main() { let mut lincoln = SpeechMaker {speeches: 22}; - fail_unless!(foo(&const lincoln) == 55); + assert!(foo(&const lincoln) == 55); } diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs index 7dcf49ef1ac44..1511eab8241d4 100644 --- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs @@ -14,7 +14,7 @@ fn bip(v: &[uint]) -> ~[uint] { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; - fail_unless!(the_vec == foo(the_vec)); - fail_unless!(the_vec == bar(the_vec)); - fail_unless!(the_vec == bip(the_vec)); + assert!(the_vec == foo(the_vec)); + assert!(the_vec == bar(the_vec)); + assert!(the_vec == bip(the_vec)); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index f89a59ff022db..bfc1de4d1e7fa 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -11,5 +11,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; bar(the_vec); - fail_unless!(the_vec == ~[100, 3, 2, 1]); + assert!(the_vec == ~[100, 3, 2, 1]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index c656dfd1530d5..0e67532d7a1fc 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -17,5 +17,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = ~[1, 2, 3, 100]; bar(the_vec); - fail_unless!(the_vec == ~[100, 3, 2, 1]); + assert!(the_vec == ~[100, 3, 2, 1]); } diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index 601bae85d4fc2..a01b06d4d7ce9 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -17,7 +17,7 @@ pub fn main() { let y = p.recv(); error!("received"); error!(y); - fail_unless!((y == 10)); + assert!((y == 10)); } fn child(c: &Chan) { diff --git a/src/test/run-pass/compare-generic-enums.rs b/src/test/run-pass/compare-generic-enums.rs index 9c91bad0df720..c6f4fecf8acc6 100644 --- a/src/test/run-pass/compare-generic-enums.rs +++ b/src/test/run-pass/compare-generic-enums.rs @@ -15,8 +15,8 @@ fn cmp(x: Option, y: Option) -> bool { } pub fn main() { - fail_unless!(!cmp(Some(3), None)); - fail_unless!(!cmp(Some(3), Some(4))); - fail_unless!(cmp(Some(3), Some(3))); - fail_unless!(cmp(None, None)); + assert!(!cmp(Some(3), None)); + assert!(!cmp(Some(3), Some(4))); + assert!(cmp(Some(3), Some(3))); + assert!(cmp(None, None)); } diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs index 194f0e71b1733..609bfe7a4cb2a 100644 --- a/src/test/run-pass/conditional-compile.rs +++ b/src/test/run-pass/conditional-compile.rs @@ -88,7 +88,7 @@ pub fn main() { fail!() } pub fn main() { // Exercise some of the configured items in ways that wouldn't be possible // if they had the bogus definition - fail_unless!((b)); + assert!((b)); let x: t = true; let y: tg = bar; @@ -104,7 +104,7 @@ fn test_in_fn_ctxt() { #[cfg(bogus)] static i: int = 0; static i: int = 1; - fail_unless!((i == 1)); + assert!((i == 1)); } mod test_foreign_items { diff --git a/src/test/run-pass/const-autoderef-newtype.rs b/src/test/run-pass/const-autoderef-newtype.rs index a157c46403bf3..021196bf7072a 100644 --- a/src/test/run-pass/const-autoderef-newtype.rs +++ b/src/test/run-pass/const-autoderef-newtype.rs @@ -13,5 +13,5 @@ static C0: S = S([3]); static C1: int = C0[0]; pub fn main() { - fail_unless!(C1 == 3); + assert!(C1 == 3); } diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs index 572b961b2f884..a7f9b57718c77 100644 --- a/src/test/run-pass/const-autoderef.rs +++ b/src/test/run-pass/const-autoderef.rs @@ -14,6 +14,6 @@ static C: &'static &'static &'static &'static [u8, ..1] = & & & &A; static D: u8 = (&C)[0]; pub fn main() { - fail_unless!(B == A[0]); - fail_unless!(D == A[0]); + assert!(B == A[0]); + assert!(D == A[0]); } diff --git a/src/test/run-pass/const-big-enum.rs b/src/test/run-pass/const-big-enum.rs index 97544da41c024..3aa7fd475b084 100644 --- a/src/test/run-pass/const-big-enum.rs +++ b/src/test/run-pass/const-big-enum.rs @@ -22,13 +22,13 @@ pub fn main() { _ => fail!() } match Y { - Bar(s) => fail_unless!(s == 2654435769), + Bar(s) => assert!(s == 2654435769), _ => fail!() } match Z { Quux(d,h) => { - fail_unless!((d == 0x123456789abcdef0)); - fail_unless!((h == 0x1234)); + assert!((d == 0x123456789abcdef0)); + assert!((h == 0x1234)); } _ => fail!() } diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs index f6f0e6ef3700b..ea5533da14d9d 100644 --- a/src/test/run-pass/const-cast-ptr-int.rs +++ b/src/test/run-pass/const-cast-ptr-int.rs @@ -11,5 +11,5 @@ static a: *u8 = 0 as *u8; pub fn main() { - fail_unless!(a == ptr::null()); + assert!(a == ptr::null()); } diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs index 981a8a94b0938..d35ad9d2da3e1 100644 --- a/src/test/run-pass/const-cast.rs +++ b/src/test/run-pass/const-cast.rs @@ -16,6 +16,6 @@ static a: &'static int = &10; static b: *int = a as *int; pub fn main() { - fail_unless!(x as *libc::c_void == y); - fail_unless!(a as *int == b); + assert!(x as *libc::c_void == y); + assert!(a as *int == b); } diff --git a/src/test/run-pass/const-const.rs b/src/test/run-pass/const-const.rs index 3f8a7da4c149d..e68bf8a74c3a3 100644 --- a/src/test/run-pass/const-const.rs +++ b/src/test/run-pass/const-const.rs @@ -12,5 +12,5 @@ static a: int = 1; static b: int = a + 2; pub fn main() { - fail_unless!(b == 3); + assert!(b == 3); } diff --git a/src/test/run-pass/const-contents.rs b/src/test/run-pass/const-contents.rs index 379089cc2a2d2..19ce5b3713df2 100644 --- a/src/test/run-pass/const-contents.rs +++ b/src/test/run-pass/const-contents.rs @@ -18,10 +18,10 @@ static notb : bool = !true; static neg : int = -(1); pub fn main() { - fail_unless!((lsl == 4)); - fail_unless!((add == 3)); - fail_unless!((addf == 3.0f)); - fail_unless!((not == -1)); - fail_unless!((notb == false)); - fail_unless!((neg == -1)); + assert!((lsl == 4)); + assert!((add == 3)); + assert!((addf == 3.0f)); + assert!((not == -1)); + assert!((notb == false)); + assert!((neg == -1)); } diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs index 130f43cfddd34..55975d364c84f 100644 --- a/src/test/run-pass/const-cross-crate-const.rs +++ b/src/test/run-pass/const-cross-crate-const.rs @@ -17,9 +17,9 @@ static a: uint = cci_const::uint_val; static b: uint = cci_const::uint_expr + 5; fn main() { - fail_unless!(a == 12); + assert!(a == 12); let foo2 = a; - fail_unless!(foo2 == cci_const::uint_val); - fail_unless!(b == cci_const::uint_expr + 5); - fail_unless!(foo == cci_const::foopy); + assert!(foo2 == cci_const::uint_val); + assert!(b == cci_const::uint_expr + 5); + assert!(foo == cci_const::foopy); } diff --git a/src/test/run-pass/const-cross-crate-extern.rs b/src/test/run-pass/const-cross-crate-extern.rs index 67bae91b26ec9..bac84d12e4ce1 100644 --- a/src/test/run-pass/const-cross-crate-extern.rs +++ b/src/test/run-pass/const-cross-crate-extern.rs @@ -16,5 +16,5 @@ use cci_const::bar; static foo: *u8 = bar; pub fn main() { - fail_unless!(foo == cci_const::bar); + assert!(foo == cci_const::bar); } diff --git a/src/test/run-pass/const-deref.rs b/src/test/run-pass/const-deref.rs index a69ca9cb93979..ee98e60f4d63f 100644 --- a/src/test/run-pass/const-deref.rs +++ b/src/test/run-pass/const-deref.rs @@ -15,6 +15,6 @@ static E: &'static S = &S(C); static F: int = ***E; pub fn main() { - fail_unless!(D == 1000); - fail_unless!(F == 1000); + assert!(D == 1000); + assert!(F == 1000); } diff --git a/src/test/run-pass/const-enum-cast.rs b/src/test/run-pass/const-enum-cast.rs index 800800a307b28..89990e9d892cc 100644 --- a/src/test/run-pass/const-enum-cast.rs +++ b/src/test/run-pass/const-enum-cast.rs @@ -20,12 +20,12 @@ pub fn main () { let a2 = B2 as int; let a3 = A2 as float; let a4 = B2 as float; - fail_unless!(c1 == 1); - fail_unless!(c2 == 2); - fail_unless!(c3 == 1.0); - fail_unless!(c4 == 2.0); - fail_unless!(a1 == 1); - fail_unless!(a2 == 2); - fail_unless!(a3 == 1.0); - fail_unless!(a4 == 2.0); + assert!(c1 == 1); + assert!(c2 == 2); + assert!(c3 == 1.0); + assert!(c4 == 2.0); + assert!(a1 == 1); + assert!(a2 == 2); + assert!(a3 == 1.0); + assert!(a4 == 2.0); } diff --git a/src/test/run-pass/const-enum-struct.rs b/src/test/run-pass/const-enum-struct.rs index 7da171cc00653..b6d916a9c38a1 100644 --- a/src/test/run-pass/const-enum-struct.rs +++ b/src/test/run-pass/const-enum-struct.rs @@ -14,6 +14,6 @@ static C: S = S { a: V16(0xDEAD), b: 0x600D, c: 0xBAD }; pub fn main() { let n = C.b; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-struct2.rs b/src/test/run-pass/const-enum-struct2.rs index c24db8414c416..3d9f7fc204404 100644 --- a/src/test/run-pass/const-enum-struct2.rs +++ b/src/test/run-pass/const-enum-struct2.rs @@ -14,6 +14,6 @@ static C: S = S { a: V0, b: 0x600D, c: 0xBAD }; pub fn main() { let n = C.b; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-structlike.rs b/src/test/run-pass/const-enum-structlike.rs index 12349eacd29a6..cc9d24e16db2c 100644 --- a/src/test/run-pass/const-enum-structlike.rs +++ b/src/test/run-pass/const-enum-structlike.rs @@ -18,6 +18,6 @@ static C: E = S1 { u: 23 }; pub fn main() { match C { S0 { _ } => fail!(), - S1 { u } => fail_unless!(u == 23) + S1 { u } => assert!(u == 23) } } diff --git a/src/test/run-pass/const-enum-tuple.rs b/src/test/run-pass/const-enum-tuple.rs index acefd4ff878b8..ade3dfd6b6358 100644 --- a/src/test/run-pass/const-enum-tuple.rs +++ b/src/test/run-pass/const-enum-tuple.rs @@ -13,6 +13,6 @@ static C: (E, u16, u16) = (V16(0xDEAD), 0x600D, 0xBAD); pub fn main() { let (_, n, _) = C; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-tuple2.rs b/src/test/run-pass/const-enum-tuple2.rs index 63f1f41d9ab5a..14da9438af00a 100644 --- a/src/test/run-pass/const-enum-tuple2.rs +++ b/src/test/run-pass/const-enum-tuple2.rs @@ -13,6 +13,6 @@ static C: (E, u16, u16) = (V0, 0x600D, 0xBAD); pub fn main() { let (_, n, _) = C; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-tuplestruct.rs b/src/test/run-pass/const-enum-tuplestruct.rs index b0d321abb09e7..885664f7ef03c 100644 --- a/src/test/run-pass/const-enum-tuplestruct.rs +++ b/src/test/run-pass/const-enum-tuplestruct.rs @@ -14,6 +14,6 @@ static C: S = S(V16(0xDEAD), 0x600D, 0xBAD); pub fn main() { let S(_, n, _) = C; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-tuplestruct2.rs b/src/test/run-pass/const-enum-tuplestruct2.rs index 7fa04af3f9a58..ad4befd92d15e 100644 --- a/src/test/run-pass/const-enum-tuplestruct2.rs +++ b/src/test/run-pass/const-enum-tuplestruct2.rs @@ -14,6 +14,6 @@ static C: S = S(V0, 0x600D, 0xBAD); pub fn main() { let S(_, n, _) = C; - fail_unless!(n != 0xBAD); - fail_unless!(n == 0x600D); + assert!(n != 0xBAD); + assert!(n == 0x600D); } diff --git a/src/test/run-pass/const-enum-vec-index.rs b/src/test/run-pass/const-enum-vec-index.rs index fd11fc422726f..01bab0778329f 100644 --- a/src/test/run-pass/const-enum-vec-index.rs +++ b/src/test/run-pass/const-enum-vec-index.rs @@ -19,7 +19,7 @@ pub fn main() { _ => fail!() } match C1 { - V1(n) => fail_unless!(n == 0xDEADBEE), + V1(n) => assert!(n == 0xDEADBEE), _ => fail!() } } diff --git a/src/test/run-pass/const-enum-vec-ptr.rs b/src/test/run-pass/const-enum-vec-ptr.rs index 8d152dca54c31..8615356965e35 100644 --- a/src/test/run-pass/const-enum-vec-ptr.rs +++ b/src/test/run-pass/const-enum-vec-ptr.rs @@ -13,7 +13,7 @@ static C: &'static [E] = &[V0, V1(0xDEADBEE), V0]; pub fn main() { match C[1] { - V1(n) => fail_unless!(n == 0xDEADBEE), + V1(n) => assert!(n == 0xDEADBEE), _ => fail!() } match C[2] { diff --git a/src/test/run-pass/const-enum-vector.rs b/src/test/run-pass/const-enum-vector.rs index 0e92694dde8ac..7ae2c5a2fee7c 100644 --- a/src/test/run-pass/const-enum-vector.rs +++ b/src/test/run-pass/const-enum-vector.rs @@ -13,7 +13,7 @@ static C: [E, ..3] = [V0, V1(0xDEADBEE), V0]; pub fn main() { match C[1] { - V1(n) => fail_unless!(n == 0xDEADBEE), + V1(n) => assert!(n == 0xDEADBEE), _ => fail!() } match C[2] { diff --git a/src/test/run-pass/const-extern-function.rs b/src/test/run-pass/const-extern-function.rs index 5e7ac4e4518ae..a9d036f121921 100644 --- a/src/test/run-pass/const-extern-function.rs +++ b/src/test/run-pass/const-extern-function.rs @@ -18,6 +18,6 @@ struct S { } pub fn main() { - fail_unless!(foopy == f); - fail_unless!(f == s.f); + assert!(foopy == f); + assert!(f == s.f); } diff --git a/src/test/run-pass/const-fields-and-indexing.rs b/src/test/run-pass/const-fields-and-indexing.rs index 658b39509bfbb..014ec19d56502 100644 --- a/src/test/run-pass/const-fields-and-indexing.rs +++ b/src/test/run-pass/const-fields-and-indexing.rs @@ -28,7 +28,7 @@ pub fn main() { io::println(fmt!("%?", p)); io::println(fmt!("%?", q)); io::println(fmt!("%?", t)); - fail_unless!(p == 3); - fail_unless!(q == 3); - fail_unless!(t == 20); + assert!(p == 3); + assert!(q == 3); + assert!(t == 20); } diff --git a/src/test/run-pass/const-fn-val.rs b/src/test/run-pass/const-fn-val.rs index f08fc3be0742a..544d671431260 100644 --- a/src/test/run-pass/const-fn-val.rs +++ b/src/test/run-pass/const-fn-val.rs @@ -17,5 +17,5 @@ struct Bar<'self> { f: &'self fn() -> int } static b : Bar<'static> = Bar { f: foo }; pub fn main() { - fail_unless!((b.f)() == 0xca7f000d); + assert!((b.f)() == 0xca7f000d); } diff --git a/src/test/run-pass/const-negative.rs b/src/test/run-pass/const-negative.rs index e2add6409f75d..e4905d5c5324d 100644 --- a/src/test/run-pass/const-negative.rs +++ b/src/test/run-pass/const-negative.rs @@ -13,5 +13,5 @@ static toplevel_mod: int = -1; pub fn main() { - fail_unless!(toplevel_mod == -1); + assert!(toplevel_mod == -1); } diff --git a/src/test/run-pass/const-nullary-univariant-enum.rs b/src/test/run-pass/const-nullary-univariant-enum.rs index 75fd2774095c1..0d0674aa962fc 100644 --- a/src/test/run-pass/const-nullary-univariant-enum.rs +++ b/src/test/run-pass/const-nullary-univariant-enum.rs @@ -15,8 +15,8 @@ enum Foo { static X: Foo = Bar; pub fn main() { - fail_unless!(((X as uint) == 0xDEADBEE)); - fail_unless!(((Y as uint) == 0xDEADBEE)); + assert!(((X as uint) == 0xDEADBEE)); + assert!(((Y as uint) == 0xDEADBEE)); } static Y: Foo = Bar; diff --git a/src/test/run-pass/const-rec-and-tup.rs b/src/test/run-pass/const-rec-and-tup.rs index 77d4521e70943..557fa427e4383 100644 --- a/src/test/run-pass/const-rec-and-tup.rs +++ b/src/test/run-pass/const-rec-and-tup.rs @@ -20,6 +20,6 @@ static y : AnotherPair = AnotherPair{ x: (0xf0f0f0f0_f0f0f0f0, pub fn main() { let (p, _) = y.x; - fail_unless!(p == - 1085102592571150096); + assert!(p == - 1085102592571150096); io::println(fmt!("0x%x", p as uint)); } diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs index a0d16a3ec3ab1..960faf131e8b0 100644 --- a/src/test/run-pass/const-region-ptrs-noncopy.rs +++ b/src/test/run-pass/const-region-ptrs-noncopy.rs @@ -14,5 +14,5 @@ static x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]); static y: &'static Pair<'static> = &Pair {a: 15, b: x}; pub fn main() { - fail_unless!(ptr::addr_of(x) == ptr::addr_of(y.b)); + assert!(ptr::addr_of(x) == ptr::addr_of(y.b)); } diff --git a/src/test/run-pass/const-region-ptrs.rs b/src/test/run-pass/const-region-ptrs.rs index 6c501ebf9389a..a2bedc85cdd4d 100644 --- a/src/test/run-pass/const-region-ptrs.rs +++ b/src/test/run-pass/const-region-ptrs.rs @@ -18,6 +18,6 @@ static y: &'static Pair<'static> = &Pair {a: 15, b: x}; pub fn main() { io::println(fmt!("x = %?", *x)); io::println(fmt!("y = {a: %?, b: %?}", y.a, *(y.b))); - fail_unless!(*x == 10); - fail_unless!(*(y.b) == 10); + assert!(*x == 10); + assert!(*(y.b) == 10); } diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index 4163748eaee01..2f98036a5b172 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -14,9 +14,9 @@ static b: *u8 = c as *u8; pub fn main() { let foo = &a as *u8; - fail_unless!(unsafe { str::raw::from_bytes(a) } == ~"hi\x00"); - fail_unless!(unsafe { str::raw::from_buf(foo) } == ~"hi"); - fail_unless!(unsafe { str::raw::from_buf(b) } == ~"hi"); - fail_unless!(unsafe { *b == a[0] }); - fail_unless!(unsafe { *(&c[0] as *u8) == a[0] }); + assert!(unsafe { str::raw::from_bytes(a) } == ~"hi\x00"); + assert!(unsafe { str::raw::from_buf(foo) } == ~"hi"); + assert!(unsafe { str::raw::from_buf(b) } == ~"hi"); + assert!(unsafe { *b == a[0] }); + assert!(unsafe { *(&c[0] as *u8) == a[0] }); } diff --git a/src/test/run-pass/const-struct.rs b/src/test/run-pass/const-struct.rs index a826f7bf564cd..f75b4321e9025 100644 --- a/src/test/run-pass/const-struct.rs +++ b/src/test/run-pass/const-struct.rs @@ -25,9 +25,9 @@ static y : foo = foo { b:2, c:3, a: 1 }; static z : &'static foo = &foo { a: 10, b: 22, c: 12 }; pub fn main() { - fail_unless!(x.b == 2); - fail_unless!(x == y); - fail_unless!(z.b == 22); + assert!(x.b == 2); + assert!(x == y); + assert!(z.b == 22); io::println(fmt!("0x%x", x.b as uint)); io::println(fmt!("0x%x", z.c as uint)); } diff --git a/src/test/run-pass/const-tuple-struct.rs b/src/test/run-pass/const-tuple-struct.rs index 857997b29d264..a68e12b7b107a 100644 --- a/src/test/run-pass/const-tuple-struct.rs +++ b/src/test/run-pass/const-tuple-struct.rs @@ -15,8 +15,8 @@ static X: Bar = Bar(1, 2); pub fn main() { match X { Bar(x, y) => { - fail_unless!(x == 1); - fail_unless!(y == 2); + assert!(x == 1); + assert!(y == 2); } } } diff --git a/src/test/run-pass/const-vecs-and-slices.rs b/src/test/run-pass/const-vecs-and-slices.rs index f99f2c17ca5df..517ced302dd8b 100644 --- a/src/test/run-pass/const-vecs-and-slices.rs +++ b/src/test/run-pass/const-vecs-and-slices.rs @@ -14,7 +14,7 @@ static y : &'static [int] = &[1,2,3,4]; pub fn main() { io::println(fmt!("%?", x[1])); io::println(fmt!("%?", y[1])); - fail_unless!(x[1] == 2); - fail_unless!(x[3] == 4); - fail_unless!(x[3] == y[3]); + assert!(x[1] == 2); + assert!(x[3] == 4); + assert!(x[3] == y[3]); } diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs index 5e79838c4b7a3..408c0e612f431 100644 --- a/src/test/run-pass/consts-in-patterns.rs +++ b/src/test/run-pass/consts-in-patterns.rs @@ -18,6 +18,6 @@ pub fn main() { BAR => 2, _ => 3 }; - fail_unless!(y == 2); + assert!(y == 2); } diff --git a/src/test/run-pass/crateresolve1.rs b/src/test/run-pass/crateresolve1.rs index 819e8d4901a09..1ddb955cee7bc 100644 --- a/src/test/run-pass/crateresolve1.rs +++ b/src/test/run-pass/crateresolve1.rs @@ -16,5 +16,5 @@ extern mod crateresolve1(vers = "0.2"); pub fn main() { - fail_unless!(crateresolve1::f() == 20); + assert!(crateresolve1::f() == 20); } diff --git a/src/test/run-pass/crateresolve2.rs b/src/test/run-pass/crateresolve2.rs index 9312c9c2a512c..1ffbf8320e51d 100644 --- a/src/test/run-pass/crateresolve2.rs +++ b/src/test/run-pass/crateresolve2.rs @@ -15,17 +15,17 @@ mod a { extern mod crateresolve2(vers = "0.1"); - pub fn f() { fail_unless!(crateresolve2::f() == 10); } + pub fn f() { assert!(crateresolve2::f() == 10); } } mod b { extern mod crateresolve2(vers = "0.2"); - pub fn f() { fail_unless!(crateresolve2::f() == 20); } + pub fn f() { assert!(crateresolve2::f() == 20); } } mod c { extern mod crateresolve2(vers = "0.3"); - pub fn f() { fail_unless!(crateresolve2::f() == 30); } + pub fn f() { assert!(crateresolve2::f() == 30); } } pub fn main() { diff --git a/src/test/run-pass/crateresolve3.rs b/src/test/run-pass/crateresolve3.rs index 51dde6cd9c372..519e67acdd6a3 100644 --- a/src/test/run-pass/crateresolve3.rs +++ b/src/test/run-pass/crateresolve3.rs @@ -17,12 +17,12 @@ mod a { extern mod crateresolve3(vers = "0.1"); - pub fn f() { fail_unless!(crateresolve3::f() == 10); } + pub fn f() { assert!(crateresolve3::f() == 10); } } mod b { extern mod crateresolve3(vers = "0.2"); - pub fn f() { fail_unless!(crateresolve3::g() == 20); } + pub fn f() { assert!(crateresolve3::g() == 20); } } pub fn main() { diff --git a/src/test/run-pass/crateresolve4.rs b/src/test/run-pass/crateresolve4.rs index ba35170b147d0..ead2a2131b0cc 100644 --- a/src/test/run-pass/crateresolve4.rs +++ b/src/test/run-pass/crateresolve4.rs @@ -16,12 +16,12 @@ pub mod a { extern mod crateresolve4b(vers = "0.1"); - pub fn f() { fail_unless!(crateresolve4b::f() == 20); } + pub fn f() { assert!(crateresolve4b::f() == 20); } } pub mod b { extern mod crateresolve4b(vers = "0.2"); - pub fn f() { fail_unless!(crateresolve4b::g() == 10); } + pub fn f() { assert!(crateresolve4b::g() == 10); } } pub fn main() { diff --git a/src/test/run-pass/crateresolve5.rs b/src/test/run-pass/crateresolve5.rs index b467da6802e18..688853dd9aefc 100644 --- a/src/test/run-pass/crateresolve5.rs +++ b/src/test/run-pass/crateresolve5.rs @@ -17,8 +17,8 @@ extern mod cr5_2 (name = "crateresolve5", vers = "0.2"); pub fn main() { // Structural types can be used between two versions of the same crate - fail_unless!(cr5_1::struct_nameval().name == cr5_2::struct_nameval().name); - fail_unless!(cr5_1::struct_nameval().val == cr5_2::struct_nameval().val); + assert!(cr5_1::struct_nameval().name == cr5_2::struct_nameval().name); + assert!(cr5_1::struct_nameval().val == cr5_2::struct_nameval().val); // Make sure these are actually two different crates - fail_unless!(cr5_1::f() == 10 && cr5_2::f() == 20); + assert!(cr5_1::f() == 10 && cr5_2::f() == 20); } diff --git a/src/test/run-pass/crateresolve6.rs b/src/test/run-pass/crateresolve6.rs index f273b12eae4ef..0263af5510578 100644 --- a/src/test/run-pass/crateresolve6.rs +++ b/src/test/run-pass/crateresolve6.rs @@ -18,6 +18,6 @@ extern mod cr6_1 (name = "crateresolve_calories", vers = "0.1", calories="100"); extern mod cr6_2 (name = "crateresolve_calories", vers = "0.1", calories="200"); pub fn main() { - fail_unless!(cr6_1::f() == 100); - fail_unless!(cr6_2::f() == 200); + assert!(cr6_1::f() == 100); + assert!(cr6_2::f() == 200); } diff --git a/src/test/run-pass/crateresolve7.rs b/src/test/run-pass/crateresolve7.rs index 49d8f27dbd6d5..b54b5a0983fbd 100644 --- a/src/test/run-pass/crateresolve7.rs +++ b/src/test/run-pass/crateresolve7.rs @@ -16,6 +16,6 @@ extern mod crateresolve7x; pub fn main() { - fail_unless!(crateresolve7x::a::f() == 100); - fail_unless!(crateresolve7x::b::f() == 200); + assert!(crateresolve7x::a::f() == 100); + assert!(crateresolve7x::b::f() == 200); } diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs index fceae82e68e75..ebb033d188e46 100644 --- a/src/test/run-pass/deep.rs +++ b/src/test/run-pass/deep.rs @@ -16,4 +16,4 @@ fn f(x: int) -> int { if x == 1 { return 1; } else { let y: int = 1 + f(x - 1); return y; } } -pub fn main() { fail_unless!((f(5000) == 5000)); } +pub fn main() { assert!((f(5000) == 5000)); } diff --git a/src/test/run-pass/deriving-via-extension-c-enum.rs b/src/test/run-pass/deriving-via-extension-c-enum.rs index 47d088cfc6f26..67893ae9c1eec 100644 --- a/src/test/run-pass/deriving-via-extension-c-enum.rs +++ b/src/test/run-pass/deriving-via-extension-c-enum.rs @@ -18,9 +18,9 @@ enum Foo { pub fn main() { let a = Bar; let b = Bar; - fail_unless!(a == b); - fail_unless!(!(a != b)); - fail_unless!(a.eq(&b)); - fail_unless!(!a.ne(&b)); + assert!(a == b); + assert!(!(a != b)); + assert!(a.eq(&b)); + assert!(!a.ne(&b)); } diff --git a/src/test/run-pass/deriving-via-extension-enum.rs b/src/test/run-pass/deriving-via-extension-enum.rs index 32f693abf2555..7481bae508b68 100644 --- a/src/test/run-pass/deriving-via-extension-enum.rs +++ b/src/test/run-pass/deriving-via-extension-enum.rs @@ -17,9 +17,9 @@ enum Foo { pub fn main() { let a = Bar(1, 2); let b = Bar(1, 2); - fail_unless!(a == b); - fail_unless!(!(a != b)); - fail_unless!(a.eq(&b)); - fail_unless!(!a.ne(&b)); + assert!(a == b); + assert!(!(a != b)); + assert!(a.eq(&b)); + assert!(!a.ne(&b)); } diff --git a/src/test/run-pass/deriving-via-extension-struct-empty.rs b/src/test/run-pass/deriving-via-extension-struct-empty.rs index 09ee83870a0e2..00b0c14369e04 100644 --- a/src/test/run-pass/deriving-via-extension-struct-empty.rs +++ b/src/test/run-pass/deriving-via-extension-struct-empty.rs @@ -12,6 +12,6 @@ struct Foo; pub fn main() { - fail_unless!(Foo == Foo); - fail_unless!(!(Foo != Foo)); + assert!(Foo == Foo); + assert!(!(Foo != Foo)); } \ No newline at end of file diff --git a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs index c349600eb9998..712767efacfa0 100644 --- a/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs +++ b/src/test/run-pass/deriving-via-extension-struct-like-enum-variant.rs @@ -6,7 +6,7 @@ enum S { pub fn main() { let x = X { x: 1, y: 2 }; - fail_unless!(x == x); - fail_unless!(!(x != x)); + assert!(x == x); + assert!(!(x != x)); } diff --git a/src/test/run-pass/deriving-via-extension-struct-tuple.rs b/src/test/run-pass/deriving-via-extension-struct-tuple.rs index 35c20c13e9371..906d69dbf5375 100644 --- a/src/test/run-pass/deriving-via-extension-struct-tuple.rs +++ b/src/test/run-pass/deriving-via-extension-struct-tuple.rs @@ -16,11 +16,11 @@ pub fn main() { let a2 = Foo(5, 6, ~"abc"); let b = Foo(5, 7, ~"def"); - fail_unless!(a1 == a1); - fail_unless!(a1 == a2); - fail_unless!(!(a1 == b)); + assert!(a1 == a1); + assert!(a1 == a2); + assert!(!(a1 == b)); - fail_unless!(a1 != b); - fail_unless!(!(a1 != a1)); - fail_unless!(!(a1 != a2)); + assert!(a1 != b); + assert!(!(a1 != a1)); + assert!(!(a1 != a2)); } diff --git a/src/test/run-pass/deriving-via-extension-struct.rs b/src/test/run-pass/deriving-via-extension-struct.rs index f5cc85c638250..1e004d1a8c00a 100644 --- a/src/test/run-pass/deriving-via-extension-struct.rs +++ b/src/test/run-pass/deriving-via-extension-struct.rs @@ -18,9 +18,9 @@ struct Foo { pub fn main() { let a = Foo { x: 1, y: 2, z: 3 }; let b = Foo { x: 1, y: 2, z: 3 }; - fail_unless!(a == b); - fail_unless!(!(a != b)); - fail_unless!(a.eq(&b)); - fail_unless!(!a.ne(&b)); + assert!(a == b); + assert!(!(a != b)); + assert!(a.eq(&b)); + assert!(!a.ne(&b)); } diff --git a/src/test/run-pass/deriving-via-extension-type-params.rs b/src/test/run-pass/deriving-via-extension-type-params.rs index 298e30f7ec1e7..f310643f94393 100644 --- a/src/test/run-pass/deriving-via-extension-type-params.rs +++ b/src/test/run-pass/deriving-via-extension-type-params.rs @@ -21,9 +21,9 @@ struct Foo { pub fn main() { let a = Foo { x: 1, y: 2.0, z: 3 }; let b = Foo { x: 1, y: 2.0, z: 3 }; - fail_unless!(a == b); - fail_unless!(!(a != b)); - fail_unless!(a.eq(&b)); - fail_unless!(!a.ne(&b)); + assert!(a == b); + assert!(!(a != b)); + assert!(a.eq(&b)); + assert!(!a.ne(&b)); } diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs index b7ade51e34491..bf1d6e3c06006 100644 --- a/src/test/run-pass/div-mod.rs +++ b/src/test/run-pass/div-mod.rs @@ -15,14 +15,14 @@ pub fn main() { let x: int = 15; let y: int = 5; - fail_unless!((x / 5 == 3)); - fail_unless!((x / 4 == 3)); - fail_unless!((x / 3 == 5)); - fail_unless!((x / y == 3)); - fail_unless!((15 / y == 3)); - fail_unless!((x % 5 == 0)); - fail_unless!((x % 4 == 3)); - fail_unless!((x % 3 == 0)); - fail_unless!((x % y == 0)); - fail_unless!((15 % y == 0)); + assert!((x / 5 == 3)); + assert!((x / 4 == 3)); + assert!((x / 3 == 5)); + assert!((x / y == 3)); + assert!((15 / y == 3)); + assert!((x % 5 == 0)); + assert!((x % 4 == 3)); + assert!((x % 3 == 0)); + assert!((x % y == 0)); + assert!((15 % y == 0)); } diff --git a/src/test/run-pass/do-stack.rs b/src/test/run-pass/do-stack.rs index a37c9ec18120b..0444b269cb34f 100644 --- a/src/test/run-pass/do-stack.rs +++ b/src/test/run-pass/do-stack.rs @@ -11,5 +11,5 @@ fn f(f: &fn(int)) { f(10) } pub fn main() { - do f() |i| { fail_unless!(i == 10) } + do f() |i| { assert!(i == 10) } } diff --git a/src/test/run-pass/do1.rs b/src/test/run-pass/do1.rs index d993bbd2d3c0c..735621a19fe75 100644 --- a/src/test/run-pass/do1.rs +++ b/src/test/run-pass/do1.rs @@ -11,5 +11,5 @@ fn f(f: @fn(int)) { f(10) } pub fn main() { - do f() |i| { fail_unless!(i == 10) } + do f() |i| { assert!(i == 10) } } diff --git a/src/test/run-pass/do2.rs b/src/test/run-pass/do2.rs index 8995faaf8baa3..ee1321e9d0048 100644 --- a/src/test/run-pass/do2.rs +++ b/src/test/run-pass/do2.rs @@ -11,5 +11,5 @@ fn f(f: @fn(int) -> int) -> int { f(10) } pub fn main() { - fail_unless!(do f() |i| { i } == 10); + assert!(do f() |i| { i } == 10); } diff --git a/src/test/run-pass/do3.rs b/src/test/run-pass/do3.rs index dee9bd77a91da..7cbf49a34862d 100644 --- a/src/test/run-pass/do3.rs +++ b/src/test/run-pass/do3.rs @@ -11,5 +11,5 @@ fn f(f: @fn(int) -> int) -> int { f(10) } pub fn main() { - fail_unless!(do f |i| { i } == 10); + assert!(do f |i| { i } == 10); } diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs index 15e68bccba87e..476d3f42d6ee3 100644 --- a/src/test/run-pass/else-if.rs +++ b/src/test/run-pass/else-if.rs @@ -12,19 +12,19 @@ pub fn main() { if 1 == 2 { - fail_unless!((false)); + assert!((false)); } else if 2 == 3 { - fail_unless!((false)); - } else if 3 == 4 { fail_unless!((false)); } else { fail_unless!((true)); } - if 1 == 2 { fail_unless!((false)); } else if 2 == 2 { fail_unless!((true)); } + assert!((false)); + } else if 3 == 4 { assert!((false)); } else { assert!((true)); } + if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); } if 1 == 2 { - fail_unless!((false)); + assert!((false)); } else if 2 == 2 { if 1 == 1 { - fail_unless!((true)); - } else { if 2 == 1 { fail_unless!((false)); } else { fail_unless!((false)); } } + assert!((true)); + } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } } } if 1 == 2 { - fail_unless!((false)); - } else { if 1 == 2 { fail_unless!((false)); } else { fail_unless!((true)); } } + assert!((false)); + } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } } } diff --git a/src/test/run-pass/empty-tag.rs b/src/test/run-pass/empty-tag.rs index 0589ffc79e054..f1b89f2bb1d3b 100644 --- a/src/test/run-pass/empty-tag.rs +++ b/src/test/run-pass/empty-tag.rs @@ -18,7 +18,7 @@ impl cmp::Eq for chan { } fn wrapper3(i: chan) { - fail_unless!(i == chan_t); + assert!(i == chan_t); } pub fn main() { diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs index 5da6436702313..e8de422d5ce60 100644 --- a/src/test/run-pass/enum-alignment.rs +++ b/src/test/run-pass/enum-alignment.rs @@ -21,6 +21,6 @@ pub fn main() { let x = Some(0u64); match x { None => fail!(), - Some(ref y) => fail_unless!(is_aligned(y)) + Some(ref y) => assert!(is_aligned(y)) } } diff --git a/src/test/run-pass/enum-disr-val-pretty.rs b/src/test/run-pass/enum-disr-val-pretty.rs index aca9f72d26564..39a807789ecec 100644 --- a/src/test/run-pass/enum-disr-val-pretty.rs +++ b/src/test/run-pass/enum-disr-val-pretty.rs @@ -20,7 +20,7 @@ pub fn main() { } fn test_color(color: color, val: int, name: ~str) { - fail_unless!(color as int == val); - fail_unless!(color as float == val as float); + assert!(color as int == val); + assert!(color as float == val as float); } diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs index 869ea6007c2a1..27a1b9514139e 100644 --- a/src/test/run-pass/estr-slice.rs +++ b/src/test/run-pass/estr-slice.rs @@ -17,12 +17,12 @@ pub fn main() { debug!(x); debug!(y); - fail_unless!(x[0] == 'h' as u8); - fail_unless!(x[4] == 'o' as u8); + assert!(x[0] == 'h' as u8); + assert!(x[4] == 'o' as u8); let z : &str = &"thing"; - fail_unless!(v == x); - fail_unless!(x != z); + assert!(v == x); + assert!(x != z); let a = &"aaaa"; let b = &"bbbb"; @@ -32,27 +32,27 @@ pub fn main() { debug!(a); - fail_unless!(a < b); - fail_unless!(a <= b); - fail_unless!(a != b); - fail_unless!(b >= a); - fail_unless!(b > a); + assert!(a < b); + assert!(a <= b); + assert!(a != b); + assert!(b >= a); + assert!(b > a); debug!(b); - fail_unless!(a < c); - fail_unless!(a <= c); - fail_unless!(a != c); - fail_unless!(c >= a); - fail_unless!(c > a); + assert!(a < c); + assert!(a <= c); + assert!(a != c); + assert!(c >= a); + assert!(c > a); debug!(c); - fail_unless!(c < cc); - fail_unless!(c <= cc); - fail_unless!(c != cc); - fail_unless!(cc >= c); - fail_unless!(cc > c); + assert!(c < cc); + assert!(c <= cc); + assert!(c != cc); + assert!(cc >= c); + assert!(cc > c); debug!(cc); } diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs index 4720f29f89186..5e23fd0f75166 100644 --- a/src/test/run-pass/estr-uniq.rs +++ b/src/test/run-pass/estr-uniq.rs @@ -13,6 +13,6 @@ pub fn main() { let _y : ~str = ~"there"; let mut z = ~"thing"; z = x; - fail_unless!(z[0] == ('h' as u8)); - fail_unless!(z[4] == ('o' as u8)); + assert!(z[0] == ('h' as u8)); + assert!(z[4] == ('o' as u8)); } diff --git a/src/test/run-pass/evec-internal-boxes.rs b/src/test/run-pass/evec-internal-boxes.rs index ec5c5f01e1597..7b51b80313680 100644 --- a/src/test/run-pass/evec-internal-boxes.rs +++ b/src/test/run-pass/evec-internal-boxes.rs @@ -13,6 +13,6 @@ pub fn main() { let _y : [@int, ..5] = [@1,@2,@3,@4,@5]; let mut z = [@1,@2,@3,@4,@5]; z = x; - fail_unless!(*z[0] == 1); - fail_unless!(*z[4] == 5); + assert!(*z[0] == 1); + assert!(*z[4] == 5); } diff --git a/src/test/run-pass/evec-internal.rs b/src/test/run-pass/evec-internal.rs index 1c23d5ac810a7..39a4397f84e73 100644 --- a/src/test/run-pass/evec-internal.rs +++ b/src/test/run-pass/evec-internal.rs @@ -18,8 +18,8 @@ pub fn main() { let _y : [int, ..5] = [1,2,3,4,5]; let mut z = [1,2,3,4,5]; z = x; - fail_unless!(z[0] == 1); - fail_unless!(z[4] == 5); + assert!(z[0] == 1); + assert!(z[4] == 5); let a : [int, ..5] = [1,1,1,1,1]; let b : [int, ..5] = [2,2,2,2,2]; @@ -27,25 +27,25 @@ pub fn main() { log(debug, a); - fail_unless!(a < b); - fail_unless!(a <= b); - fail_unless!(a != b); - fail_unless!(b >= a); - fail_unless!(b > a); + assert!(a < b); + assert!(a <= b); + assert!(a != b); + assert!(b >= a); + assert!(b > a); log(debug, b); - fail_unless!(b < c); - fail_unless!(b <= c); - fail_unless!(b != c); - fail_unless!(c >= b); - fail_unless!(c > b); - - fail_unless!(a < c); - fail_unless!(a <= c); - fail_unless!(a != c); - fail_unless!(c >= a); - fail_unless!(c > a); + assert!(b < c); + assert!(b <= c); + assert!(b != c); + assert!(c >= b); + assert!(c > b); + + assert!(a < c); + assert!(a <= c); + assert!(a != c); + assert!(c >= a); + assert!(c > a); log(debug, c); diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs index 0d14670a6db11..28bac56b05e76 100644 --- a/src/test/run-pass/evec-slice.rs +++ b/src/test/run-pass/evec-slice.rs @@ -12,8 +12,8 @@ pub fn main() { let x : &[int] = &[1,2,3,4,5]; let mut z = &[1,2,3,4,5]; z = x; - fail_unless!(z[0] == 1); - fail_unless!(z[4] == 5); + assert!(z[0] == 1); + assert!(z[4] == 5); let a : &[int] = &[1,1,1,1,1]; let b : &[int] = &[2,2,2,2,2]; @@ -22,33 +22,33 @@ pub fn main() { debug!(a); - fail_unless!(a < b); - fail_unless!(a <= b); - fail_unless!(a != b); - fail_unless!(b >= a); - fail_unless!(b > a); + assert!(a < b); + assert!(a <= b); + assert!(a != b); + assert!(b >= a); + assert!(b > a); debug!(b); - fail_unless!(b < c); - fail_unless!(b <= c); - fail_unless!(b != c); - fail_unless!(c >= b); - fail_unless!(c > b); + assert!(b < c); + assert!(b <= c); + assert!(b != c); + assert!(c >= b); + assert!(c > b); - fail_unless!(a < c); - fail_unless!(a <= c); - fail_unless!(a != c); - fail_unless!(c >= a); - fail_unless!(c > a); + assert!(a < c); + assert!(a <= c); + assert!(a != c); + assert!(c >= a); + assert!(c > a); debug!(c); - fail_unless!(a < cc); - fail_unless!(a <= cc); - fail_unless!(a != cc); - fail_unless!(cc >= a); - fail_unless!(cc > a); + assert!(a < cc); + assert!(a <= cc); + assert!(a != cc); + assert!(cc >= a); + assert!(cc > a); debug!(cc); } diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index 2478eed2f0cf7..486186e9fe098 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -12,5 +12,5 @@ // exec-env:TEST_EXEC_ENV=22 pub fn main() { - fail_unless!(os::getenv(~"TEST_EXEC_ENV") == Some(~"22")); + assert!(os::getenv(~"TEST_EXEC_ENV") == Some(~"22")); } diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs index e22e739f570ff..fdf733d0314bc 100644 --- a/src/test/run-pass/explicit-self-generic.rs +++ b/src/test/run-pass/explicit-self-generic.rs @@ -38,6 +38,6 @@ pub impl LinearMap { pub fn main() { let mut m = ~linear_map::<(),()>(); - fail_unless!(m.len() == 0); + assert!(m.len() == 0); } diff --git a/src/test/run-pass/explicit-self-objects-box.rs b/src/test/run-pass/explicit-self-objects-box.rs index 6c981a93d7ceb..105aad03083d7 100644 --- a/src/test/run-pass/explicit-self-objects-box.rs +++ b/src/test/run-pass/explicit-self-objects-box.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(@self) { - fail_unless!(self.x == 3); + assert!(self.x == 3); } } diff --git a/src/test/run-pass/explicit-self-objects-simple.rs b/src/test/run-pass/explicit-self-objects-simple.rs index 1fa054a9060c9..de2926b0e7efc 100644 --- a/src/test/run-pass/explicit-self-objects-simple.rs +++ b/src/test/run-pass/explicit-self-objects-simple.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(&self) { - fail_unless!(self.x == 3); + assert!(self.x == 3); } } diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs index 2361df4f45751..e99a6bbedc06c 100644 --- a/src/test/run-pass/explicit-self-objects-uniq.rs +++ b/src/test/run-pass/explicit-self-objects-uniq.rs @@ -18,7 +18,7 @@ struct S { impl Foo for S { fn f(~self) { - fail_unless!(self.x == 3); + assert!(self.x == 3); } } diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index c41fa52bf15f4..c5b5016572caa 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -68,13 +68,13 @@ impl Nus for thing { fn f(&self) {} } pub fn main() { let x = @thing(A {a: @10}); - fail_unless!(x.foo() == 10); - fail_unless!(x.quux() == 10); + assert!(x.foo() == 10); + assert!(x.quux() == 10); let y = ~thing(A {a: @10}); - fail_unless!((copy y).bar() == 10); - fail_unless!(y.quux() == 10); + assert!((copy y).bar() == 10); + assert!(y.quux() == 10); let z = thing(A {a: @11}); - fail_unless!(z.spam() == 11); + assert!(z.spam() == 11); } diff --git a/src/test/run-pass/export-unexported-dep.rs b/src/test/run-pass/export-unexported-dep.rs index 4634cc4ef1101..ba2a7c6104aba 100644 --- a/src/test/run-pass/export-unexported-dep.rs +++ b/src/test/run-pass/export-unexported-dep.rs @@ -24,7 +24,7 @@ mod foo { pub fn f() -> t { return t1; } - pub fn g(v: t) { fail_unless!((v == t1)); } + pub fn g(v: t) { assert!((v == t1)); } } pub fn main() { foo::g(foo::f()); } diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs index a5ad80a49e75e..5439d13fed810 100644 --- a/src/test/run-pass/expr-alt-box.rs +++ b/src/test/run-pass/expr-alt-box.rs @@ -16,13 +16,13 @@ // Tests for match as expressions resulting in boxed types fn test_box() { let res = match true { true => { @100 } _ => fail!(~"wat") }; - fail_unless!((*res == 100)); + assert!((*res == 100)); } fn test_str() { let res = match true { true => { ~"happy" }, _ => fail!(~"not happy at all") }; - fail_unless!((res == ~"happy")); + assert!((res == ~"happy")); } pub fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/expr-alt-fail.rs b/src/test/run-pass/expr-alt-fail.rs index a22afab485c69..4391856230fe9 100644 --- a/src/test/run-pass/expr-alt-fail.rs +++ b/src/test/run-pass/expr-alt-fail.rs @@ -10,12 +10,12 @@ fn test_simple() { let r = match true { true => { true } false => { fail!() } }; - fail_unless!((r == true)); + assert!((r == true)); } fn test_box() { let r = match true { true => { ~[10] } false => { fail!() } }; - fail_unless!((r[0] == 10)); + assert!((r[0] == 10)); } pub fn main() { test_simple(); test_box(); } diff --git a/src/test/run-pass/expr-alt-generic-box1.rs b/src/test/run-pass/expr-alt-generic-box1.rs index 5d9e317be388b..4ea2d0fba9b2f 100644 --- a/src/test/run-pass/expr-alt-generic-box1.rs +++ b/src/test/run-pass/expr-alt-generic-box1.rs @@ -16,7 +16,7 @@ type compare = @fn(@T, @T) -> bool; fn test_generic(expected: @T, eq: compare) { let actual: @T = match true { true => { expected }, _ => fail!() }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_box() { diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs index 15bfd75905920..02227bbc700b3 100644 --- a/src/test/run-pass/expr-alt-generic-box2.rs +++ b/src/test/run-pass/expr-alt-generic-box2.rs @@ -15,7 +15,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, eq: compare) { let actual: T = match true { true => { expected }, _ => fail!(~"wat") }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_vec() { diff --git a/src/test/run-pass/expr-alt-generic-unique1.rs b/src/test/run-pass/expr-alt-generic-unique1.rs index 74a88bb5c8769..037cda8549991 100644 --- a/src/test/run-pass/expr-alt-generic-unique1.rs +++ b/src/test/run-pass/expr-alt-generic-unique1.rs @@ -18,7 +18,7 @@ fn test_generic(expected: ~T, eq: compare) { true => { expected.clone() }, _ => fail!(~"wat") }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_box() { diff --git a/src/test/run-pass/expr-alt-generic-unique2.rs b/src/test/run-pass/expr-alt-generic-unique2.rs index c9efe753f5757..2d470cd6fcc21 100644 --- a/src/test/run-pass/expr-alt-generic-unique2.rs +++ b/src/test/run-pass/expr-alt-generic-unique2.rs @@ -18,7 +18,7 @@ fn test_generic(expected: T, eq: compare) { true => expected.clone(), _ => fail!(~"wat") }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_vec() { diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs index 1c7f907933ef5..0fcca32cde06a 100644 --- a/src/test/run-pass/expr-alt-generic.rs +++ b/src/test/run-pass/expr-alt-generic.rs @@ -15,7 +15,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, eq: compare) { let actual: T = match true { true => { expected }, _ => fail!(~"wat") }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_bool() { diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs index 03358f2511bb6..a8cacca4fe812 100644 --- a/src/test/run-pass/expr-alt-struct.rs +++ b/src/test/run-pass/expr-alt-struct.rs @@ -18,7 +18,7 @@ struct R { i: int } fn test_rec() { let rs = match true { true => R {i: 100}, _ => fail!() }; - fail_unless!((rs.i == 100)); + assert!((rs.i == 100)); } enum mood { happy, sad, } @@ -32,7 +32,7 @@ impl cmp::Eq for mood { fn test_tag() { let rs = match true { true => { happy } false => { sad } }; - fail_unless!((rs == happy)); + assert!((rs == happy)); } pub fn main() { test_rec(); test_tag(); } diff --git a/src/test/run-pass/expr-alt-unique.rs b/src/test/run-pass/expr-alt-unique.rs index 3fa9e84d4b314..dd20840db575e 100644 --- a/src/test/run-pass/expr-alt-unique.rs +++ b/src/test/run-pass/expr-alt-unique.rs @@ -16,7 +16,7 @@ // Tests for match as expressions resulting in boxed types fn test_box() { let res = match true { true => { ~100 }, _ => fail!() }; - fail_unless!((*res == 100)); + assert!((*res == 100)); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/expr-alt.rs b/src/test/run-pass/expr-alt.rs index de18290b7af7f..a6324b98ebcaa 100644 --- a/src/test/run-pass/expr-alt.rs +++ b/src/test/run-pass/expr-alt.rs @@ -16,14 +16,14 @@ // Tests for using match as an expression fn test_basic() { let mut rs: bool = match true { true => { true } false => { false } }; - fail_unless!((rs)); + assert!((rs)); rs = match false { true => { false } false => { true } }; - fail_unless!((rs)); + assert!((rs)); } fn test_inferrence() { let mut rs = match true { true => { true } false => { false } }; - fail_unless!((rs)); + assert!((rs)); } fn test_alt_as_alt_head() { @@ -34,7 +34,7 @@ fn test_alt_as_alt_head() { true => { false } false => { true } }; - fail_unless!((rs)); + assert!((rs)); } fn test_alt_as_block_result() { @@ -43,7 +43,7 @@ fn test_alt_as_block_result() { true => { false } false => { match true { true => { true } false => { false } } } }; - fail_unless!((rs)); + assert!((rs)); } pub fn main() { diff --git a/src/test/run-pass/expr-block-box.rs b/src/test/run-pass/expr-block-box.rs index a3e55b739afd0..8385c95d999f7 100644 --- a/src/test/run-pass/expr-block-box.rs +++ b/src/test/run-pass/expr-block-box.rs @@ -12,4 +12,4 @@ // -*- rust -*- -pub fn main() { let x = { @100 }; fail_unless!((*x == 100)); } +pub fn main() { let x = { @100 }; assert!((*x == 100)); } diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs index 9967281612b2c..a44afac80f44d 100644 --- a/src/test/run-pass/expr-block-fn.rs +++ b/src/test/run-pass/expr-block-fn.rs @@ -14,7 +14,7 @@ fn test_fn() { type t = @fn() -> int; fn ten() -> int { return 10; } let rs: t = { ten }; - //fail_unless!((rs() == 10)); + //assert!((rs() == 10)); } pub fn main() { test_fn(); } diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs index 6aca1b994d940..5cd8d649e99a2 100644 --- a/src/test/run-pass/expr-block-generic-box1.rs +++ b/src/test/run-pass/expr-block-generic-box1.rs @@ -16,7 +16,7 @@ type compare = @fn(@T, @T) -> bool; fn test_generic(expected: @T, eq: compare) { let actual: @T = { expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_box() { diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs index 9f2018a12e9ef..2fa9a9c768ba4 100644 --- a/src/test/run-pass/expr-block-generic-box2.rs +++ b/src/test/run-pass/expr-block-generic-box2.rs @@ -16,7 +16,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_vec() { diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs index a9fe128661dc7..d00e9b7a78db2 100644 --- a/src/test/run-pass/expr-block-generic-unique1.rs +++ b/src/test/run-pass/expr-block-generic-unique1.rs @@ -15,7 +15,7 @@ type compare = @fn(~T, ~T) -> bool; fn test_generic(expected: ~T, eq: compare) { let actual: ~T = { expected.clone() }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_box() { diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs index 3d5953494aeae..e4a5d49736e99 100644 --- a/src/test/run-pass/expr-block-generic-unique2.rs +++ b/src/test/run-pass/expr-block-generic-unique2.rs @@ -16,7 +16,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_vec() { diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs index c582a30fa25a2..e507700e6b28d 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -17,7 +17,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, eq: compare) { let actual: T = { expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_bool() { diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs index 474f5a1bf5118..0a75d9074c6c2 100644 --- a/src/test/run-pass/expr-block-slot.rs +++ b/src/test/run-pass/expr-block-slot.rs @@ -15,7 +15,7 @@ struct V { v: int } pub fn main() { let a = { let b = A {a: 3}; b }; - fail_unless!((a.a == 3)); + assert!((a.a == 3)); let c = { let d = V {v: 3}; d }; - fail_unless!((c.v == 3)); + assert!((c.v == 3)); } diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs index 8b9e77071ea93..72151f7abe668 100644 --- a/src/test/run-pass/expr-block-unique.rs +++ b/src/test/run-pass/expr-block-unique.rs @@ -12,4 +12,4 @@ // -*- rust -*- -pub fn main() { let x = { ~100 }; fail_unless!((*x == 100)); } +pub fn main() { let x = { ~100 }; assert!((*x == 100)); } diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs index faa36ffa09a84..ee5d41fdd324b 100644 --- a/src/test/run-pass/expr-block.rs +++ b/src/test/run-pass/expr-block.rs @@ -14,15 +14,15 @@ // -*- rust -*- // Tests for standalone blocks as expressions -fn test_basic() { let rs: bool = { true }; fail_unless!((rs)); } +fn test_basic() { let rs: bool = { true }; assert!((rs)); } struct RS { v1: int, v2: int } -fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; fail_unless!((rs.v2 == 20)); } +fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); } fn test_filled_with_stuff() { let rs = { let mut a = 0; while a < 10 { a += 1; } a }; - fail_unless!((rs == 10)); + assert!((rs == 10)); } pub fn main() { test_basic(); test_rec(); test_filled_with_stuff(); } diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs index 287f935eef829..7dc0f8246bf97 100644 --- a/src/test/run-pass/expr-copy.rs +++ b/src/test/run-pass/expr-copy.rs @@ -19,9 +19,9 @@ struct A { a: int } pub fn main() { let mut x = A {a: 10}; f(&mut x); - fail_unless!(x.a == 100); + assert!(x.a == 100); x.a = 20; let mut y = copy x; f(&mut y); - fail_unless!(x.a == 20); + assert!(x.a == 20); } diff --git a/src/test/run-pass/expr-elseif-ref.rs b/src/test/run-pass/expr-elseif-ref.rs index 2bacf914a70a0..831ddfde445ad 100644 --- a/src/test/run-pass/expr-elseif-ref.rs +++ b/src/test/run-pass/expr-elseif-ref.rs @@ -13,5 +13,5 @@ pub fn main() { let y: @uint = @10u; let x = if false { y } else if true { y } else { y }; - fail_unless!((*y == 10u)); + assert!((*y == 10u)); } diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs index 5695ea24d830e..b7ea721464e6e 100644 --- a/src/test/run-pass/expr-fn.rs +++ b/src/test/run-pass/expr-fn.rs @@ -10,32 +10,32 @@ fn test_int() { fn f() -> int { 10 } - fail_unless!((f() == 10)); + assert!((f() == 10)); } fn test_vec() { fn f() -> ~[int] { ~[10, 11] } - fail_unless!((f()[1] == 11)); + assert!((f()[1] == 11)); } fn test_generic() { fn f(t: T) -> T { t } - fail_unless!((f(10) == 10)); + assert!((f(10) == 10)); } fn test_alt() { fn f() -> int { match true { false => { 10 } true => { 20 } } } - fail_unless!((f() == 20)); + assert!((f() == 20)); } fn test_if() { fn f() -> int { if true { 10 } else { 20 } } - fail_unless!((f() == 10)); + assert!((f() == 10)); } fn test_block() { fn f() -> int { { 10 } } - fail_unless!((f() == 10)); + assert!((f() == 10)); } fn test_ret() { @@ -43,14 +43,14 @@ fn test_ret() { return 10 // no semi } - fail_unless!((f() == 10)); + assert!((f() == 10)); } // From issue #372 fn test_372() { fn f() -> int { let x = { 3 }; x } - fail_unless!((f() == 3)); + assert!((f() == 3)); } fn test_nil() { () } diff --git a/src/test/run-pass/expr-if-box.rs b/src/test/run-pass/expr-if-box.rs index 4a38f9986b87e..004137d065c34 100644 --- a/src/test/run-pass/expr-if-box.rs +++ b/src/test/run-pass/expr-if-box.rs @@ -16,12 +16,12 @@ // Tests for if as expressions returning boxed types fn test_box() { let rs = if true { @100 } else { @101 }; - fail_unless!((*rs == 100)); + assert!((*rs == 100)); } fn test_str() { let rs = if true { ~"happy" } else { ~"sad" }; - fail_unless!((rs == ~"happy")); + assert!((rs == ~"happy")); } pub fn main() { test_box(); test_str(); } diff --git a/src/test/run-pass/expr-if-fail.rs b/src/test/run-pass/expr-if-fail.rs index 813ce4edbaeaa..7e2e0badb3662 100644 --- a/src/test/run-pass/expr-if-fail.rs +++ b/src/test/run-pass/expr-if-fail.rs @@ -8,16 +8,16 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn test_if_fail() { let x = if false { fail!() } else { 10 }; fail_unless!((x == 10)); } +fn test_if_fail() { let x = if false { fail!() } else { 10 }; assert!((x == 10)); } fn test_else_fail() { let x = if true { 10 } else { fail!() }; - fail_unless!((x == 10)); + assert!((x == 10)); } fn test_elseif_fail() { let x = if false { 0 } else if false { fail!() } else { 10 }; - fail_unless!((x == 10)); + assert!((x == 10)); } pub fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); } diff --git a/src/test/run-pass/expr-if-generic-box1.rs b/src/test/run-pass/expr-if-generic-box1.rs index 036b99b344aa4..def991adea875 100644 --- a/src/test/run-pass/expr-if-generic-box1.rs +++ b/src/test/run-pass/expr-if-generic-box1.rs @@ -16,7 +16,7 @@ type compare = @fn(@T, @T) -> bool; fn test_generic(expected: @T, not_expected: @T, eq: compare) { let actual: @T = if true { expected } else { not_expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_box() { diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs index 5868f45f3c8e6..910e0b2da958d 100644 --- a/src/test/run-pass/expr-if-generic-box2.rs +++ b/src/test/run-pass/expr-if-generic-box2.rs @@ -16,7 +16,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, not_expected: T, eq: compare) { let actual: T = if true { expected } else { not_expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_vec() { diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs index f4945a0fa2144..8d2ce83c87946 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -16,7 +16,7 @@ type compare = @fn(T, T) -> bool; fn test_generic(expected: T, not_expected: T, eq: compare) { let actual: T = if true { expected } else { not_expected }; - fail_unless!((eq(expected, actual))); + assert!((eq(expected, actual))); } fn test_bool() { diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index 1421234783575..b2bbfcaf9a5ca 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -19,7 +19,7 @@ struct I { i: int } fn test_rec() { let rs = if true { I {i: 100} } else { I {i: 101} }; - fail_unless!((rs.i == 100)); + assert!((rs.i == 100)); } enum mood { happy, sad, } @@ -33,7 +33,7 @@ impl cmp::Eq for mood { fn test_tag() { let rs = if true { happy } else { sad }; - fail_unless!((rs == happy)); + assert!((rs == happy)); } pub fn main() { test_rec(); test_tag(); } diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs index 1b635431ba68b..9f90ff32f8379 100644 --- a/src/test/run-pass/expr-if-unique.rs +++ b/src/test/run-pass/expr-if-unique.rs @@ -16,7 +16,7 @@ // Tests for if as expressions returning boxed types fn test_box() { let rs = if true { ~100 } else { ~101 }; - fail_unless!((*rs == 100)); + assert!((*rs == 100)); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs index 55958f88ced3f..54f831e44b60b 100644 --- a/src/test/run-pass/expr-if.rs +++ b/src/test/run-pass/expr-if.rs @@ -14,43 +14,43 @@ // -*- rust -*- // Tests for if as expressions -fn test_if() { let rs: bool = if true { true } else { false }; fail_unless!((rs)); } +fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); } fn test_else() { let rs: bool = if false { false } else { true }; - fail_unless!((rs)); + assert!((rs)); } fn test_elseif1() { let rs: bool = if true { true } else if true { false } else { false }; - fail_unless!((rs)); + assert!((rs)); } fn test_elseif2() { let rs: bool = if false { false } else if true { true } else { false }; - fail_unless!((rs)); + assert!((rs)); } fn test_elseif3() { let rs: bool = if false { false } else if false { false } else { true }; - fail_unless!((rs)); + assert!((rs)); } fn test_inferrence() { let rs = if true { true } else { false }; - fail_unless!((rs)); + assert!((rs)); } fn test_if_as_if_condition() { let rs1 = if if false { false } else { true } { true } else { false }; - fail_unless!((rs1)); + assert!((rs1)); let rs2 = if if true { false } else { true } { false } else { true }; - fail_unless!((rs2)); + assert!((rs2)); } fn test_if_as_block_result() { let rs = if true { if false { false } else { true } } else { false }; - fail_unless!((rs)); + assert!((rs)); } pub fn main() { diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index c5d52830686fd..eef0924f487e4 100644 --- a/src/test/run-pass/exterior.rs +++ b/src/test/run-pass/exterior.rs @@ -14,13 +14,13 @@ // -*- rust -*- struct Point {x: int, y: int, z: int} -fn f(p: @mut Point) { fail_unless!((p.z == 12)); p.z = 13; fail_unless!((p.z == 13)); } +fn f(p: @mut Point) { assert!((p.z == 12)); p.z = 13; assert!((p.z == 13)); } pub fn main() { let a: Point = Point {x: 10, y: 11, z: 12}; let b: @mut Point = @mut copy a; - fail_unless!((b.z == 12)); + assert!((b.z == 12)); f(b); - fail_unless!((a.z == 12)); - fail_unless!((b.z == 13)); + assert!((a.z == 12)); + assert!((b.z == 13)); } diff --git a/src/test/run-pass/extern-call-deep.rs b/src/test/run-pass/extern-call-deep.rs index cf396695d2620..c29eb2613ad21 100644 --- a/src/test/run-pass/extern-call-deep.rs +++ b/src/test/run-pass/extern-call-deep.rs @@ -33,5 +33,5 @@ fn count(n: uint) -> uint { pub fn main() { let result = count(1000u); debug!("result = %?", result); - fail_unless!(result == 1000u); + assert!(result == 1000u); } diff --git a/src/test/run-pass/extern-call-deep2.rs b/src/test/run-pass/extern-call-deep2.rs index 3175ddf978400..4e807f0f169ec 100644 --- a/src/test/run-pass/extern-call-deep2.rs +++ b/src/test/run-pass/extern-call-deep2.rs @@ -36,6 +36,6 @@ pub fn main() { do task::spawn { let result = count(1000u); debug!("result = %?", result); - fail_unless!(result == 1000u); + assert!(result == 1000u); }; } diff --git a/src/test/run-pass/extern-call-scrub.rs b/src/test/run-pass/extern-call-scrub.rs index e456677255613..eafdd3c5e9946 100644 --- a/src/test/run-pass/extern-call-scrub.rs +++ b/src/test/run-pass/extern-call-scrub.rs @@ -40,6 +40,6 @@ pub fn main() { do task::spawn { let result = count(12u); debug!("result = %?", result); - fail_unless!(result == 2048u); + assert!(result == 2048u); }; } diff --git a/src/test/run-pass/extern-call.rs b/src/test/run-pass/extern-call.rs index d0c75b7c7397e..6e41f91dcd7f8 100644 --- a/src/test/run-pass/extern-call.rs +++ b/src/test/run-pass/extern-call.rs @@ -33,5 +33,5 @@ fn fact(n: uint) -> uint { pub fn main() { let result = fact(10u); debug!("result = %?", result); - fail_unless!(result == 3628800u); + assert!(result == 3628800u); } diff --git a/src/test/run-pass/extern-crosscrate.rs b/src/test/run-pass/extern-crosscrate.rs index 7bc68333f4a65..de7dd7e4c8c1d 100644 --- a/src/test/run-pass/extern-crosscrate.rs +++ b/src/test/run-pass/extern-crosscrate.rs @@ -23,5 +23,5 @@ fn fact(n: uint) -> uint { pub fn main() { let result = fact(10u); debug!("result = %?", result); - fail_unless!(result == 3628800u); + assert!(result == 3628800u); } diff --git a/src/test/run-pass/extern-pass-TwoU64s-ref.rs b/src/test/run-pass/extern-pass-TwoU64s-ref.rs index f04e9d086e94f..87bec86d8de70 100644 --- a/src/test/run-pass/extern-pass-TwoU64s-ref.rs +++ b/src/test/run-pass/extern-pass-TwoU64s-ref.rs @@ -25,7 +25,7 @@ pub fn main() { unsafe { let x = TwoU64s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU64s(x); - fail_unless!(x == y); + assert!(x == y); } } diff --git a/src/test/run-pass/extern-pass-TwoU64s.rs b/src/test/run-pass/extern-pass-TwoU64s.rs index 1937ddaa9f42a..fb91d5495e16f 100644 --- a/src/test/run-pass/extern-pass-TwoU64s.rs +++ b/src/test/run-pass/extern-pass-TwoU64s.rs @@ -26,7 +26,7 @@ pub fn main() { unsafe { let x = TwoU64s {one: 22, two: 23}; let y = rust_dbg_extern_identity_TwoU64s(x); - fail_unless!(x == y); + assert!(x == y); } } diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs index 104ea342cd5e0..f4fa6bde392b9 100644 --- a/src/test/run-pass/extern-pass-char.rs +++ b/src/test/run-pass/extern-pass-char.rs @@ -16,7 +16,7 @@ pub extern { pub fn main() { unsafe { - fail_unless!(22_u8 == rust_dbg_extern_identity_u8(22_u8)); + assert!(22_u8 == rust_dbg_extern_identity_u8(22_u8)); } } diff --git a/src/test/run-pass/extern-pass-double.rs b/src/test/run-pass/extern-pass-double.rs index afdec4d100298..4e16acb4ad580 100644 --- a/src/test/run-pass/extern-pass-double.rs +++ b/src/test/run-pass/extern-pass-double.rs @@ -14,7 +14,7 @@ pub extern { pub fn main() { unsafe { - fail_unless!(22.0_f64 == rust_dbg_extern_identity_double(22.0_f64)); + assert!(22.0_f64 == rust_dbg_extern_identity_double(22.0_f64)); } } diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs index 0d6220e7b25cd..14d05f821770a 100644 --- a/src/test/run-pass/extern-pass-u32.rs +++ b/src/test/run-pass/extern-pass-u32.rs @@ -16,7 +16,7 @@ pub extern { pub fn main() { unsafe { - fail_unless!(22_u32 == rust_dbg_extern_identity_u32(22_u32)); + assert!(22_u32 == rust_dbg_extern_identity_u32(22_u32)); } } diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs index 3177703523833..2b5a03a4d7122 100644 --- a/src/test/run-pass/extern-pass-u64.rs +++ b/src/test/run-pass/extern-pass-u64.rs @@ -16,7 +16,7 @@ pub extern { pub fn main() { unsafe { - fail_unless!(22_u64 == rust_dbg_extern_identity_u64(22_u64)); + assert!(22_u64 == rust_dbg_extern_identity_u64(22_u64)); } } diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs index ed1567897eb11..e334dabe88365 100644 --- a/src/test/run-pass/extern-stress.rs +++ b/src/test/run-pass/extern-stress.rs @@ -36,7 +36,7 @@ fn count(n: uint) -> uint { pub fn main() { for iter::repeat(100u) { do task::spawn { - fail_unless!(count(5u) == 16u); + assert!(count(5u) == 16u); }; } } diff --git a/src/test/run-pass/extern-take-value.rs b/src/test/run-pass/extern-take-value.rs index 513d9d284d0e2..c3815cf2a67f6 100644 --- a/src/test/run-pass/extern-take-value.rs +++ b/src/test/run-pass/extern-take-value.rs @@ -20,6 +20,6 @@ pub fn main() { let b: *u8 = f; let c: *u8 = g; - fail_unless!(a == b); - fail_unless!(a != c); + assert!(a == b); + assert!(a != c); } diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs index 4f94193b85613..13c3fd44f3969 100644 --- a/src/test/run-pass/extern-yield.rs +++ b/src/test/run-pass/extern-yield.rs @@ -35,7 +35,7 @@ pub fn main() { do task::spawn { let result = count(5u); debug!("result = %?", result); - fail_unless!(result == 16u); + assert!(result == 16u); }; } } diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index 958e2e1e79e8a..ec82db8644c55 100644 --- a/src/test/run-pass/fact.rs +++ b/src/test/run-pass/fact.rs @@ -32,7 +32,7 @@ fn f(x: int) -> int { } pub fn main() { - fail_unless!((f(5) == 120)); + assert!((f(5) == 120)); // debug!("all done"); } diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs index fc03eaf3b03c9..76b2309085aba 100644 --- a/src/test/run-pass/fixed-point-bind-box.rs +++ b/src/test/run-pass/fixed-point-bind-box.rs @@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int { pub fn main() { let fact = fix(fact_); - fail_unless!((fact(5) == 120)); - fail_unless!((fact(2) == 2)); + assert!((fact(5) == 120)); + assert!((fact(2) == 2)); } diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs index d79cd36d8fc07..83060baac51a3 100644 --- a/src/test/run-pass/fixed-point-bind-unique.rs +++ b/src/test/run-pass/fixed-point-bind-unique.rs @@ -25,6 +25,6 @@ fn fact_(f: @fn(v: int) -> int, n: int) -> int { pub fn main() { let fact = fix(fact_); - fail_unless!((fact(5) == 120)); - fail_unless!((fact(2) == 2)); + assert!((fact(5) == 120)); + assert!((fact(2) == 2)); } diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs index 8c104f4f88b73..5daa525d9b161 100644 --- a/src/test/run-pass/fixed_length_copy.rs +++ b/src/test/run-pass/fixed_length_copy.rs @@ -15,6 +15,6 @@ pub fn main() { let arr = [1,2,3]; let arr2 = arr; - fail_unless!((arr[1] == 2)); - fail_unless!((arr2[2] == 3)); + assert!((arr[1] == 2)); + assert!((arr2[2] == 3)); } diff --git a/src/test/run-pass/fixed_length_vec_glue.rs b/src/test/run-pass/fixed_length_vec_glue.rs index a8752f444bfd8..b3ced135a4faf 100644 --- a/src/test/run-pass/fixed_length_vec_glue.rs +++ b/src/test/run-pass/fixed_length_vec_glue.rs @@ -14,5 +14,5 @@ pub fn main() { let arr = [1,2,3]; let struc = Struc {a: 13u8, b: arr, c: 42}; let s = sys::log_str(&struc); - fail_unless!((s == ~"{a: 13, b: [1, 2, 3], c: 42}")); + assert!((s == ~"{a: 13, b: [1, 2, 3], c: 42}")); } diff --git a/src/test/run-pass/float-nan.rs b/src/test/run-pass/float-nan.rs index 7ae38c45b99d6..918d45ad49246 100644 --- a/src/test/run-pass/float-nan.rs +++ b/src/test/run-pass/float-nan.rs @@ -12,80 +12,80 @@ extern mod std; pub fn main() { let nan = float::NaN; - fail_unless!((float::is_NaN(nan))); + assert!((float::is_NaN(nan))); let inf = float::infinity; - fail_unless!((-inf == float::neg_infinity)); + assert!((-inf == float::neg_infinity)); - fail_unless!(( nan != nan)); - fail_unless!(( nan != -nan)); - fail_unless!((-nan != -nan)); - fail_unless!((-nan != nan)); + assert!(( nan != nan)); + assert!(( nan != -nan)); + assert!((-nan != -nan)); + assert!((-nan != nan)); - fail_unless!(( nan != 1.)); - fail_unless!(( nan != 0.)); - fail_unless!(( nan != inf)); - fail_unless!(( nan != -inf)); + assert!(( nan != 1.)); + assert!(( nan != 0.)); + assert!(( nan != inf)); + assert!(( nan != -inf)); - fail_unless!(( 1. != nan)); - fail_unless!(( 0. != nan)); - fail_unless!(( inf != nan)); - fail_unless!((-inf != nan)); + assert!(( 1. != nan)); + assert!(( 0. != nan)); + assert!(( inf != nan)); + assert!((-inf != nan)); - fail_unless!((!( nan == nan))); - fail_unless!((!( nan == -nan))); - fail_unless!((!( nan == 1.))); - fail_unless!((!( nan == 0.))); - fail_unless!((!( nan == inf))); - fail_unless!((!( nan == -inf))); - fail_unless!((!( 1. == nan))); - fail_unless!((!( 0. == nan))); - fail_unless!((!( inf == nan))); - fail_unless!((!(-inf == nan))); - fail_unless!((!(-nan == nan))); - fail_unless!((!(-nan == -nan))); + assert!((!( nan == nan))); + assert!((!( nan == -nan))); + assert!((!( nan == 1.))); + assert!((!( nan == 0.))); + assert!((!( nan == inf))); + assert!((!( nan == -inf))); + assert!((!( 1. == nan))); + assert!((!( 0. == nan))); + assert!((!( inf == nan))); + assert!((!(-inf == nan))); + assert!((!(-nan == nan))); + assert!((!(-nan == -nan))); - fail_unless!((!( nan > nan))); - fail_unless!((!( nan > -nan))); - fail_unless!((!( nan > 0.))); - fail_unless!((!( nan > inf))); - fail_unless!((!( nan > -inf))); - fail_unless!((!( 0. > nan))); - fail_unless!((!( inf > nan))); - fail_unless!((!(-inf > nan))); - fail_unless!((!(-nan > nan))); + assert!((!( nan > nan))); + assert!((!( nan > -nan))); + assert!((!( nan > 0.))); + assert!((!( nan > inf))); + assert!((!( nan > -inf))); + assert!((!( 0. > nan))); + assert!((!( inf > nan))); + assert!((!(-inf > nan))); + assert!((!(-nan > nan))); - fail_unless!((!(nan < 0.))); - fail_unless!((!(nan < 1.))); - fail_unless!((!(nan < -1.))); - fail_unless!((!(nan < inf))); - fail_unless!((!(nan < -inf))); - fail_unless!((!(nan < nan))); - fail_unless!((!(nan < -nan))); + assert!((!(nan < 0.))); + assert!((!(nan < 1.))); + assert!((!(nan < -1.))); + assert!((!(nan < inf))); + assert!((!(nan < -inf))); + assert!((!(nan < nan))); + assert!((!(nan < -nan))); - fail_unless!((!( 0. < nan))); - fail_unless!((!( 1. < nan))); - fail_unless!((!( -1. < nan))); - fail_unless!((!( inf < nan))); - fail_unless!((!(-inf < nan))); - fail_unless!((!(-nan < nan))); + assert!((!( 0. < nan))); + assert!((!( 1. < nan))); + assert!((!( -1. < nan))); + assert!((!( inf < nan))); + assert!((!(-inf < nan))); + assert!((!(-nan < nan))); - fail_unless!((float::is_NaN(nan + inf))); - fail_unless!((float::is_NaN(nan + -inf))); - fail_unless!((float::is_NaN(nan + 0.))); - fail_unless!((float::is_NaN(nan + 1.))); - fail_unless!((float::is_NaN(nan * 1.))); - fail_unless!((float::is_NaN(nan / 1.))); - fail_unless!((float::is_NaN(nan / 0.))); - fail_unless!((float::is_NaN(0. / 0.))); - fail_unless!((float::is_NaN(-inf + inf))); - fail_unless!((float::is_NaN(inf - inf))); + assert!((float::is_NaN(nan + inf))); + assert!((float::is_NaN(nan + -inf))); + assert!((float::is_NaN(nan + 0.))); + assert!((float::is_NaN(nan + 1.))); + assert!((float::is_NaN(nan * 1.))); + assert!((float::is_NaN(nan / 1.))); + assert!((float::is_NaN(nan / 0.))); + assert!((float::is_NaN(0. / 0.))); + assert!((float::is_NaN(-inf + inf))); + assert!((float::is_NaN(inf - inf))); - fail_unless!((!float::is_NaN(-1.))); - fail_unless!((!float::is_NaN(0.))); - fail_unless!((!float::is_NaN(0.1))); - fail_unless!((!float::is_NaN(1.))); - fail_unless!((!float::is_NaN(inf))); - fail_unless!((!float::is_NaN(-inf))); - fail_unless!((!float::is_NaN(1./-inf))); + assert!((!float::is_NaN(-1.))); + assert!((!float::is_NaN(0.))); + assert!((!float::is_NaN(0.1))); + assert!((!float::is_NaN(1.))); + assert!((!float::is_NaN(inf))); + assert!((!float::is_NaN(-inf))); + assert!((!float::is_NaN(1./-inf))); } diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs index b9de5c66fe0a2..d84c4930aa209 100644 --- a/src/test/run-pass/float2.rs +++ b/src/test/run-pass/float2.rs @@ -22,13 +22,13 @@ pub fn main() { let i = 1.0E7f64; let j = 3.1e+9; let k = 3.2e-10; - fail_unless!((a == b)); - fail_unless!((c < b)); - fail_unless!((c == d)); - fail_unless!((e < g)); - fail_unless!((f < h)); - fail_unless!((g == 1000000.0f32)); - fail_unless!((h == i)); - fail_unless!((j > k)); - fail_unless!((k < a)); + assert!((a == b)); + assert!((c < b)); + assert!((c == d)); + assert!((e < g)); + assert!((f < h)); + assert!((g == 1000000.0f32)); + assert!((h == i)); + assert!((j > k)); + assert!((k < a)); } diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs index bbb1ec5bfa7ad..d1300e7f30c04 100644 --- a/src/test/run-pass/floatlits.rs +++ b/src/test/run-pass/floatlits.rs @@ -12,9 +12,9 @@ pub fn main() { let f = 4.999999999999; - fail_unless!((f > 4.90)); - fail_unless!((f < 5.0)); + assert!((f > 4.90)); + assert!((f < 5.0)); let g = 4.90000000001e-10; - fail_unless!((g > 5e-11)); - fail_unless!((g < 5e-9)); + assert!((g > 5e-11)); + assert!((g < 5e-9)); } diff --git a/src/test/run-pass/fn-assign-managed-to-bare-1.rs b/src/test/run-pass/fn-assign-managed-to-bare-1.rs index 9ab6af0ac276e..3a6d448667897 100644 --- a/src/test/run-pass/fn-assign-managed-to-bare-1.rs +++ b/src/test/run-pass/fn-assign-managed-to-bare-1.rs @@ -14,7 +14,7 @@ fn add(n: int) -> @fn(int) -> int { } pub fn main() { - fail_unless!(add(3)(4) == 7); + assert!(add(3)(4) == 7); let add3 : &fn(int)->int = add(3); - fail_unless!(add3(4) == 7); + assert!(add3(4) == 7); } diff --git a/src/test/run-pass/fn-assign-managed-to-bare-2.rs b/src/test/run-pass/fn-assign-managed-to-bare-2.rs index 3d788cd25d766..c7b7770d81fef 100644 --- a/src/test/run-pass/fn-assign-managed-to-bare-2.rs +++ b/src/test/run-pass/fn-assign-managed-to-bare-2.rs @@ -15,14 +15,14 @@ fn add(n: int) -> @fn(int) -> int { pub fn main() { - fail_unless!(add(3)(4) == 7); + assert!(add(3)(4) == 7); let add1 : @fn(int)->int = add(1); - fail_unless!(add1(6) == 7); + assert!(add1(6) == 7); let add2 : &(@fn(int)->int) = &add(2); - fail_unless!((*add2)(5) == 7); + assert!((*add2)(5) == 7); let add3 : &fn(int)->int = add(3); - fail_unless!(add3(4) == 7); + assert!(add3(4) == 7); } diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs index 356777a64d32e..7ad7d24df596a 100644 --- a/src/test/run-pass/fn-bare-assign.rs +++ b/src/test/run-pass/fn-bare-assign.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(i: int, called: &mut bool) { - fail_unless!(i == 10); + assert!(i == 10); *called = true; } @@ -21,5 +21,5 @@ pub fn main() { let mut called = false; let h = f; g(h, &mut called); - fail_unless!(called == true); + assert!(called == true); } diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs index 06ec69624c423..424d829b5ea7b 100644 --- a/src/test/run-pass/fn-bare-size.rs +++ b/src/test/run-pass/fn-bare-size.rs @@ -14,6 +14,6 @@ extern mod std; pub fn main() { // Bare functions should just be a pointer - fail_unless!(sys::rustrt::size_of::() == + assert!(sys::rustrt::size_of::() == sys::rustrt::size_of::()); } diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs index 4bfd1756ce63e..857a8cdb3d02f 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(val: T, f: extern fn(T)) { } fn f(+i: int) { - fail_unless!(i == 100); + assert!(i == 100); } pub fn main() { diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs index 3f5d3818e1c12..dc3f33a1991a4 100644 --- a/src/test/run-pass/fn-pattern-expected-type.rs +++ b/src/test/run-pass/fn-pattern-expected-type.rs @@ -10,8 +10,8 @@ pub fn main() { let f: &fn((int,int)) = |(x, y)| { - fail_unless!(x == 1); - fail_unless!(y == 2); + assert!(x == 1); + assert!(y == 2); }; f((1, 2)); } diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs index 4209791c87f4c..4c5084d9f1e21 100644 --- a/src/test/run-pass/for-destruct.rs +++ b/src/test/run-pass/for-destruct.rs @@ -12,6 +12,6 @@ struct Pair { x: int, y: int } pub fn main() { for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| { - fail_unless!((elt.x + elt.y == 30)); + assert!((elt.x + elt.y == 30)); } } diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs index a94131b36c051..b180e50202345 100644 --- a/src/test/run-pass/foreach-nested.rs +++ b/src/test/run-pass/foreach-nested.rs @@ -20,8 +20,8 @@ pub fn main() { do two |i| { do two |j| { a[p] = 10 * i + j; p += 1; } } - fail_unless!((a[0] == 0)); - fail_unless!((a[1] == 1)); - fail_unless!((a[2] == 10)); - fail_unless!((a[3] == 11)); + assert!((a[0] == 0)); + assert!((a[1] == 1)); + assert!((a[2] == 10)); + assert!((a[3] == 11)); } diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs index dfee55571243d..421ee7ff2b0f4 100644 --- a/src/test/run-pass/foreach-put-structured.rs +++ b/src/test/run-pass/foreach-put-structured.rs @@ -23,9 +23,9 @@ pub fn main() { let (_0, _1) = p; debug!(_0); debug!(_1); - fail_unless!((_0 + 10 == i)); + assert!((_0 + 10 == i)); i += 1; j = _1; }; - fail_unless!((j == 45)); + assert!((j == 45)); } diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs index 7e07232c32f25..99848ddfc7b48 100644 --- a/src/test/run-pass/foreach-simple-outer-slot.rs +++ b/src/test/run-pass/foreach-simple-outer-slot.rs @@ -17,7 +17,7 @@ pub fn main() { do first_ten |i| { debug!("main"); debug!(i); sum = sum + i; } debug!("sum"); debug!(sum); - fail_unless!((sum == 45)); + assert!((sum == 45)); } fn first_ten(it: &fn(int)) { diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs index 516be9fcda832..08cb8db5131ff 100644 --- a/src/test/run-pass/foreign-call-no-runtime.rs +++ b/src/test/run-pass/foreign-call-no-runtime.rs @@ -19,6 +19,6 @@ pub fn main() { extern fn callback(data: libc::uintptr_t) { unsafe { let data: *int = cast::transmute(data); - fail_unless!(*data == 100); + assert!(*data == 100); } } diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs index 6d7e0a6cfcc92..429e78b9c2194 100644 --- a/src/test/run-pass/foreign-fn-linkname.rs +++ b/src/test/run-pass/foreign-fn-linkname.rs @@ -29,5 +29,5 @@ fn strlen(str: ~str) -> uint { pub fn main() { let len = strlen(~"Rust"); - fail_unless!((len == 4u)); + assert!((len == 4u)); } diff --git a/src/test/run-pass/foreign-lib-path.rs b/src/test/run-pass/foreign-lib-path.rs index 337ec978858ed..61fc709d94933 100644 --- a/src/test/run-pass/foreign-lib-path.rs +++ b/src/test/run-pass/foreign-lib-path.rs @@ -22,5 +22,5 @@ mod WHATGOESHERE { } pub fn main() { - fail_unless!(IDONTKNOW() == 0x_BAD_DOOD_u32); + assert!(IDONTKNOW() == 0x_BAD_DOOD_u32); } diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs index 5e611b260d023..c2baab090db9d 100644 --- a/src/test/run-pass/fun-call-variants.rs +++ b/src/test/run-pass/fun-call-variants.rs @@ -17,5 +17,5 @@ pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound - fail_unless!((a == b)); + assert!((a == b)); } diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs index 659c508e3a3c5..db39850e74edb 100644 --- a/src/test/run-pass/fun-indirect-call.rs +++ b/src/test/run-pass/fun-indirect-call.rs @@ -17,5 +17,5 @@ fn f() -> int { return 42; } pub fn main() { let g: extern fn() -> int = f; let i: int = g(); - fail_unless!((i == 42)); + assert!((i == 42)); } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index 3da699640aca4..e5aa54534db1f 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -16,5 +16,5 @@ pub fn main() { let expected = @100; let actual = id::<@int>(expected); debug!(*actual); - fail_unless!((*expected == *actual)); + assert!((*expected == *actual)); } diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 287fc260bf86f..5eb91b317404b 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -16,5 +16,5 @@ pub fn main() { let expected = ~100; let actual = id::<~int>(expected.clone()); debug!(*actual); - fail_unless!((*expected == *actual)); + assert!((*expected == *actual)); } diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 3c4e1a857a7bd..0506256459529 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -16,5 +16,5 @@ struct Box {x: T, y: T, z: T} pub fn main() { let x: @Box = box::(Box{x: 1, y: 2, z: 3}); - fail_unless!((x.y == 2)); + assert!((x.y == 2)); } diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index e58fd884da6c0..747acca903ba2 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::(10); debug!(b.a); debug!(b.b); - fail_unless!((b.a == 10)); - fail_unless!((b.b == 10)); + assert!((b.a == 10)); + assert!((b.b == 10)); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index bd7e01d08d4ea..7708ffad3678a 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: T) -> Recbox { return Recbox {x: @t}; } pub fn main() { let foo: int = 17; let rbfoo: Recbox = reclift::(foo); - fail_unless!((*rbfoo.x == foo)); + assert!((*rbfoo.x == foo)); } diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index b0da35ac82c0f..693b83f1102be 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: T) -> Recbox { return Recbox {x: ~t}; } pub fn main() { let foo: int = 17; let rbfoo: Recbox = reclift::(foo); - fail_unless!((*rbfoo.x == foo)); + assert!((*rbfoo.x == foo)); } diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index 3dbbd62ff7fac..7c21bd52d4647 100644 --- a/src/test/run-pass/generic-fn-infer.rs +++ b/src/test/run-pass/generic-fn-infer.rs @@ -16,4 +16,4 @@ // Issue #45: infer type parameters in function applications fn id(x: T) -> T { return x; } -pub fn main() { let x: int = 42; let y: int = id(x); fail_unless!((x == y)); } +pub fn main() { let x: int = 42; let y: int = id(x); assert!((x == y)); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index 4c0248c488f9e..8108e15ee148c 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::(x); debug!(y); - fail_unless!((x == y)); + assert!((x == y)); b = id::(a); debug!(b); - fail_unless!((a == b)); + assert!((a == b)); q = id::(p); x = p.z; y = q.z; debug!(y); - fail_unless!((x == y)); + assert!((x == y)); } diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs index acdd3fc460089..ebfc362c72c43 100644 --- a/src/test/run-pass/generic-object.rs +++ b/src/test/run-pass/generic-object.rs @@ -25,6 +25,6 @@ impl Foo for S { pub fn main() { let x = @S { x: 1 }; let y = x as @Foo; - fail_unless!(y.get() == 1); + assert!(y.get() == 1); } diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs index 1229f7df54491..752dded83c44c 100644 --- a/src/test/run-pass/generic-tag-alt.rs +++ b/src/test/run-pass/generic-tag-alt.rs @@ -15,7 +15,7 @@ enum foo { arm(T), } fn altfoo(f: foo) { let mut hit = false; match f { arm::(x) => { debug!("in arm"); hit = true; } } - fail_unless!((hit)); + assert!((hit)); } pub fn main() { altfoo::(arm::(10)); } diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs index 30738ee33fdfb..42f19e86fe852 100644 --- a/src/test/run-pass/generic-tag-values.rs +++ b/src/test/run-pass/generic-tag-values.rs @@ -18,14 +18,14 @@ struct Pair { x: int, y: int } pub fn main() { let nop: noption = some::(5); - match nop { some::(n) => { debug!(n); fail_unless!((n == 5)); } } + match nop { some::(n) => { debug!(n); assert!((n == 5)); } } let nop2: noption = some(Pair{x: 17, y: 42}); match nop2 { some(t) => { debug!(t.x); debug!(t.y); - fail_unless!((t.x == 17)); - fail_unless!((t.y == 42)); + assert!((t.x == 17)); + assert!((t.y == 42)); } } } diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs index ce419ff002f9c..cd5944ca0f10d 100644 --- a/src/test/run-pass/generic-temporary.rs +++ b/src/test/run-pass/generic-temporary.rs @@ -12,7 +12,7 @@ fn mk() -> int { return 1; } -fn chk(a: int) { debug!(a); fail_unless!((a == 1)); } +fn chk(a: int) { debug!(a); assert!((a == 1)); } fn apply(produce: extern fn() -> T, consume: extern fn(T)) { diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index e80bc8da7174f..212e044dd14fc 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: (T, T, T)) -> T { let (_, _, x) = t; return x; } pub fn main() { debug!(get_third((1, 2, 3))); - fail_unless!((get_third((1, 2, 3)) == 3)); - fail_unless!((get_third((5u8, 6u8, 7u8)) == 7u8)); + assert!((get_third((1, 2, 3)) == 3)); + assert!((get_third((5u8, 6u8, 7u8)) == 7u8)); } diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs index 0579604faef0a..8f9208ea91726 100644 --- a/src/test/run-pass/generic-type.rs +++ b/src/test/run-pass/generic-type.rs @@ -14,6 +14,6 @@ struct Pair {x: T, y: T} pub fn main() { let x: Pair = Pair {x: 10, y: 12}; - fail_unless!((x.x == 10)); - fail_unless!((x.y == 12)); + assert!((x.x == 10)); + assert!((x.y == 12)); } diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 98c7c660e697c..064e2f5462822 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -14,5 +14,5 @@ fn box(x: Triple) -> ~Triple { return ~x; } pub fn main() { let x: ~Triple = box::(Triple{x: 1, y: 2, z: 3}); - fail_unless!((x.y == 2)); + assert!((x.y == 2)); } diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs index 83a6a9170cc2a..afd018de3bb39 100644 --- a/src/test/run-pass/getopts_ref.rs +++ b/src/test/run-pass/getopts_ref.rs @@ -20,7 +20,7 @@ pub fn main() { match getopts(args, opts) { result::Ok(ref m) => - fail_unless!(!opt_present(m, "b")), + assert!(!opt_present(m, "b")), result::Err(ref f) => fail!(fail_str(copy *f)) }; diff --git a/src/test/run-pass/global-scope.rs b/src/test/run-pass/global-scope.rs index 272889e5b9aa8..3dd912dea9a13 100644 --- a/src/test/run-pass/global-scope.rs +++ b/src/test/run-pass/global-scope.rs @@ -14,7 +14,7 @@ pub fn f() -> int { return 1; } pub mod foo { pub fn f() -> int { return 2; } - pub fn g() { fail_unless!((f() == 2)); fail_unless!((::f() == 1)); } + pub fn g() { assert!((f() == 2)); assert!((::f() == 1)); } } pub fn main() { return foo::g(); } diff --git a/src/test/run-pass/guards-not-exhaustive.rs b/src/test/run-pass/guards-not-exhaustive.rs index 1647fd5335375..8f5b288b755dd 100644 --- a/src/test/run-pass/guards-not-exhaustive.rs +++ b/src/test/run-pass/guards-not-exhaustive.rs @@ -9,5 +9,5 @@ fn xyzzy(q: Q) -> uint { pub fn main() { - fail_unless!(xyzzy(R(Some(5))) == 0); + assert!(xyzzy(R(Some(5))) == 0); } diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs index 66667487001c2..8654e4a2a4b27 100644 --- a/src/test/run-pass/guards.rs +++ b/src/test/run-pass/guards.rs @@ -13,7 +13,7 @@ struct Pair { x: int, y: int } pub fn main() { let a = match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } }; - fail_unless!((a == 2)); + assert!((a == 2)); let b = match Pair {x: 10, y: 20} { @@ -21,5 +21,5 @@ pub fn main() { Pair {x: x, y: y} if x == 10 && y == 20 => { 2 } Pair {x: x, y: y} => { 3 } }; - fail_unless!((b == 2)); + assert!((b == 2)); } diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs index 71e4b9a80397d..af3b724cfe29f 100644 --- a/src/test/run-pass/i32-sub.rs +++ b/src/test/run-pass/i32-sub.rs @@ -12,4 +12,4 @@ // -*- rust -*- -pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; fail_unless!((x == 400_i32)); } +pub fn main() { let mut x: i32 = -400_i32; x = 0_i32 - x; assert!((x == 400_i32)); } diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs index ca6254f84c239..9708e04058b8c 100644 --- a/src/test/run-pass/i8-incr.rs +++ b/src/test/run-pass/i8-incr.rs @@ -17,5 +17,5 @@ pub fn main() { let y: i8 = -12i8; x = x + 1i8; x = x - 1i8; - fail_unless!((x == y)); + assert!((x == y)); } diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs index 4fb3a0c1a16c9..a29b1ff0c6984 100644 --- a/src/test/run-pass/import-glob-crate.rs +++ b/src/test/run-pass/import-glob-crate.rs @@ -17,5 +17,5 @@ use core::vec::*; pub fn main() { let mut v = from_elem(0u, 0); v = vec::append(v, ~[4, 2]); - fail_unless!((reversed(v) == ~[2, 4])); + assert!((reversed(v) == ~[2, 4])); } diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs index baaa41f5bba84..e9287f3562205 100644 --- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs +++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs @@ -14,19 +14,19 @@ pub fn main() { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - fail_unless!(x_message == ~"lots"); + assert!(x_message == ~"lots"); let y = 2i; let y_message = match y { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - fail_unless!(y_message == ~"lots"); + assert!(y_message == ~"lots"); let z = 1u64; let z_message = match z { 0 .. 1 => { ~"not many" } _ => { ~"lots" } }; - fail_unless!(z_message == ~"not many"); + assert!(z_message == ~"not many"); } diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs index 5db8e34c7b5ca..98919e49a1ad3 100644 --- a/src/test/run-pass/init-res-into-things.rs +++ b/src/test/run-pass/init-res-into-things.rs @@ -37,7 +37,7 @@ fn test_box() { { let a = @r(i); } - fail_unless!(*i == 1); + assert!(*i == 1); } fn test_rec() { @@ -45,7 +45,7 @@ fn test_rec() { { let a = Box {x: r(i)}; } - fail_unless!(*i == 1); + assert!(*i == 1); } fn test_tag() { @@ -57,7 +57,7 @@ fn test_tag() { { let a = t0(r(i)); } - fail_unless!(*i == 1); + assert!(*i == 1); } fn test_tup() { @@ -65,7 +65,7 @@ fn test_tup() { { let a = (r(i), 0); } - fail_unless!(*i == 1); + assert!(*i == 1); } fn test_unique() { @@ -73,7 +73,7 @@ fn test_unique() { { let a = ~r(i); } - fail_unless!(*i == 1); + assert!(*i == 1); } fn test_box_rec() { @@ -83,7 +83,7 @@ fn test_box_rec() { x: r(i) }; } - fail_unless!(*i == 1); + assert!(*i == 1); } pub fn main() { diff --git a/src/test/run-pass/int-conversion-coherence.rs b/src/test/run-pass/int-conversion-coherence.rs index d9fcbb4cb3ec1..235fab107e781 100644 --- a/src/test/run-pass/int-conversion-coherence.rs +++ b/src/test/run-pass/int-conversion-coherence.rs @@ -21,6 +21,6 @@ impl foo of plus for uint { fn plus() -> int { self as int + 20 } } impl foo of plus for int { fn plus() -> int { self + 10 } } pub fn main() { - fail_unless!(10.plus() == 20); + assert!(10.plus() == 20); } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index 711e4e9cdf41f..9d30c73860505 100644 --- a/src/test/run-pass/integral-indexing.rs +++ b/src/test/run-pass/integral-indexing.rs @@ -15,16 +15,16 @@ pub fn main() { let v: ~[int] = ~[0, 1, 2, 3, 4, 5]; let s: ~str = ~"abcdef"; - fail_unless!((v[3u] == 3)); - fail_unless!((v[3u8] == 3)); - fail_unless!((v[3i8] == 3)); - fail_unless!((v[3u32] == 3)); - fail_unless!((v[3i32] == 3)); + assert!((v[3u] == 3)); + assert!((v[3u8] == 3)); + assert!((v[3i8] == 3)); + assert!((v[3u32] == 3)); + assert!((v[3i32] == 3)); debug!(v[3u8]); - fail_unless!((s[3u] == 'd' as u8)); - fail_unless!((s[3u8] == 'd' as u8)); - fail_unless!((s[3i8] == 'd' as u8)); - fail_unless!((s[3u32] == 'd' as u8)); - fail_unless!((s[3i32] == 'd' as u8)); + assert!((s[3u] == 'd' as u8)); + assert!((s[3u8] == 'd' as u8)); + assert!((s[3i8] == 'd' as u8)); + assert!((s[3u32] == 'd' as u8)); + assert!((s[3i32] == 'd' as u8)); debug!(s[3u8]); } diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs index 5d25dafdd0618..5d1ed5f8692ff 100644 --- a/src/test/run-pass/intrinsic-alignment.rs +++ b/src/test/run-pass/intrinsic-alignment.rs @@ -25,16 +25,16 @@ mod m { #[cfg(target_arch = "x86")] pub fn main() { unsafe { - fail_unless!(::rusti::pref_align_of::() == 8u); - fail_unless!(::rusti::min_align_of::() == 4u); + assert!(::rusti::pref_align_of::() == 8u); + assert!(::rusti::min_align_of::() == 4u); } } #[cfg(target_arch = "x86_64")] pub fn main() { unsafe { - fail_unless!(::rusti::pref_align_of::() == 8u); - fail_unless!(::rusti::min_align_of::() == 8u); + assert!(::rusti::pref_align_of::() == 8u); + assert!(::rusti::min_align_of::() == 8u); } } } @@ -44,8 +44,8 @@ mod m { #[cfg(target_arch = "x86")] pub fn main() { unsafe { - fail_unless!(::rusti::pref_align_of::() == 8u); - fail_unless!(::rusti::min_align_of::() == 8u); + assert!(::rusti::pref_align_of::() == 8u); + assert!(::rusti::min_align_of::() == 8u); } } } diff --git a/src/test/run-pass/intrinsic-atomics-cc.rs b/src/test/run-pass/intrinsic-atomics-cc.rs index f4025658f7f15..da0c7e759f580 100644 --- a/src/test/run-pass/intrinsic-atomics-cc.rs +++ b/src/test/run-pass/intrinsic-atomics-cc.rs @@ -18,6 +18,6 @@ pub fn main() { unsafe { let mut x = 1; atomic_xchg(&mut x, 5); - fail_unless!(x == 5); + assert!(x == 5); } } diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs index 4e571f90602b5..cd2079667c28e 100644 --- a/src/test/run-pass/intrinsic-atomics.rs +++ b/src/test/run-pass/intrinsic-atomics.rs @@ -33,32 +33,32 @@ pub fn main() { unsafe { let mut x = ~1; - fail_unless!(rusti::atomic_cxchg(x, 1, 2) == 1); - fail_unless!(*x == 2); + assert!(rusti::atomic_cxchg(x, 1, 2) == 1); + assert!(*x == 2); - fail_unless!(rusti::atomic_cxchg_acq(x, 1, 3) == 2); - fail_unless!(*x == 2); + assert!(rusti::atomic_cxchg_acq(x, 1, 3) == 2); + assert!(*x == 2); - fail_unless!(rusti::atomic_cxchg_rel(x, 2, 1) == 2); - fail_unless!(*x == 1); + assert!(rusti::atomic_cxchg_rel(x, 2, 1) == 2); + assert!(*x == 1); - fail_unless!(rusti::atomic_xchg(x, 0) == 1); - fail_unless!(*x == 0); + assert!(rusti::atomic_xchg(x, 0) == 1); + assert!(*x == 0); - fail_unless!(rusti::atomic_xchg_acq(x, 1) == 0); - fail_unless!(*x == 1); + assert!(rusti::atomic_xchg_acq(x, 1) == 0); + assert!(*x == 1); - fail_unless!(rusti::atomic_xchg_rel(x, 0) == 1); - fail_unless!(*x == 0); + assert!(rusti::atomic_xchg_rel(x, 0) == 1); + assert!(*x == 0); - fail_unless!(rusti::atomic_xadd(x, 1) == 0); - fail_unless!(rusti::atomic_xadd_acq(x, 1) == 1); - fail_unless!(rusti::atomic_xadd_rel(x, 1) == 2); - fail_unless!(*x == 3); + assert!(rusti::atomic_xadd(x, 1) == 0); + assert!(rusti::atomic_xadd_acq(x, 1) == 1); + assert!(rusti::atomic_xadd_rel(x, 1) == 2); + assert!(*x == 3); - fail_unless!(rusti::atomic_xsub(x, 1) == 3); - fail_unless!(rusti::atomic_xsub_acq(x, 1) == 2); - fail_unless!(rusti::atomic_xsub_rel(x, 1) == 1); - fail_unless!(*x == 0); + assert!(rusti::atomic_xsub(x, 1) == 3); + assert!(rusti::atomic_xsub_acq(x, 1) == 2); + assert!(rusti::atomic_xsub_rel(x, 1) == 1); + assert!(*x == 0); } } diff --git a/src/test/run-pass/intrinsic-frame-address.rs b/src/test/run-pass/intrinsic-frame-address.rs index 6c25291c48db1..5562d26677d1f 100644 --- a/src/test/run-pass/intrinsic-frame-address.rs +++ b/src/test/run-pass/intrinsic-frame-address.rs @@ -21,7 +21,7 @@ mod rusti { pub fn main() { unsafe { do rusti::frame_address |addr| { - fail_unless!(addr.is_not_null()); + assert!(addr.is_not_null()); } } } diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs index 7544c89197bab..21a471db4807e 100644 --- a/src/test/run-pass/intrinsic-move-val.rs +++ b/src/test/run-pass/intrinsic-move-val.rs @@ -21,6 +21,6 @@ pub fn main() { let mut x = @1; let mut y = @2; rusti::move_val(&mut y, x); - fail_unless!(*y == 1); + assert!(*y == 1); } } diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs index 8731b812f4a54..75713d8c710ec 100644 --- a/src/test/run-pass/intrinsics-integer.rs +++ b/src/test/run-pass/intrinsics-integer.rs @@ -40,83 +40,83 @@ pub fn main() { unsafe { use rusti::*; - fail_unless!((ctpop8(0i8) == 0i8)); - fail_unless!((ctpop16(0i16) == 0i16)); - fail_unless!((ctpop32(0i32) == 0i32)); - fail_unless!((ctpop64(0i64) == 0i64)); - - fail_unless!((ctpop8(1i8) == 1i8)); - fail_unless!((ctpop16(1i16) == 1i16)); - fail_unless!((ctpop32(1i32) == 1i32)); - fail_unless!((ctpop64(1i64) == 1i64)); - - fail_unless!((ctpop8(10i8) == 2i8)); - fail_unless!((ctpop16(10i16) == 2i16)); - fail_unless!((ctpop32(10i32) == 2i32)); - fail_unless!((ctpop64(10i64) == 2i64)); - - fail_unless!((ctpop8(100i8) == 3i8)); - fail_unless!((ctpop16(100i16) == 3i16)); - fail_unless!((ctpop32(100i32) == 3i32)); - fail_unless!((ctpop64(100i64) == 3i64)); - - fail_unless!((ctpop8(-1i8) == 8i8)); - fail_unless!((ctpop16(-1i16) == 16i16)); - fail_unless!((ctpop32(-1i32) == 32i32)); - fail_unless!((ctpop64(-1i64) == 64i64)); - - fail_unless!((ctlz8(0i8) == 8i8)); - fail_unless!((ctlz16(0i16) == 16i16)); - fail_unless!((ctlz32(0i32) == 32i32)); - fail_unless!((ctlz64(0i64) == 64i64)); - - fail_unless!((ctlz8(1i8) == 7i8)); - fail_unless!((ctlz16(1i16) == 15i16)); - fail_unless!((ctlz32(1i32) == 31i32)); - fail_unless!((ctlz64(1i64) == 63i64)); - - fail_unless!((ctlz8(10i8) == 4i8)); - fail_unless!((ctlz16(10i16) == 12i16)); - fail_unless!((ctlz32(10i32) == 28i32)); - fail_unless!((ctlz64(10i64) == 60i64)); - - fail_unless!((ctlz8(100i8) == 1i8)); - fail_unless!((ctlz16(100i16) == 9i16)); - fail_unless!((ctlz32(100i32) == 25i32)); - fail_unless!((ctlz64(100i64) == 57i64)); - - fail_unless!((cttz8(-1i8) == 0i8)); - fail_unless!((cttz16(-1i16) == 0i16)); - fail_unless!((cttz32(-1i32) == 0i32)); - fail_unless!((cttz64(-1i64) == 0i64)); + assert!((ctpop8(0i8) == 0i8)); + assert!((ctpop16(0i16) == 0i16)); + assert!((ctpop32(0i32) == 0i32)); + assert!((ctpop64(0i64) == 0i64)); + + assert!((ctpop8(1i8) == 1i8)); + assert!((ctpop16(1i16) == 1i16)); + assert!((ctpop32(1i32) == 1i32)); + assert!((ctpop64(1i64) == 1i64)); + + assert!((ctpop8(10i8) == 2i8)); + assert!((ctpop16(10i16) == 2i16)); + assert!((ctpop32(10i32) == 2i32)); + assert!((ctpop64(10i64) == 2i64)); + + assert!((ctpop8(100i8) == 3i8)); + assert!((ctpop16(100i16) == 3i16)); + assert!((ctpop32(100i32) == 3i32)); + assert!((ctpop64(100i64) == 3i64)); + + assert!((ctpop8(-1i8) == 8i8)); + assert!((ctpop16(-1i16) == 16i16)); + assert!((ctpop32(-1i32) == 32i32)); + assert!((ctpop64(-1i64) == 64i64)); + + assert!((ctlz8(0i8) == 8i8)); + assert!((ctlz16(0i16) == 16i16)); + assert!((ctlz32(0i32) == 32i32)); + assert!((ctlz64(0i64) == 64i64)); + + assert!((ctlz8(1i8) == 7i8)); + assert!((ctlz16(1i16) == 15i16)); + assert!((ctlz32(1i32) == 31i32)); + assert!((ctlz64(1i64) == 63i64)); + + assert!((ctlz8(10i8) == 4i8)); + assert!((ctlz16(10i16) == 12i16)); + assert!((ctlz32(10i32) == 28i32)); + assert!((ctlz64(10i64) == 60i64)); + + assert!((ctlz8(100i8) == 1i8)); + assert!((ctlz16(100i16) == 9i16)); + assert!((ctlz32(100i32) == 25i32)); + assert!((ctlz64(100i64) == 57i64)); + + assert!((cttz8(-1i8) == 0i8)); + assert!((cttz16(-1i16) == 0i16)); + assert!((cttz32(-1i32) == 0i32)); + assert!((cttz64(-1i64) == 0i64)); - fail_unless!((cttz8(0i8) == 8i8)); - fail_unless!((cttz16(0i16) == 16i16)); - fail_unless!((cttz32(0i32) == 32i32)); - fail_unless!((cttz64(0i64) == 64i64)); - - fail_unless!((cttz8(1i8) == 0i8)); - fail_unless!((cttz16(1i16) == 0i16)); - fail_unless!((cttz32(1i32) == 0i32)); - fail_unless!((cttz64(1i64) == 0i64)); - - fail_unless!((cttz8(10i8) == 1i8)); - fail_unless!((cttz16(10i16) == 1i16)); - fail_unless!((cttz32(10i32) == 1i32)); - fail_unless!((cttz64(10i64) == 1i64)); - - fail_unless!((cttz8(100i8) == 2i8)); - fail_unless!((cttz16(100i16) == 2i16)); - fail_unless!((cttz32(100i32) == 2i32)); - fail_unless!((cttz64(100i64) == 2i64)); - - fail_unless!((cttz8(-1i8) == 0i8)); - fail_unless!((cttz16(-1i16) == 0i16)); - fail_unless!((cttz32(-1i32) == 0i32)); - fail_unless!((cttz64(-1i64) == 0i64)); - - fail_unless!((bswap16(0x0A0Bi16) == 0x0B0Ai16)); - fail_unless!((bswap32(0x0ABBCC0Di32) == 0x0DCCBB0Ai32)); - fail_unless!((bswap64(0x0122334455667708i64) == 0x0877665544332201i64)); + assert!((cttz8(0i8) == 8i8)); + assert!((cttz16(0i16) == 16i16)); + assert!((cttz32(0i32) == 32i32)); + assert!((cttz64(0i64) == 64i64)); + + assert!((cttz8(1i8) == 0i8)); + assert!((cttz16(1i16) == 0i16)); + assert!((cttz32(1i32) == 0i32)); + assert!((cttz64(1i64) == 0i64)); + + assert!((cttz8(10i8) == 1i8)); + assert!((cttz16(10i16) == 1i16)); + assert!((cttz32(10i32) == 1i32)); + assert!((cttz64(10i64) == 1i64)); + + assert!((cttz8(100i8) == 2i8)); + assert!((cttz16(100i16) == 2i16)); + assert!((cttz32(100i32) == 2i32)); + assert!((cttz64(100i64) == 2i64)); + + assert!((cttz8(-1i8) == 0i8)); + assert!((cttz16(-1i16) == 0i16)); + assert!((cttz32(-1i32) == 0i32)); + assert!((cttz64(-1i64) == 0i64)); + + assert!((bswap16(0x0A0Bi16) == 0x0B0Ai16)); + assert!((bswap32(0x0ABBCC0Di32) == 0x0DCCBB0Ai32)); + assert!((bswap64(0x0122334455667708i64) == 0x0877665544332201i64)); } } diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs index b0db48057b19d..500f06e0517fa 100644 --- a/src/test/run-pass/intrinsics-math.rs +++ b/src/test/run-pass/intrinsics-math.rs @@ -54,54 +54,54 @@ pub fn main() { unsafe { use rusti::*; - fail_unless!((sqrtf32(64f32).fuzzy_eq(&8f32))); - fail_unless!((sqrtf64(64f64).fuzzy_eq(&8f64))); + assert!((sqrtf32(64f32).fuzzy_eq(&8f32))); + assert!((sqrtf64(64f64).fuzzy_eq(&8f64))); - fail_unless!((powif32(25f32, -2i32).fuzzy_eq(&0.0016f32))); - fail_unless!((powif64(23.2f64, 2i32).fuzzy_eq(&538.24f64))); + assert!((powif32(25f32, -2i32).fuzzy_eq(&0.0016f32))); + assert!((powif64(23.2f64, 2i32).fuzzy_eq(&538.24f64))); - fail_unless!((sinf32(0f32).fuzzy_eq(&0f32))); - fail_unless!((sinf64(f64::consts::pi / 2f64).fuzzy_eq(&1f64))); + assert!((sinf32(0f32).fuzzy_eq(&0f32))); + assert!((sinf64(f64::consts::pi / 2f64).fuzzy_eq(&1f64))); - fail_unless!((cosf32(0f32).fuzzy_eq(&1f32))); - fail_unless!((cosf64(f64::consts::pi * 2f64).fuzzy_eq(&1f64))); + assert!((cosf32(0f32).fuzzy_eq(&1f32))); + assert!((cosf64(f64::consts::pi * 2f64).fuzzy_eq(&1f64))); - fail_unless!((powf32(25f32, -2f32).fuzzy_eq(&0.0016f32))); - fail_unless!((powf64(400f64, 0.5f64).fuzzy_eq(&20f64))); + assert!((powf32(25f32, -2f32).fuzzy_eq(&0.0016f32))); + assert!((powf64(400f64, 0.5f64).fuzzy_eq(&20f64))); - fail_unless!((fabsf32(expf32(1f32) - f32::consts::e).fuzzy_eq(&0f32))); - fail_unless!((expf64(1f64).fuzzy_eq(&f64::consts::e))); + assert!((fabsf32(expf32(1f32) - f32::consts::e).fuzzy_eq(&0f32))); + assert!((expf64(1f64).fuzzy_eq(&f64::consts::e))); - fail_unless!((exp2f32(10f32).fuzzy_eq(&1024f32))); - fail_unless!((exp2f64(50f64).fuzzy_eq(&1125899906842624f64))); + assert!((exp2f32(10f32).fuzzy_eq(&1024f32))); + assert!((exp2f64(50f64).fuzzy_eq(&1125899906842624f64))); - fail_unless!((fabsf32(logf32(f32::consts::e) - 1f32).fuzzy_eq(&0f32))); - fail_unless!((logf64(1f64).fuzzy_eq(&0f64))); + assert!((fabsf32(logf32(f32::consts::e) - 1f32).fuzzy_eq(&0f32))); + assert!((logf64(1f64).fuzzy_eq(&0f64))); - fail_unless!((log10f32(10f32).fuzzy_eq(&1f32))); - fail_unless!((log10f64(f64::consts::e).fuzzy_eq(&f64::consts::log10_e))); + assert!((log10f32(10f32).fuzzy_eq(&1f32))); + assert!((log10f64(f64::consts::e).fuzzy_eq(&f64::consts::log10_e))); - fail_unless!((log2f32(8f32).fuzzy_eq(&3f32))); - fail_unless!((log2f64(f64::consts::e).fuzzy_eq(&f64::consts::log2_e))); + assert!((log2f32(8f32).fuzzy_eq(&3f32))); + assert!((log2f64(f64::consts::e).fuzzy_eq(&f64::consts::log2_e))); - fail_unless!((fmaf32(1.0f32, 2.0f32, 5.0f32).fuzzy_eq(&7.0f32))); - fail_unless!((fmaf64(0.0f64, -2.0f64, f64::consts::e).fuzzy_eq(&f64::consts::e))); + assert!((fmaf32(1.0f32, 2.0f32, 5.0f32).fuzzy_eq(&7.0f32))); + assert!((fmaf64(0.0f64, -2.0f64, f64::consts::e).fuzzy_eq(&f64::consts::e))); - fail_unless!((fabsf32(-1.0f32).fuzzy_eq(&1.0f32))); - fail_unless!((fabsf64(34.2f64).fuzzy_eq(&34.2f64))); + assert!((fabsf32(-1.0f32).fuzzy_eq(&1.0f32))); + assert!((fabsf64(34.2f64).fuzzy_eq(&34.2f64))); - fail_unless!((floorf32(3.8f32).fuzzy_eq(&3.0f32))); - fail_unless!((floorf64(-1.1f64).fuzzy_eq(&-2.0f64))); + assert!((floorf32(3.8f32).fuzzy_eq(&3.0f32))); + assert!((floorf64(-1.1f64).fuzzy_eq(&-2.0f64))); // Causes linker error // undefined reference to llvm.ceil.f32/64 - //fail_unless!((ceilf32(-2.3f32) == -2.0f32)); - //fail_unless!((ceilf64(3.8f64) == 4.0f64)); + //assert!((ceilf32(-2.3f32) == -2.0f32)); + //assert!((ceilf64(3.8f64) == 4.0f64)); // Causes linker error // undefined reference to llvm.trunc.f32/64 - //fail_unless!((truncf32(0.1f32) == 0.0f32)); - //fail_unless!((truncf64(-0.1f64) == 0.0f64)); + //assert!((truncf32(0.1f32) == 0.0f32)); + //assert!((truncf64(-0.1f64) == 0.0f64)); } } diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs index 111dd43747f0c..cd15dfa2a0d60 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(x: X) { - fail_unless!(x.b == 9u8); - fail_unless!(x.c == true); - fail_unless!(x.d == 10u8); - fail_unless!(x.e == 11u16); - fail_unless!(x.f == 12u8); - fail_unless!(x.g == 13u8); + assert!(x.b == 9u8); + assert!(x.c == true); + assert!(x.d == 10u8); + assert!(x.e == 11u16); + assert!(x.f == 12u8); + assert!(x.g == 13u8); } diff --git a/src/test/run-pass/issue-1458.rs b/src/test/run-pass/issue-1458.rs index a6556895dda33..0677c9dea7402 100644 --- a/src/test/run-pass/issue-1458.rs +++ b/src/test/run-pass/issue-1458.rs @@ -18,5 +18,5 @@ fn ret_plus_one() -> extern fn(&fn() -> int) -> int { pub fn main() { let z = do (ret_plus_one()) || { 2 }; - fail_unless!(z == 3); + assert!(z == 3); } diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs index 577d74c4118dd..c8937a2a628ee 100644 --- a/src/test/run-pass/issue-1701.rs +++ b/src/test/run-pass/issue-1701.rs @@ -24,8 +24,8 @@ fn noise(a: animal) -> Option<~str> { } pub fn main() { - fail_unless!(noise(cat(tabby)) == Some(~"meow")); - fail_unless!(noise(dog(pug)) == Some(~"woof")); - fail_unless!(noise(rabbit(~"Hilbert", upright)) == None); - fail_unless!(noise(tiger) == Some(~"roar")); + assert!(noise(cat(tabby)) == Some(~"meow")); + assert!(noise(dog(pug)) == Some(~"woof")); + assert!(noise(rabbit(~"Hilbert", upright)) == None); + assert!(noise(tiger) == Some(~"roar")); } diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs index 7cf255e017272..d5e9e8df91ea1 100644 --- a/src/test/run-pass/issue-2214.rs +++ b/src/test/run-pass/issue-2214.rs @@ -44,5 +44,5 @@ mod m { pub fn main() { let mut y: int = 5; let x: &mut int = &mut y; - fail_unless!((lgamma(1.0 as c_double, x) == 0.0 as c_double)); + assert!((lgamma(1.0 as c_double, x) == 0.0 as c_double)); } diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs index 22e69c92a1a1d..0be4084b08397 100644 --- a/src/test/run-pass/issue-2216.rs +++ b/src/test/run-pass/issue-2216.rs @@ -28,5 +28,5 @@ pub fn main() { } error!("%?", x); - fail_unless!((x == 42)); + assert!((x == 42)); } diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs index a571c49c438b7..29fa357ba1a28 100644 --- a/src/test/run-pass/issue-2428.rs +++ b/src/test/run-pass/issue-2428.rs @@ -16,5 +16,5 @@ pub fn main() { Bar = quux } - fail_unless!((Bar as int == quux)); + assert!((Bar as int == quux)); } diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index 3acfa74411721..35b92d994d273 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -73,7 +73,7 @@ pub mod pipes { pub fn send(mut p: send_packet, +payload: T) { let mut p = p.unwrap(); let mut p = unsafe { uniquify(p) }; - fail_unless!((*p).payload.is_none()); + assert!((*p).payload.is_none()); (*p).payload = Some(payload); let old_state = swap_state_rel(&mut (*p).state, full); match old_state { @@ -110,7 +110,7 @@ pub mod pipes { return Some(payload.unwrap()) } terminated => { - fail_unless!(old_state == terminated); + assert!(old_state == terminated); return None; } } diff --git a/src/test/run-pass/issue-2735-2.rs b/src/test/run-pass/issue-2735-2.rs index 396175716b210..96f76b0fd6ba6 100644 --- a/src/test/run-pass/issue-2735-2.rs +++ b/src/test/run-pass/issue-2735-2.rs @@ -31,5 +31,5 @@ fn defer<'r>(b: &'r mut bool) -> defer<'r> { pub fn main() { let mut dtor_ran = false; let _ = defer(&mut dtor_ran); - fail_unless!((dtor_ran)); + assert!((dtor_ran)); } diff --git a/src/test/run-pass/issue-2735-3.rs b/src/test/run-pass/issue-2735-3.rs index 7b5f19f1434dc..50e3c946f50ef 100644 --- a/src/test/run-pass/issue-2735-3.rs +++ b/src/test/run-pass/issue-2735-3.rs @@ -31,5 +31,5 @@ fn defer<'r>(b: &'r mut bool) -> defer<'r> { pub fn main() { let mut dtor_ran = false; defer(&mut dtor_ran); - fail_unless!((dtor_ran)); + assert!((dtor_ran)); } diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs index 630448d278214..b9efb441ae78d 100644 --- a/src/test/run-pass/issue-2748-b.rs +++ b/src/test/run-pass/issue-2748-b.rs @@ -14,6 +14,6 @@ pub fn main() { let x = &[1,2,3]; let y = x; let z = thing(x); - fail_unless!((z[2] == x[2])); - fail_unless!((z[1] == y[1])); + assert!((z[2] == x[2])); + assert!((z[1] == y[1])); } diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs index dee2483462d2d..2560c1ba77ebc 100644 --- a/src/test/run-pass/issue-2895.rs +++ b/src/test/run-pass/issue-2895.rs @@ -22,12 +22,12 @@ impl Drop for Kitty { #[cfg(target_arch = "x86_64")] pub fn main() { - fail_unless!((sys::size_of::() == 8 as uint)); - fail_unless!((sys::size_of::() == 16 as uint)); + assert!((sys::size_of::() == 8 as uint)); + assert!((sys::size_of::() == 16 as uint)); } #[cfg(target_arch = "x86")] pub fn main() { - fail_unless!((sys::size_of::() == 4 as uint)); - fail_unless!((sys::size_of::() == 8 as uint)); + assert!((sys::size_of::() == 4 as uint)); + assert!((sys::size_of::() == 8 as uint)); } diff --git a/src/test/run-pass/issue-2904.rs b/src/test/run-pass/issue-2904.rs index 84a4083a62860..ef7fd69157791 100644 --- a/src/test/run-pass/issue-2904.rs +++ b/src/test/run-pass/issue-2904.rs @@ -70,14 +70,14 @@ fn read_board_grid(+in: rdr) -> ~[~[square]] { grid.push(row) } let width = grid[0].len(); - for grid.each |row| { fail_unless!(row.len() == width) } + for grid.each |row| { assert!(row.len() == width) } grid } mod test { #[test] pub fn trivial_to_str() { - fail_unless!(lambda.to_str() == "\\") + assert!(lambda.to_str() == "\\") } #[test] diff --git a/src/test/run-pass/issue-2936.rs b/src/test/run-pass/issue-2936.rs index 5acae2da1ce4a..b989be0c1826a 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::(cbar(5)); - fail_unless!(x == 5); + assert!(x == 5); } diff --git a/src/test/run-pass/issue-2989.rs b/src/test/run-pass/issue-2989.rs index 10b845a923d5b..af8190f32a75e 100644 --- a/src/test/run-pass/issue-2989.rs +++ b/src/test/run-pass/issue-2989.rs @@ -41,5 +41,5 @@ pub fn main() { io::println(fmt!("%u => %u vs %u", i, bools[i] as uint, bools2[i] as uint)); } - fail_unless!(bools == bools2); + assert!(bools == bools2); } diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs index a218df591c5d9..aa0625aa110d9 100644 --- a/src/test/run-pass/issue-3091.rs +++ b/src/test/run-pass/issue-3091.rs @@ -11,5 +11,5 @@ pub fn main() { let x = 1; let y = 1; - fail_unless!(&x == &y); + assert!(&x == &y); } diff --git a/src/test/run-pass/issue-3168.rs b/src/test/run-pass/issue-3168.rs index f0e1779ba3766..d4eb0793dac53 100644 --- a/src/test/run-pass/issue-3168.rs +++ b/src/test/run-pass/issue-3168.rs @@ -26,6 +26,6 @@ pub fn main() { p3.recv(); }; error!("parent tries"); - fail_unless!(!p.recv().try_send(())); + assert!(!p.recv().try_send(())); error!("all done!"); } diff --git a/src/test/run-pass/issue-3176.rs b/src/test/run-pass/issue-3176.rs index c1008e581ea93..03b1c127c55ff 100644 --- a/src/test/run-pass/issue-3176.rs +++ b/src/test/run-pass/issue-3176.rs @@ -30,6 +30,6 @@ pub fn main() { c.send(()); }; error!("parent tries"); - fail_unless!(!p.recv().try_send(())); + assert!(!p.recv().try_send(())); error!("all done!"); } diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs index c759ca1ad0f47..02e61fc7ce2ca 100644 --- a/src/test/run-pass/issue-3211.rs +++ b/src/test/run-pass/issue-3211.rs @@ -3,6 +3,6 @@ pub fn main() { for 4096.times { x += 1; } - fail_unless!(x == 4096); + assert!(x == 4096); io::println(fmt!("x = %u", x)); } diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs index 6a1f00de21af2..9791b6cdc530a 100644 --- a/src/test/run-pass/issue-333.rs +++ b/src/test/run-pass/issue-333.rs @@ -12,4 +12,4 @@ fn quux(x: T) -> T { let f = id::; return f(x); } fn id(x: T) -> T { return x; } -pub fn main() { fail_unless!((quux(10) == 10)); } +pub fn main() { assert!((quux(10) == 10)); } diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs index b472d3a105b94..d79eef46f0523 100644 --- a/src/test/run-pass/issue-3424.rs +++ b/src/test/run-pass/issue-3424.rs @@ -22,7 +22,7 @@ fn tester() let loader: rsrc_loader = |_path| {result::Ok(~"more blah")}; let path = path::from_str("blah"); - fail_unless!(loader(&path).is_ok()); + assert!(loader(&path).is_ok()); } pub fn main() {} diff --git a/src/test/run-pass/issue-3556.rs b/src/test/run-pass/issue-3556.rs index 1df86da6cb7f9..703dcd54f0ac8 100644 --- a/src/test/run-pass/issue-3556.rs +++ b/src/test/run-pass/issue-3556.rs @@ -32,11 +32,11 @@ fn check_strs(actual: &str, expected: &str) -> bool pub fn main() { - // fail_unless!(check_strs(fmt!("%?", Text(@~"foo")), "Text(@~\"foo\")")); - // fail_unless!(check_strs(fmt!("%?", ETag(@~[~"foo"], @~"bar")), "ETag(@~[ ~\"foo\" ], @~\"bar\")")); + // assert!(check_strs(fmt!("%?", Text(@~"foo")), "Text(@~\"foo\")")); + // assert!(check_strs(fmt!("%?", ETag(@~[~"foo"], @~"bar")), "ETag(@~[ ~\"foo\" ], @~\"bar\")")); let t = Text(@~"foo"); let u = Section(@~[~"alpha"], true, @~[t], @~"foo", @~"foo", @~"foo", @~"foo", @~"foo"); let v = fmt!("%?", u); // this is the line that causes the seg fault - fail_unless!(v.len() > 0); + assert!(v.len() > 0); } diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs index 46a02ff15929c..f7b7605523c25 100644 --- a/src/test/run-pass/issue-3559.rs +++ b/src/test/run-pass/issue-3559.rs @@ -32,7 +32,7 @@ fn tester() let mut table = core::hashmap::linear::LinearMap(); table.insert(@~"one", 1); table.insert(@~"two", 2); - fail_unless!(check_strs(table.to_str(), ~"xxx")); // not sure what expected should be + assert!(check_strs(table.to_str(), ~"xxx")); // not sure what expected should be } pub fn main() {} diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index fdbd7ec304edd..9b7ab67c1a3e8 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -181,7 +181,7 @@ pub fn check_strs(actual: &str, expected: &str) -> bool fn test_ascii_art_ctor() { let art = AsciiArt(3, 3, '*'); - fail_unless!(check_strs(art.to_str(), "...\n...\n...")); + assert!(check_strs(art.to_str(), "...\n...\n...")); } @@ -191,7 +191,7 @@ fn test_add_pt() art.add_pt(0, 0); art.add_pt(0, -10); art.add_pt(1, 2); - fail_unless!(check_strs(art.to_str(), "*..\n...\n.*.")); + assert!(check_strs(art.to_str(), "*..\n...\n.*.")); } @@ -200,7 +200,7 @@ fn test_shapes() let mut art = AsciiArt(4, 4, '*'); art.add_rect(Rect {top_left: Point {x: 0, y: 0}, size: Size {width: 4, height: 4}}); art.add_point(Point {x: 2, y: 2}); - fail_unless!(check_strs(art.to_str(), "****\n*..*\n*.**\n****")); + assert!(check_strs(art.to_str(), "****\n*..*\n*.**\n****")); } pub fn main() { diff --git a/src/test/run-pass/issue-3574.rs b/src/test/run-pass/issue-3574.rs index 5d0d65820e14d..db937e745037a 100644 --- a/src/test/run-pass/issue-3574.rs +++ b/src/test/run-pass/issue-3574.rs @@ -22,6 +22,6 @@ fn compare(x: &str, y: &str) -> bool pub fn main() { - fail_unless!(compare("foo", "foo")); - fail_unless!(compare(@"foo", @"foo")); + assert!(compare("foo", "foo")); + assert!(compare(@"foo", @"foo")); } diff --git a/src/test/run-pass/issue-3683.rs b/src/test/run-pass/issue-3683.rs index edbc7852542c2..bdb191488b985 100644 --- a/src/test/run-pass/issue-3683.rs +++ b/src/test/run-pass/issue-3683.rs @@ -24,5 +24,5 @@ impl Foo for int { } pub fn main() { - fail_unless!((3.b() == 5)); + assert!((3.b() == 5)); } diff --git a/src/test/run-pass/issue-3935.rs b/src/test/run-pass/issue-3935.rs index 626932850cf42..af1538c6e62a0 100644 --- a/src/test/run-pass/issue-3935.rs +++ b/src/test/run-pass/issue-3935.rs @@ -17,5 +17,5 @@ pub fn main() { let town_bike = Bike { name: ~"schwinn" }; let my_bike = Bike { name: ~"surly" }; - fail_unless!(town_bike != my_bike); + assert!(town_bike != my_bike); } diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs index 84136b40a7ba7..d26e9f1ba7b43 100644 --- a/src/test/run-pass/issue-3979-generics.rs +++ b/src/test/run-pass/issue-3979-generics.rs @@ -37,5 +37,5 @@ impl Point: Movable; pub fn main() { let p = Point{ x: 1, y: 2}; p.translate(3); - fail_unless!(p.X() == 4); + assert!(p.X() == 4); } diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs index e87e7692855bc..5ecf80f481227 100644 --- a/src/test/run-pass/issue-3979-xcrate.rs +++ b/src/test/run-pass/issue-3979-xcrate.rs @@ -29,5 +29,5 @@ impl Movable for Point; pub fn main() { let mut p = Point{ x: 1, y: 2}; p.translate(3); - fail_unless!(p.X() == 4); + assert!(p.X() == 4); } diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs index 3ff677cf1fe5c..2303c52be58b0 100644 --- a/src/test/run-pass/issue-3979.rs +++ b/src/test/run-pass/issue-3979.rs @@ -40,5 +40,5 @@ impl Movable for Point; pub fn main() { let mut p = Point{ x: 1, y: 2}; p.translate(3); - fail_unless!(p.X() == 4); + assert!(p.X() == 4); } diff --git a/src/test/run-pass/issue-4241.rs b/src/test/run-pass/issue-4241.rs index 32aa5a0c70afe..18bc471afab1d 100644 --- a/src/test/run-pass/issue-4241.rs +++ b/src/test/run-pass/issue-4241.rs @@ -28,13 +28,13 @@ priv fn parse_data(len: uint, io: @io::Reader) -> Result { let res = if (len > 0) { let bytes = io.read_bytes(len as uint); - fail_unless!(bytes.len() == len); + assert!(bytes.len() == len); Data(bytes) } else { Data(~[]) }; - fail_unless!(io.read_char() == '\r'); - fail_unless!(io.read_char() == '\n'); + assert!(io.read_char() == '\r'); + assert!(io.read_char() == '\n'); return res; } diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs index ef947ef3cd79e..e509cb828f840 100644 --- a/src/test/run-pass/issue-4401.rs +++ b/src/test/run-pass/issue-4401.rs @@ -3,6 +3,6 @@ pub fn main() { for 999_999.times() { count += 1; } - fail_unless!(count == 999_999); + assert!(count == 999_999); io::println(fmt!("%u", count)); } diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index 5284fe92ade8e..68abeef15de5f 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -12,7 +12,7 @@ pub fn main() { let (port, chan) = comm::stream::<&'static str>(); do task::spawn { - fail_unless!(port.recv() == "hello, world"); + assert!(port.recv() == "hello, world"); } chan.send("hello, world"); diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs index d5184efa4c3db..70d7df3f787e7 100644 --- a/src/test/run-pass/issue-979.rs +++ b/src/test/run-pass/issue-979.rs @@ -33,5 +33,5 @@ pub fn main() { let p = Some(r(b)); } - fail_unless!(*b == 1); + assert!(*b == 1); } diff --git a/src/test/run-pass/issue2378c.rs b/src/test/run-pass/issue2378c.rs index 86fa5be0a22c8..ea8c47a3eb91a 100644 --- a/src/test/run-pass/issue2378c.rs +++ b/src/test/run-pass/issue2378c.rs @@ -20,5 +20,5 @@ use issue2378b::{methods}; pub fn main() { let x = {a: just(3), b: just(5)}; - fail_unless!(x[0u] == (3, 5)); + assert!(x[0u] == (3, 5)); } diff --git a/src/test/run-pass/istr.rs b/src/test/run-pass/istr.rs index e6e3931162695..2f641993467c7 100644 --- a/src/test/run-pass/istr.rs +++ b/src/test/run-pass/istr.rs @@ -12,9 +12,9 @@ fn test_stack_assign() { let s: ~str = ~"a"; debug!(s.clone()); let t: ~str = ~"a"; - fail_unless!((s == t)); + assert!((s == t)); let u: ~str = ~"b"; - fail_unless!((s != u)); + assert!((s != u)); } fn test_heap_lit() { ~"a big string"; } @@ -22,42 +22,42 @@ fn test_heap_lit() { ~"a big string"; } fn test_heap_assign() { let s: ~str = ~"a big ol' string"; let t: ~str = ~"a big ol' string"; - fail_unless!((s == t)); + assert!((s == t)); let u: ~str = ~"a bad ol' string"; - fail_unless!((s != u)); + assert!((s != u)); } fn test_heap_log() { let s = ~"a big ol' string"; debug!(s); } fn test_stack_add() { - fail_unless!((~"a" + ~"b" == ~"ab")); + assert!((~"a" + ~"b" == ~"ab")); let s: ~str = ~"a"; - fail_unless!((s + s == ~"aa")); - fail_unless!((~"" + ~"" == ~"")); + assert!((s + s == ~"aa")); + assert!((~"" + ~"" == ~"")); } -fn test_stack_heap_add() { fail_unless!((~"a" + ~"bracadabra" == ~"abracadabra")); } +fn test_stack_heap_add() { assert!((~"a" + ~"bracadabra" == ~"abracadabra")); } fn test_heap_add() { - fail_unless!((~"this should" + ~" totally work" == ~"this should totally work")); + assert!((~"this should" + ~" totally work" == ~"this should totally work")); } fn test_append() { let mut s = ~""; s += ~"a"; - fail_unless!((s == ~"a")); + assert!((s == ~"a")); let mut s = ~"a"; s += ~"b"; debug!(s.clone()); - fail_unless!((s == ~"ab")); + assert!((s == ~"ab")); let mut s = ~"c"; s += ~"offee"; - fail_unless!((s == ~"coffee")); + assert!((s == ~"coffee")); s += ~"&tea"; - fail_unless!((s == ~"coffee&tea")); + assert!((s == ~"coffee&tea")); } pub fn main() { diff --git a/src/test/run-pass/iter-all.rs b/src/test/run-pass/iter-all.rs index 62b4825067f81..1e81c72148f73 100644 --- a/src/test/run-pass/iter-all.rs +++ b/src/test/run-pass/iter-all.rs @@ -11,11 +11,11 @@ fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { - fail_unless!(![1u, 2u].all(is_even)); - fail_unless!([2u, 4u].all(is_even)); - fail_unless!([].all(is_even)); + assert!(![1u, 2u].all(is_even)); + assert!([2u, 4u].all(is_even)); + assert!([].all(is_even)); - fail_unless!(!iter::all(&Some(1u), is_even)); - fail_unless!(iter::all(&Some(2u), is_even)); - fail_unless!(iter::all(&None::, is_even)); + assert!(!iter::all(&Some(1u), is_even)); + assert!(iter::all(&Some(2u), is_even)); + assert!(iter::all(&None::, is_even)); } diff --git a/src/test/run-pass/iter-any.rs b/src/test/run-pass/iter-any.rs index e23a87287e733..6f3114f1290bc 100644 --- a/src/test/run-pass/iter-any.rs +++ b/src/test/run-pass/iter-any.rs @@ -11,11 +11,11 @@ fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { - fail_unless!(![1u, 3u].any(is_even)); - fail_unless!([1u, 2u].any(is_even)); - fail_unless!(![].any(is_even)); + assert!(![1u, 3u].any(is_even)); + assert!([1u, 2u].any(is_even)); + assert!(![].any(is_even)); - fail_unless!(!iter::any(&Some(1u), is_even)); - fail_unless!(iter::any(&Some(2u), is_even)); - fail_unless!(!iter::any(&None::, is_even)); + assert!(!iter::any(&Some(1u), is_even)); + assert!(iter::any(&Some(2u), is_even)); + assert!(!iter::any(&None::, is_even)); } diff --git a/src/test/run-pass/iter-contains.rs b/src/test/run-pass/iter-contains.rs index f56779a3c7a04..7b8beda9bf107 100644 --- a/src/test/run-pass/iter-contains.rs +++ b/src/test/run-pass/iter-contains.rs @@ -9,12 +9,12 @@ // except according to those terms. pub fn main() { - fail_unless!([].contains(&22u) == false); - fail_unless!([1u, 3u].contains(&22u) == false); - fail_unless!([22u, 1u, 3u].contains(&22u) == true); - fail_unless!([1u, 22u, 3u].contains(&22u) == true); - fail_unless!([1u, 3u, 22u].contains(&22u) == true); - fail_unless!(iter::contains(&None::, &22u) == false); - fail_unless!(iter::contains(&Some(1u), &22u) == false); - fail_unless!(iter::contains(&Some(22u), &22u) == true); + assert!([].contains(&22u) == false); + assert!([1u, 3u].contains(&22u) == false); + assert!([22u, 1u, 3u].contains(&22u) == true); + assert!([1u, 22u, 3u].contains(&22u) == true); + assert!([1u, 3u, 22u].contains(&22u) == true); + assert!(iter::contains(&None::, &22u) == false); + assert!(iter::contains(&Some(1u), &22u) == false); + assert!(iter::contains(&Some(22u), &22u) == true); } diff --git a/src/test/run-pass/iter-count.rs b/src/test/run-pass/iter-count.rs index 8de0a727a526d..8f67e48948610 100644 --- a/src/test/run-pass/iter-count.rs +++ b/src/test/run-pass/iter-count.rs @@ -9,11 +9,11 @@ // except according to those terms. pub fn main() { - fail_unless!([].count(&22u) == 0u); - fail_unless!([1u, 3u].count(&22u) == 0u); - fail_unless!([22u, 1u, 3u].count(&22u) == 1u); - fail_unless!([22u, 1u, 22u].count(&22u) == 2u); - fail_unless!(iter::count(&None::, &22u) == 0u); - fail_unless!(iter::count(&Some(1u), &22u) == 0u); - fail_unless!(iter::count(&Some(22u), &22u) == 1u); + assert!([].count(&22u) == 0u); + assert!([1u, 3u].count(&22u) == 0u); + assert!([22u, 1u, 3u].count(&22u) == 1u); + assert!([22u, 1u, 22u].count(&22u) == 2u); + assert!(iter::count(&None::, &22u) == 0u); + assert!(iter::count(&Some(1u), &22u) == 0u); + assert!(iter::count(&Some(22u), &22u) == 1u); } diff --git a/src/test/run-pass/iter-eachi.rs b/src/test/run-pass/iter-eachi.rs index 150b435bd5c5a..cbf4243c4096f 100644 --- a/src/test/run-pass/iter-eachi.rs +++ b/src/test/run-pass/iter-eachi.rs @@ -11,17 +11,17 @@ pub fn main() { let mut c = 0u; for [1u, 2u, 3u, 4u, 5u].eachi |i, v| { - fail_unless!((i + 1u) == *v); + assert!((i + 1u) == *v); c += 1u; } - fail_unless!(c == 5u); + assert!(c == 5u); for iter::eachi(&None::) |i, v| { fail!(); } let mut c = 0u; for iter::eachi(&Some(1u)) |i, v| { - fail_unless!((i + 1u) == *v); + assert!((i + 1u) == *v); c += 1u; } - fail_unless!(c == 1u); + assert!(c == 1u); } diff --git a/src/test/run-pass/iter-filter-to-vec.rs b/src/test/run-pass/iter-filter-to-vec.rs index f96ff5efd81dc..4fd523ea2c0ea 100644 --- a/src/test/run-pass/iter-filter-to-vec.rs +++ b/src/test/run-pass/iter-filter-to-vec.rs @@ -11,9 +11,9 @@ fn is_even(x: &uint) -> bool { (*x % 2) == 0 } pub fn main() { - fail_unless!([1, 3].filter_to_vec(is_even) == ~[]); - fail_unless!([1, 2, 3].filter_to_vec(is_even) == ~[2]); - fail_unless!(iter::filter_to_vec(&None::, is_even) == ~[]); - fail_unless!(iter::filter_to_vec(&Some(1u), is_even) == ~[]); - fail_unless!(iter::filter_to_vec(&Some(2u), is_even) == ~[2]); + assert!([1, 3].filter_to_vec(is_even) == ~[]); + assert!([1, 2, 3].filter_to_vec(is_even) == ~[2]); + assert!(iter::filter_to_vec(&None::, is_even) == ~[]); + assert!(iter::filter_to_vec(&Some(1u), is_even) == ~[]); + assert!(iter::filter_to_vec(&Some(2u), is_even) == ~[2]); } diff --git a/src/test/run-pass/iter-flat-map-to-vec.rs b/src/test/run-pass/iter-flat-map-to-vec.rs index 2ed6f95e455c9..b392b8efd2111 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 { } pub fn main() { - fail_unless!((~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u]); - fail_unless!((~[]).flat_map_to_vec(repeat) == ~[]); - fail_unless!(iter::flat_map_to_vec(&None::, repeat) == ~[]); - fail_unless!(iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u]); - fail_unless!(iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u]); + assert!((~[1u, 3u]).flat_map_to_vec(repeat) == ~[1u, 1u, 3u, 3u]); + assert!((~[]).flat_map_to_vec(repeat) == ~[]); + assert!(iter::flat_map_to_vec(&None::, repeat) == ~[]); + assert!(iter::flat_map_to_vec(&Some(1u), repeat) == ~[1u, 1u]); + assert!(iter::flat_map_to_vec(&Some(2u), repeat) == ~[2u, 2u]); - fail_unless!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u]); - fail_unless!((~[]).flat_map_to_vec(incd_if_even) == ~[]); - fail_unless!(iter::flat_map_to_vec(&None::, incd_if_even) == ~[]); - fail_unless!(iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[]); - fail_unless!(iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u]); + assert!((~[1u, 2u, 5u]).flat_map_to_vec(incd_if_even) == ~[3u]); + assert!((~[]).flat_map_to_vec(incd_if_even) == ~[]); + assert!(iter::flat_map_to_vec(&None::, incd_if_even) == ~[]); + assert!(iter::flat_map_to_vec(&Some(1u), incd_if_even) == ~[]); + assert!(iter::flat_map_to_vec(&Some(2u), incd_if_even) == ~[3u]); } diff --git a/src/test/run-pass/iter-foldl.rs b/src/test/run-pass/iter-foldl.rs index cbfb2fb7bc604..e5e5cd44032a7 100644 --- a/src/test/run-pass/iter-foldl.rs +++ b/src/test/run-pass/iter-foldl.rs @@ -11,9 +11,9 @@ fn add(x: &float, y: &uint) -> float { *x + ((*y) as float) } pub fn main() { - fail_unless!([1u, 3u].foldl(20f, add) == 24f); - fail_unless!([].foldl(20f, add) == 20f); - fail_unless!(iter::foldl(&None::, 20f, add) == 20f); - fail_unless!(iter::foldl(&Some(1u), 20f, add) == 21f); - fail_unless!(iter::foldl(&Some(2u), 20f, add) == 22f); + assert!([1u, 3u].foldl(20f, add) == 24f); + assert!([].foldl(20f, add) == 20f); + assert!(iter::foldl(&None::, 20f, add) == 20f); + assert!(iter::foldl(&Some(1u), 20f, add) == 21f); + assert!(iter::foldl(&Some(2u), 20f, add) == 22f); } diff --git a/src/test/run-pass/iter-map-to-vec.rs b/src/test/run-pass/iter-map-to-vec.rs index f2361376fd8cb..17af47d87333a 100644 --- a/src/test/run-pass/iter-map-to-vec.rs +++ b/src/test/run-pass/iter-map-to-vec.rs @@ -11,9 +11,9 @@ fn inc(x: &uint) -> uint { *x + 1 } pub fn main() { - fail_unless!([1, 3].map_to_vec(inc) == ~[2, 4]); - fail_unless!([1, 2, 3].map_to_vec(inc) == ~[2, 3, 4]); - fail_unless!(iter::map_to_vec(&None::, inc) == ~[]); - fail_unless!(iter::map_to_vec(&Some(1u), inc) == ~[2]); - fail_unless!(iter::map_to_vec(&Some(2u), inc) == ~[3]); + assert!([1, 3].map_to_vec(inc) == ~[2, 4]); + assert!([1, 2, 3].map_to_vec(inc) == ~[2, 3, 4]); + assert!(iter::map_to_vec(&None::, inc) == ~[]); + assert!(iter::map_to_vec(&Some(1u), inc) == ~[2]); + assert!(iter::map_to_vec(&Some(2u), inc) == ~[3]); } diff --git a/src/test/run-pass/iter-min-max.rs b/src/test/run-pass/iter-min-max.rs index 188aff44007a6..a7160615dbdc2 100644 --- a/src/test/run-pass/iter-min-max.rs +++ b/src/test/run-pass/iter-min-max.rs @@ -11,11 +11,11 @@ fn is_even(&&x: uint) -> bool { (x % 2u) == 0u } pub fn main() { - fail_unless!([1u, 3u].min() == 1u); - fail_unless!([3u, 1u].min() == 1u); - fail_unless!(iter::min(&Some(1u)) == 1u); + assert!([1u, 3u].min() == 1u); + assert!([3u, 1u].min() == 1u); + assert!(iter::min(&Some(1u)) == 1u); - fail_unless!([1u, 3u].max() == 3u); - fail_unless!([3u, 1u].max() == 3u); - fail_unless!(iter::max(&Some(3u)) == 3u); + assert!([1u, 3u].max() == 3u); + assert!([3u, 1u].max() == 3u); + assert!(iter::max(&Some(3u)) == 3u); } diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs index 983f47e8ab7ec..0fbca65e6fb23 100644 --- a/src/test/run-pass/iter-range.rs +++ b/src/test/run-pass/iter-range.rs @@ -11,7 +11,7 @@ fn range(a: int, b: int, it: &fn(int)) { - fail_unless!((a < b)); + assert!((a < b)); let mut i: int = a; while i < b { it(i); i += 1; } } diff --git a/src/test/run-pass/iter-to-vec.rs b/src/test/run-pass/iter-to-vec.rs index 00fcb17a0b0a1..944e9f5b0a586 100644 --- a/src/test/run-pass/iter-to-vec.rs +++ b/src/test/run-pass/iter-to-vec.rs @@ -9,10 +9,10 @@ // except according to those terms. pub fn main() { - fail_unless!([1u, 3u].to_vec() == ~[1u, 3u]); + assert!([1u, 3u].to_vec() == ~[1u, 3u]); let e: ~[uint] = ~[]; - fail_unless!(e.to_vec() == ~[]); - fail_unless!(iter::to_vec(&None::) == ~[]); - fail_unless!(iter::to_vec(&Some(1u)) == ~[1u]); - fail_unless!(iter::to_vec(&Some(2u)) == ~[2u]); + assert!(e.to_vec() == ~[]); + assert!(iter::to_vec(&None::) == ~[]); + assert!(iter::to_vec(&Some(1u)) == ~[1u]); + assert!(iter::to_vec(&Some(2u)) == ~[2u]); } diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs index 410286d683f59..1b9e818421e2e 100644 --- a/src/test/run-pass/ivec-add.rs +++ b/src/test/run-pass/ivec-add.rs @@ -14,11 +14,11 @@ fn double_int(a: int) -> ~[int] { return ~[a] + ~[a]; } pub fn main() { let mut d = double(1); - fail_unless!((d[0] == 1)); - fail_unless!((d[1] == 1)); + assert!((d[0] == 1)); + assert!((d[1] == 1)); d = double_int(1); - fail_unless!((d[0] == 1)); - fail_unless!((d[1] == 1)); + assert!((d[0] == 1)); + assert!((d[1] == 1)); } diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs index 0a39472025d26..3fb554dc4509a 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(v: @A) -> @repeat { pub fn main() { let x = &3; let y = repeater(@x); - fail_unless!(*x == *(y.get())); + assert!(*x == *(y.get())); } diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs index 3d121d087453c..442e79bde77ce 100644 --- a/src/test/run-pass/last-use-in-cap-clause.rs +++ b/src/test/run-pass/last-use-in-cap-clause.rs @@ -20,5 +20,5 @@ fn foo() -> @fn() -> int { } pub fn main() { - fail_unless!(foo()() == 22); + assert!(foo()() == 22); } diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs index e16229eec53d4..1a1e4816a361a 100644 --- a/src/test/run-pass/lazy-and-or.rs +++ b/src/test/run-pass/lazy-and-or.rs @@ -10,13 +10,13 @@ -fn incr(x: &mut int) -> bool { *x += 1; fail_unless!((false)); return false; } +fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; } pub fn main() { let x = 1 == 2 || 3 == 3; - fail_unless!((x)); + assert!((x)); let mut y: int = 10; debug!(x || incr(&mut y)); - fail_unless!((y == 10)); - if true && x { fail_unless!((true)); } else { fail_unless!((false)); } + assert!((y == 10)); + if true && x { assert!((true)); } else { assert!((false)); } } diff --git a/src/test/run-pass/let-destruct-fresh-mem.rs b/src/test/run-pass/let-destruct-fresh-mem.rs index 0b085f1fd324f..ae6118d063e9e 100644 --- a/src/test/run-pass/let-destruct-fresh-mem.rs +++ b/src/test/run-pass/let-destruct-fresh-mem.rs @@ -16,8 +16,8 @@ pub fn main() { let mut X {x: x, y: @A {a: a}} = u; x = 100; a = 100; - fail_unless!((x == 100)); - fail_unless!((a == 100)); - fail_unless!((u.x == 10)); - fail_unless!((u.y.a == 20)); + assert!((x == 100)); + assert!((a == 100)); + assert!((u.x == 10)); + assert!((u.y.a == 20)); } diff --git a/src/test/run-pass/let-destruct.rs b/src/test/run-pass/let-destruct.rs index 05e50e3e66047..6e2ce508928a7 100644 --- a/src/test/run-pass/let-destruct.rs +++ b/src/test/run-pass/let-destruct.rs @@ -14,5 +14,5 @@ struct X { x: xx, y: int } pub fn main() { let @X {x: xx(x), y: y} = @X{x: xx(10), y: 20}; - fail_unless!((x + y == 30)); + assert!((x + y == 30)); } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 1d8662de7c2a7..f2fb63cfc9e79 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -15,20 +15,20 @@ pub fn main() { let mut y = 0; for x.each |i| { debug!(*i); y += *i; } debug!(y); - fail_unless!((y == 6)); + assert!((y == 6)); let s = ~"hello there"; let mut i: int = 0; for str::each(s) |c| { - if i == 0 { fail_unless!((c == 'h' as u8)); } - if i == 1 { fail_unless!((c == 'e' as u8)); } - if i == 2 { fail_unless!((c == 'l' as u8)); } - if i == 3 { fail_unless!((c == 'l' as u8)); } - if i == 4 { fail_unless!((c == 'o' as u8)); } + if i == 0 { assert!((c == 'h' as u8)); } + if i == 1 { assert!((c == 'e' as u8)); } + if i == 2 { assert!((c == 'l' as u8)); } + if i == 3 { assert!((c == 'l' as u8)); } + if i == 4 { assert!((c == 'o' as u8)); } // ... i += 1; debug!(i); debug!(c); } - fail_unless!((i == 11)); + assert!((i == 11)); } diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs index a521b5fe47826..44e1292d9b1c1 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs @@ -19,13 +19,13 @@ enum foo { } fn check_log(exp: ~str, v: T) { - fail_unless!(exp == fmt!("%?", v)); + assert!(exp == fmt!("%?", v)); } pub fn main() { let x = list::from_vec(~[a(22u), b(~"hi")]); let exp = ~"@Cons(a(22), @Cons(b(~\"hi\"), @Nil))"; let act = fmt!("%?", x); - fail_unless!(act == exp); + assert!(act == exp); check_log(exp, x); } diff --git a/src/test/run-pass/log-knows-the-names-of-variants.rs b/src/test/run-pass/log-knows-the-names-of-variants.rs index bbd05daf49f2e..641d6155e23a9 100644 --- a/src/test/run-pass/log-knows-the-names-of-variants.rs +++ b/src/test/run-pass/log-knows-the-names-of-variants.rs @@ -19,8 +19,8 @@ enum bar { } pub fn main() { - fail_unless!(~"a(22)" == fmt!("%?", a(22u))); - fail_unless!(~"b(~\"hi\")" == fmt!("%?", b(~"hi"))); - fail_unless!(~"c" == fmt!("%?", c)); - fail_unless!(~"d" == fmt!("%?", d)); + assert!(~"a(22)" == fmt!("%?", a(22u))); + assert!(~"b(~\"hi\")" == fmt!("%?", b(~"hi"))); + assert!(~"c" == fmt!("%?", c)); + assert!(~"d" == fmt!("%?", d)); } diff --git a/src/test/run-pass/log-str.rs b/src/test/run-pass/log-str.rs index d41867f1722ab..e321789a2b1a1 100644 --- a/src/test/run-pass/log-str.rs +++ b/src/test/run-pass/log-str.rs @@ -10,8 +10,8 @@ pub fn main() { let act = sys::log_str(&~[1, 2, 3]); - fail_unless!(~"~[1, 2, 3]" == act); + assert!(~"~[1, 2, 3]" == act); let act = fmt!("%?/%6?", ~[1, 2, 3], ~"hi"); - fail_unless!(act == ~"~[1, 2, 3]/ ~\"hi\""); + assert!(act == ~"~[1, 2, 3]/ ~\"hi\""); } diff --git a/src/test/run-pass/loop-break-cont-1.rs b/src/test/run-pass/loop-break-cont-1.rs index a07203c9e1338..7ed4a0ba5ce0b 100644 --- a/src/test/run-pass/loop-break-cont-1.rs +++ b/src/test/run-pass/loop-break-cont-1.rs @@ -13,5 +13,5 @@ pub fn main() { loop { break; } - fail_unless!(true); + assert!(true); } diff --git a/src/test/run-pass/loop-break-cont.rs b/src/test/run-pass/loop-break-cont.rs index b0ea375228f4b..4a4da79367fb4 100644 --- a/src/test/run-pass/loop-break-cont.rs +++ b/src/test/run-pass/loop-break-cont.rs @@ -17,7 +17,7 @@ pub fn main() { break; } } - fail_unless!((i == 10u)); + assert!((i == 10u)); let mut is_even = false; loop { if i == 21u { @@ -31,7 +31,7 @@ pub fn main() { } is_even = true; } - fail_unless!(!is_even); + assert!(!is_even); loop { error!(~"c"); if i == 22u { @@ -44,5 +44,5 @@ pub fn main() { } is_even = true; } - fail_unless!(is_even); + assert!(is_even); } diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs index 55697a086aadb..a3caf1e4800d2 100644 --- a/src/test/run-pass/loop-scope.rs +++ b/src/test/run-pass/loop-scope.rs @@ -12,5 +12,5 @@ pub fn main() { let x = ~[10, 20, 30]; let mut sum = 0; for x.each |x| { sum += *x; } - fail_unless!((sum == 60)); + assert!((sum == 60)); } diff --git a/src/test/run-pass/macro-2.rs b/src/test/run-pass/macro-2.rs index 0606385ed7d53..b4ae81a32047d 100644 --- a/src/test/run-pass/macro-2.rs +++ b/src/test/run-pass/macro-2.rs @@ -19,5 +19,5 @@ pub fn main() { }) ) - fail_unless!(mylambda_tt!(y, y * 2)(8) == 16) + assert!(mylambda_tt!(y, y * 2)(8) == 16) } diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs index 91410fea16e54..45c8669eae2e9 100644 --- a/src/test/run-pass/macro-interpolation.rs +++ b/src/test/run-pass/macro-interpolation.rs @@ -23,7 +23,7 @@ macro_rules! overly_complicated ( ) pub fn main() { - fail_unless!(overly_complicated!(f, x, Option, { return Some(x); }, + assert!(overly_complicated!(f, x, Option, { return Some(x); }, Some(8u), Some(y), y) == 8u) } diff --git a/src/test/run-pass/macro-path.rs b/src/test/run-pass/macro-path.rs index da5d79baadf7e..a3bd03c80bc46 100644 --- a/src/test/run-pass/macro-path.rs +++ b/src/test/run-pass/macro-path.rs @@ -20,5 +20,5 @@ macro_rules! foo { } pub fn main() { - fail_unless!(foo!(m::t) == 10); + assert!(foo!(m::t) == 10); } diff --git a/src/test/run-pass/macro-stmt.rs b/src/test/run-pass/macro-stmt.rs index 26ad97ce21dba..d9417ee0a1953 100644 --- a/src/test/run-pass/macro-stmt.rs +++ b/src/test/run-pass/macro-stmt.rs @@ -27,16 +27,16 @@ pub fn main() { ); mylet!(y, 8*2); - fail_unless!((y == 16)); + assert!((y == 16)); myfn!(mult, (a,b), { a*b } ); - fail_unless!((mult(2, add(4,4)) == 16)); + assert!((mult(2, add(4,4)) == 16)); macro_rules! actually_an_expr_macro ( () => ( 16 ) ) - fail_unless!({ actually_an_expr_macro!() } == 16); + assert!({ actually_an_expr_macro!() } == 16); } diff --git a/src/test/run-pass/mod-inside-fn.rs b/src/test/run-pass/mod-inside-fn.rs index 768578d691e12..e4bc850644e4b 100644 --- a/src/test/run-pass/mod-inside-fn.rs +++ b/src/test/run-pass/mod-inside-fn.rs @@ -17,5 +17,5 @@ fn f() -> int { } pub fn main() { - fail_unless!(f() == 720); + assert!(f() == 720); } diff --git a/src/test/run-pass/mod-merge-hack.rs b/src/test/run-pass/mod-merge-hack.rs index 2f910fdbc2ca9..10f661b4f8d58 100644 --- a/src/test/run-pass/mod-merge-hack.rs +++ b/src/test/run-pass/mod-merge-hack.rs @@ -14,6 +14,6 @@ mod myint32; pub fn main() { - fail_unless!(myint32::bits == 32); - fail_unless!(myint32::min(10, 20) == 10); + assert!(myint32::bits == 32); + assert!(myint32::min(10, 20) == 10); } diff --git a/src/test/run-pass/mod_dir_path.rs b/src/test/run-pass/mod_dir_path.rs index 0d43e24809d85..f0cc4aa52d665 100644 --- a/src/test/run-pass/mod_dir_path.rs +++ b/src/test/run-pass/mod_dir_path.rs @@ -17,5 +17,5 @@ mod mod_dir_simple { } pub fn main() { - fail_unless!(mod_dir_simple::syrup::foo() == 10); + assert!(mod_dir_simple::syrup::foo() == 10); } diff --git a/src/test/run-pass/mod_dir_path2.rs b/src/test/run-pass/mod_dir_path2.rs index 0f6e94bce3302..2635084a07273 100644 --- a/src/test/run-pass/mod_dir_path2.rs +++ b/src/test/run-pass/mod_dir_path2.rs @@ -18,5 +18,5 @@ mod pancakes { } pub fn main() { - fail_unless!(pancakes::syrup::foo() == 10); + assert!(pancakes::syrup::foo() == 10); } diff --git a/src/test/run-pass/mod_dir_path3.rs b/src/test/run-pass/mod_dir_path3.rs index 881eac72ebd5f..0971120eb6f7d 100644 --- a/src/test/run-pass/mod_dir_path3.rs +++ b/src/test/run-pass/mod_dir_path3.rs @@ -17,5 +17,5 @@ mod pancakes { } pub fn main() { - fail_unless!(pancakes::test::foo() == 10); + assert!(pancakes::test::foo() == 10); } diff --git a/src/test/run-pass/mod_dir_path_multi.rs b/src/test/run-pass/mod_dir_path_multi.rs index c0019bcfd7c2c..c6ab45d1b3a4d 100644 --- a/src/test/run-pass/mod_dir_path_multi.rs +++ b/src/test/run-pass/mod_dir_path_multi.rs @@ -22,6 +22,6 @@ mod gravy { } pub fn main() { - fail_unless!(biscuits::test::foo() == 10); - fail_unless!(gravy::test::foo() == 10); + assert!(biscuits::test::foo() == 10); + assert!(gravy::test::foo() == 10); } diff --git a/src/test/run-pass/mod_dir_recursive.rs b/src/test/run-pass/mod_dir_recursive.rs index 5c8ae86dfbc18..5392671651d1a 100644 --- a/src/test/run-pass/mod_dir_recursive.rs +++ b/src/test/run-pass/mod_dir_recursive.rs @@ -20,5 +20,5 @@ mod mod_dir_simple { } pub fn main() { - fail_unless!(mod_dir_simple::load_another_mod::test::foo() == 10); + assert!(mod_dir_simple::load_another_mod::test::foo() == 10); } diff --git a/src/test/run-pass/mod_dir_simple.rs b/src/test/run-pass/mod_dir_simple.rs index 0ec7ce8ecc44a..382911d49793f 100644 --- a/src/test/run-pass/mod_dir_simple.rs +++ b/src/test/run-pass/mod_dir_simple.rs @@ -16,5 +16,5 @@ mod mod_dir_simple { } pub fn main() { - fail_unless!(mod_dir_simple::test::foo() == 10); + assert!(mod_dir_simple::test::foo() == 10); } diff --git a/src/test/run-pass/mod_file.rs b/src/test/run-pass/mod_file.rs index 5616945631843..a03dc04401141 100644 --- a/src/test/run-pass/mod_file.rs +++ b/src/test/run-pass/mod_file.rs @@ -15,5 +15,5 @@ mod mod_file_aux; pub fn main() { - fail_unless!(mod_file_aux::foo() == 10); + assert!(mod_file_aux::foo() == 10); } diff --git a/src/test/run-pass/mod_file_with_path_attr.rs b/src/test/run-pass/mod_file_with_path_attr.rs index 0130d62867d73..ecd4fd73a062f 100644 --- a/src/test/run-pass/mod_file_with_path_attr.rs +++ b/src/test/run-pass/mod_file_with_path_attr.rs @@ -16,5 +16,5 @@ mod m; pub fn main() { - fail_unless!(m::foo() == 10); + assert!(m::foo() == 10); } diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index f046adc30b456..303d5bc1b4170 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -40,9 +40,9 @@ fn transform(x: Option) -> Option<~str> { } pub fn main() { - fail_unless!(transform(Some(10)) == Some(~"11")); - fail_unless!(transform(None) == None); - fail_unless!((~[~"hi"]) + assert!(transform(Some(10)) == Some(~"11")); + assert!(transform(None) == None); + assert!((~[~"hi"]) .bind(|x| ~[x.clone(), *x + ~"!"] ) .bind(|x| ~[x.clone(), *x + ~"?"] ) == ~[~"hi", ~"hi?", ~"hi!", ~"hi!?"]); diff --git a/src/test/run-pass/monomorphize-trait-in-fn-at.rs b/src/test/run-pass/monomorphize-trait-in-fn-at.rs index a591c3034d2a5..61d9456296e96 100644 --- a/src/test/run-pass/monomorphize-trait-in-fn-at.rs +++ b/src/test/run-pass/monomorphize-trait-in-fn-at.rs @@ -26,5 +26,5 @@ impl ty_ops for () { pub fn main() { let fn_env: @fn() -> uint = || mk_nil(()); - fail_unless!(fn_env() == 22u); + assert!(fn_env() == 22u); } diff --git a/src/test/run-pass/morestack-address.rs b/src/test/run-pass/morestack-address.rs index 9497ca83eccc0..8089a2dc03476 100644 --- a/src/test/run-pass/morestack-address.rs +++ b/src/test/run-pass/morestack-address.rs @@ -19,7 +19,7 @@ mod rusti { pub fn main() { unsafe { let addr = rusti::morestack_addr(); - fail_unless!(addr.is_not_null()); + assert!(addr.is_not_null()); error!("%?", addr); } } diff --git a/src/test/run-pass/morestack3.rs b/src/test/run-pass/morestack3.rs index de624d22588c7..07edf0d2e1cf4 100644 --- a/src/test/run-pass/morestack3.rs +++ b/src/test/run-pass/morestack3.rs @@ -21,15 +21,15 @@ fn getbig(a0: int, a8: int, a9: int) -> int { - fail_unless!(a0 + 1 == a1); - fail_unless!(a1 + 1 == a2); - fail_unless!(a2 + 1 == a3); - fail_unless!(a3 + 1 == a4); - fail_unless!(a4 + 1 == a5); - fail_unless!(a5 + 1 == a6); - fail_unless!(a6 + 1 == a7); - fail_unless!(a7 + 1 == a8); - fail_unless!(a8 + 1 == a9); + assert!(a0 + 1 == a1); + assert!(a1 + 1 == a2); + assert!(a2 + 1 == a3); + assert!(a3 + 1 == a4); + assert!(a4 + 1 == a5); + assert!(a5 + 1 == a6); + assert!(a6 + 1 == a7); + assert!(a7 + 1 == a8); + assert!(a8 + 1 == a9); if a0 != 0 { let j = getbig(a0 - 1, a1 - 1, @@ -41,7 +41,7 @@ fn getbig(a0: int, a7 - 1, a8 - 1, a9 - 1); - fail_unless!(j == a0 - 1); + assert!(j == a0 - 1); } return a0; } diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs index 06c4586cdfcd1..47902363db7bc 100644 --- a/src/test/run-pass/move-1-unique.rs +++ b/src/test/run-pass/move-1-unique.rs @@ -19,8 +19,8 @@ fn test(x: bool, foo: ~Triple) -> int { pub fn main() { let x = ~Triple{x: 1, y: 2, z: 3}; - fail_unless!((test(true, copy x) == 2)); - fail_unless!((test(true, copy x) == 2)); - fail_unless!((test(true, copy x) == 2)); - fail_unless!((test(false, x) == 5)); + assert!((test(true, copy x) == 2)); + assert!((test(true, copy x) == 2)); + assert!((test(true, copy x) == 2)); + assert!((test(false, x) == 5)); } diff --git a/src/test/run-pass/move-1.rs b/src/test/run-pass/move-1.rs index f7e5758c462b7..04354d74159a4 100644 --- a/src/test/run-pass/move-1.rs +++ b/src/test/run-pass/move-1.rs @@ -19,8 +19,8 @@ fn test(x: bool, foo: @Triple) -> int { pub fn main() { let x = @Triple {x: 1, y: 2, z: 3}; - fail_unless!((test(true, x) == 2)); - fail_unless!((test(true, x) == 2)); - fail_unless!((test(true, x) == 2)); - fail_unless!((test(false, x) == 5)); + assert!((test(true, x) == 2)); + assert!((test(true, x) == 2)); + assert!((test(true, x) == 2)); + assert!((test(false, x) == 5)); } diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs index 08f67a7fa5c82..e3595d4ac9a31 100644 --- a/src/test/run-pass/move-2-unique.rs +++ b/src/test/run-pass/move-2-unique.rs @@ -11,4 +11,4 @@ struct X { x: int, y: int, z: int } -pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = x; fail_unless!((y.y == 2)); } +pub fn main() { let x = ~X{x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); } diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs index 0294ff9973376..fb5f3e11ab705 100644 --- a/src/test/run-pass/move-2.rs +++ b/src/test/run-pass/move-2.rs @@ -11,4 +11,4 @@ struct X { x: int, y: int, z: int } -pub fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = x; fail_unless!((y.y == 2)); } +pub fn main() { let x = @X {x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); } diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs index be6dc8b2004f6..36c9c787b754d 100644 --- a/src/test/run-pass/move-3-unique.rs +++ b/src/test/run-pass/move-3-unique.rs @@ -22,7 +22,7 @@ fn test(x: bool, foo: ~Triple) -> int { pub fn main() { let x = ~Triple{x: 1, y: 2, z: 3}; for uint::range(0u, 10000u) |_i| { - fail_unless!((test(true, copy x) == 2)); + assert!((test(true, copy x) == 2)); } - fail_unless!((test(false, x) == 5)); + assert!((test(false, x) == 5)); } diff --git a/src/test/run-pass/move-3.rs b/src/test/run-pass/move-3.rs index 01d56282d7e93..f2b6b2f998080 100644 --- a/src/test/run-pass/move-3.rs +++ b/src/test/run-pass/move-3.rs @@ -22,7 +22,7 @@ fn test(x: bool, foo: @Triple) -> int { pub fn main() { let x = @Triple{x: 1, y: 2, z: 3}; for uint::range(0u, 10000u) |i| { - fail_unless!((test(true, x) == 2)); + assert!((test(true, x) == 2)); } - fail_unless!((test(false, x) == 5)); + assert!((test(false, x) == 5)); } diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs index 2f393b156eac7..2ed3523ef86ab 100644 --- a/src/test/run-pass/move-4-unique.rs +++ b/src/test/run-pass/move-4-unique.rs @@ -20,4 +20,4 @@ fn test(foo: ~Triple) -> ~Triple { return quux; } -pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); fail_unless!((y.c == 3)); } +pub fn main() { let x = ~Triple{a: 1, b: 2, c: 3}; let y = test(x); assert!((y.c == 3)); } diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs index a1a76040593c1..fe544e54742bd 100644 --- a/src/test/run-pass/move-4.rs +++ b/src/test/run-pass/move-4.rs @@ -24,5 +24,5 @@ fn test(foo: @Triple) -> @Triple { pub fn main() { let x = @Triple{a: 1, b: 2, c: 3}; let y = test(x); - fail_unless!((y.c == 3)); + assert!((y.c == 3)); } diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs index c0adcc8c03cc4..dbc73c20e6b21 100644 --- a/src/test/run-pass/move-arg-2-unique.rs +++ b/src/test/run-pass/move-arg-2-unique.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn test(+foo: ~~[int]) { fail_unless!((foo[0] == 10)); } +fn test(+foo: ~~[int]) { assert!((foo[0] == 10)); } pub fn main() { let x = ~~[10]; diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs index 41a82977175e7..5cc309d1a3ea4 100644 --- a/src/test/run-pass/move-arg-2.rs +++ b/src/test/run-pass/move-arg-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn test(+foo: @~[int]) { fail_unless!((foo[0] == 10)); } +fn test(+foo: @~[int]) { assert!((foo[0] == 10)); } pub fn main() { let x = @~[10]; diff --git a/src/test/run-pass/move-arg.rs b/src/test/run-pass/move-arg.rs index b763317dfe186..ca3a5509c5cfd 100644 --- a/src/test/run-pass/move-arg.rs +++ b/src/test/run-pass/move-arg.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn test(+foo: int) { fail_unless!((foo == 10)); } +fn test(+foo: int) { assert!((foo == 10)); } pub fn main() { let x = 10; test(x); } diff --git a/src/test/run-pass/move-scalar.rs b/src/test/run-pass/move-scalar.rs index 5fdef34b33af6..6a8091d7b770f 100644 --- a/src/test/run-pass/move-scalar.rs +++ b/src/test/run-pass/move-scalar.rs @@ -13,5 +13,5 @@ pub fn main() { let y: int = 42; let mut x: int; x = y; - fail_unless!((x == 42)); + assert!((x == 42)); } diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs index 275fee25d72fc..a7c3c80fba739 100644 --- a/src/test/run-pass/multi-let.rs +++ b/src/test/run-pass/multi-let.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn main() { let x = 10, y = x; fail_unless!((y == 10)); } +pub fn main() { let x = 10, y = x; assert!((y == 10)); } diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs index f61ffc1bc3e00..20813bb4a0335 100644 --- a/src/test/run-pass/mut-function-arguments.rs +++ b/src/test/run-pass/mut-function-arguments.rs @@ -10,11 +10,11 @@ fn f(mut y: ~int) { *y = 5; - fail_unless!(*y == 5); + assert!(*y == 5); } fn g() { - let frob: &fn(~int) = |mut q| { *q = 2; fail_unless!(*q == 2); }; + let frob: &fn(~int) = |mut q| { *q = 2; assert!(*q == 2); }; let w = ~37; frob(w); diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index d63f1b40dc863..c4caf716df239 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -11,13 +11,13 @@ fn test1() { let mut ints = [0, ..32]; ints[0] += 1; - fail_unless!(ints[0] == 1); + assert!(ints[0] == 1); } fn test2() { let mut ints = [0, ..32]; for vec::each_mut(ints) |i| { *i += 22; } - for ints.each |i| { fail_unless!(*i == 22); } + for ints.each |i| { assert!(*i == 22); } } pub fn main() { diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index e08bd5f85a965..c6bf07536b1a9 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::(v); debug!(len); - fail_unless!((len == 3 as uint)); + assert!((len == 3 as uint)); } diff --git a/src/test/run-pass/nested-class.rs b/src/test/run-pass/nested-class.rs index 6447d46ad896a..44348223b605d 100644 --- a/src/test/run-pass/nested-class.rs +++ b/src/test/run-pass/nested-class.rs @@ -27,7 +27,7 @@ pub fn main() { // fn b(x:int) -> int { fail!(); } let z = b(42); - fail_unless!((z.i == 42)); - fail_unless!((z.do_stuff() == 37)); + assert!((z.i == 42)); + assert!((z.do_stuff() == 37)); } diff --git a/src/test/run-pass/nested-patterns.rs b/src/test/run-pass/nested-patterns.rs index 9da3f44fc6deb..6c56e39d2d308 100644 --- a/src/test/run-pass/nested-patterns.rs +++ b/src/test/run-pass/nested-patterns.rs @@ -15,13 +15,13 @@ struct C { c: int } pub fn main() { match A {a: 10, b: @20} { - x@A {a, b: @20} => { fail_unless!(x.a == 10); fail_unless!(a == 10); } + x@A {a, b: @20} => { assert!(x.a == 10); assert!(a == 10); } A {b, _} => { fail!(); } } let mut x@B {b, _} = B {a: 10, b: C {c: 20}}; x.b.c = 30; - fail_unless!(b.c == 20); + assert!(b.c == 20); let mut y@D {d, _} = D {a: 10, d: C {c: 20}}; y.d.c = 30; - fail_unless!(d.c == 20); + assert!(d.c == 20); } diff --git a/src/test/run-pass/newlambdas.rs b/src/test/run-pass/newlambdas.rs index 076e019bab46d..1fb98d54adc7a 100644 --- a/src/test/run-pass/newlambdas.rs +++ b/src/test/run-pass/newlambdas.rs @@ -19,11 +19,11 @@ fn ff() -> @fn(int) -> int { } pub fn main() { - fail_unless!(f(10, |a| a) == 10); + assert!(f(10, |a| a) == 10); g(||()); - fail_unless!(do f(10) |a| { a } == 10); + assert!(do f(10) |a| { a } == 10); do g() { } let _x: @fn() -> int = || 10; let _y: @fn(int) -> int = |a| a; - fail_unless!(ff()(10) == 11); + assert!(ff()(10) == 11); } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 18132d15d5787..6b1b97cfd5f82 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -16,7 +16,7 @@ fn myvec_elt(mv: myvec) -> X { return mv[0]; } pub fn main() { let mv = myvec(~[1, 2, 3]); - fail_unless!((myvec_deref(copy mv)[1] == 2)); - fail_unless!((myvec_elt(copy mv) == 1)); - fail_unless!((mv[2] == 3)); + assert!((myvec_deref(copy mv)[1] == 2)); + assert!((myvec_elt(copy mv) == 1)); + assert!((mv[2] == 3)); } diff --git a/src/test/run-pass/newtype.rs b/src/test/run-pass/newtype.rs index 6a82f70d9158a..ad2c502f20e93 100644 --- a/src/test/run-pass/newtype.rs +++ b/src/test/run-pass/newtype.rs @@ -17,5 +17,5 @@ fn compute(i: mytype) -> int { return i.val + 20; } pub fn main() { let myval = mytype(Mytype{compute: compute, val: 30}); io::println(fmt!("%d", compute(myval))); - fail_unless!(((myval.compute)(myval) == 50)); + assert!(((myval.compute)(myval) == 50)); } diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs index ae241e458fc15..6a76f9d1646d4 100644 --- a/src/test/run-pass/non-boolean-pure-fns.rs +++ b/src/test/run-pass/non-boolean-pure-fns.rs @@ -23,12 +23,12 @@ fn pure_length(ls: @List) -> uint { pure_length_go(ls, 0u) } fn nonempty_list(ls: @List) -> bool { pure_length(ls) > 0u } fn safe_head(ls: @List) -> T { - fail_unless!(!is_empty(ls)); + assert!(!is_empty(ls)); return head(ls); } pub fn main() { let mylist = @Cons(@1u, @Nil); - fail_unless!((nonempty_list(mylist))); - fail_unless!((*safe_head(mylist) == 1u)); + assert!((nonempty_list(mylist))); + assert!((*safe_head(mylist) == 1u)); } diff --git a/src/test/run-pass/non-legacy-modes.rs b/src/test/run-pass/non-legacy-modes.rs index 330a9b9de7b8f..69feae49157cb 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(x: T, f: &fn(T)) { } fn check_int(x: int) { - fail_unless!(x == 22); + assert!(x == 22); } fn check_struct(x: X) { diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs index cda68d72ed626..6a92c1c993c23 100644 --- a/src/test/run-pass/nullary-or-pattern.rs +++ b/src/test/run-pass/nullary-or-pattern.rs @@ -15,6 +15,6 @@ fn or_alt(q: blah) -> int { } pub fn main() { - fail_unless!((or_alt(a) == 42)); - fail_unless!((or_alt(b) == 42)); + assert!((or_alt(a) == 42)); + assert!((or_alt(b) == 42)); } diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index 714852dbb86e9..719f1015684a1 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -17,26 +17,26 @@ pub fn main() { // ints // num - fail_unless!(15i.add(&6) == 21); - fail_unless!(15i8.add(&6i8) == 21i8); - fail_unless!(15i16.add(&6i16) == 21i16); - fail_unless!(15i32.add(&6i32) == 21i32); - fail_unless!(15i64.add(&6i64) == 21i64); + assert!(15i.add(&6) == 21); + assert!(15i8.add(&6i8) == 21i8); + assert!(15i16.add(&6i16) == 21i16); + assert!(15i32.add(&6i32) == 21i32); + assert!(15i64.add(&6i64) == 21i64); // uints // num - fail_unless!(15u.add(&6u) == 21u); - fail_unless!(15u8.add(&6u8) == 21u8); - fail_unless!(15u16.add(&6u16) == 21u16); - fail_unless!(15u32.add(&6u32) == 21u32); - fail_unless!(15u64.add(&6u64) == 21u64); + assert!(15u.add(&6u) == 21u); + assert!(15u8.add(&6u8) == 21u8); + assert!(15u16.add(&6u16) == 21u16); + assert!(15u32.add(&6u32) == 21u32); + assert!(15u64.add(&6u64) == 21u64); // times 15u.times(|| false); // floats // num - fail_unless!(10f.to_int() == 10); - fail_unless!(10f32.to_int() == 10); - fail_unless!(10f64.to_int() == 10); + assert!(10f.to_int() == 10); + assert!(10f32.to_int() == 10); + assert!(10f64.to_int() == 10); } diff --git a/src/test/run-pass/one-tuple.rs b/src/test/run-pass/one-tuple.rs index 0e483390beec9..2efa0b98b6a27 100644 --- a/src/test/run-pass/one-tuple.rs +++ b/src/test/run-pass/one-tuple.rs @@ -13,12 +13,12 @@ pub fn main() { match ('c',) { (x,) => { - fail_unless!(x == 'c'); + assert!(x == 'c'); } } // test the 1-tuple type too let x: (char,) = ('d',); let (y,) = x; - fail_unless!(y == 'd'); + assert!(y == 'd'); } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index 98bec28e398a2..004aa864f99da 100644 --- a/src/test/run-pass/opeq.rs +++ b/src/test/run-pass/opeq.rs @@ -16,14 +16,14 @@ pub fn main() { let mut x: int = 1; x *= 2; debug!(x); - fail_unless!((x == 2)); + assert!((x == 2)); x += 3; debug!(x); - fail_unless!((x == 5)); + assert!((x == 5)); x *= x; debug!(x); - fail_unless!((x == 25)); + assert!((x == 25)); x /= 5; debug!(x); - fail_unless!((x == 5)); + assert!((x == 5)); } diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs index a1af35be65325..bee6d23a27d62 100644 --- a/src/test/run-pass/operator-associativity.rs +++ b/src/test/run-pass/operator-associativity.rs @@ -12,4 +12,4 @@ // Testcase for issue #130, operator associativity. -pub fn main() { fail_unless!((3 * 5 / 2 == 7)); } +pub fn main() { assert!((3 * 5 / 2 == 7)); } diff --git a/src/test/run-pass/operator-overloading.rs b/src/test/run-pass/operator-overloading.rs index 6f479140d73ae..ffd6903d7f7a4 100644 --- a/src/test/run-pass/operator-overloading.rs +++ b/src/test/run-pass/operator-overloading.rs @@ -56,14 +56,14 @@ pub fn main() { let mut p = Point {x: 10, y: 20}; p += Point {x: 101, y: 102}; p = p - Point {x: 100, y: 100}; - fail_unless!(p + Point {x: 5, y: 5} == Point {x: 16, y: 27}); - fail_unless!(-p == Point {x: -11, y: -22}); - fail_unless!(p[true] == 11); - fail_unless!(p[false] == 22); + assert!(p + Point {x: 5, y: 5} == Point {x: 16, y: 27}); + assert!(-p == Point {x: -11, y: -22}); + assert!(p[true] == 11); + assert!(p[false] == 22); let q = !p; - fail_unless!(q.x == !(p.x)); - fail_unless!(q.y == !(p.y)); + assert!(q.x == !(p.x)); + assert!(q.y == !(p.y)); // Issue #1733 let result: ~fn(int) = |_|(); diff --git a/src/test/run-pass/option-unwrap.rs b/src/test/run-pass/option-unwrap.rs index 207428c2cec78..0efed2708f485 100644 --- a/src/test/run-pass/option-unwrap.rs +++ b/src/test/run-pass/option-unwrap.rs @@ -38,5 +38,5 @@ pub fn main() { let c = unwrap(b); } - fail_unless!(*x == 0); + assert!(*x == 0); } diff --git a/src/test/run-pass/option_addition.rs b/src/test/run-pass/option_addition.rs index f42d3054e5c07..0bd61d1a67d89 100644 --- a/src/test/run-pass/option_addition.rs +++ b/src/test/run-pass/option_addition.rs @@ -22,9 +22,9 @@ pub fn main() { None => (), Some(foo) => fail!(fmt!("expected None, but found %?", foo)) } - fail_unless!(foo == somefoo.get()); - fail_unless!(bar == somebar.get()); - fail_unless!(foobar == somefoobar.get()); + assert!(foo == somefoo.get()); + assert!(bar == somebar.get()); + assert!(foobar == somefoobar.get()); } fn optint(in: int) -> Option { diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs index c787b8dbbf2d4..93d51ab7e8b8b 100644 --- a/src/test/run-pass/or-pattern.rs +++ b/src/test/run-pass/or-pattern.rs @@ -15,7 +15,7 @@ fn or_alt(q: blah) -> int { } pub fn main() { - fail_unless!((or_alt(c) == 0)); - fail_unless!((or_alt(a(10, 100, 0u)) == 110)); - fail_unless!((or_alt(b(20, 200)) == 220)); + assert!((or_alt(c) == 0)); + assert!((or_alt(a(10, 100, 0u)) == 110)); + assert!((or_alt(b(20, 200)) == 220)); } diff --git a/src/test/run-pass/overload-index-operator.rs b/src/test/run-pass/overload-index-operator.rs index 7d1d0c6be0e5e..3030bedccccc2 100644 --- a/src/test/run-pass/overload-index-operator.rs +++ b/src/test/run-pass/overload-index-operator.rs @@ -47,9 +47,9 @@ pub fn main() { list.push(copy foo, 22); list.push(copy bar, 44); - fail_unless!(list[foo] == 22) - fail_unless!(list[bar] == 44) + assert!(list[foo] == 22) + assert!(list[bar] == 44) - fail_unless!(list[foo] == 22) - fail_unless!(list[bar] == 44) + assert!(list[foo] == 22) + assert!(list[bar] == 44) } \ No newline at end of file diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs index a60a761e27727..63d9ec17ccb5e 100644 --- a/src/test/run-pass/pattern-bound-var-in-for-each.rs +++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs @@ -18,7 +18,7 @@ fn foo(src: uint) { Some(src_id) => { for uint::range(0u, 10u) |i| { let yyy = src_id; - fail_unless!((yyy == 0u)); + assert!((yyy == 0u)); } } _ => { } diff --git a/src/test/run-pass/pipe-peek.rs b/src/test/run-pass/pipe-peek.rs index 4058e5a492d63..46fbb88aef2e1 100644 --- a/src/test/run-pass/pipe-peek.rs +++ b/src/test/run-pass/pipe-peek.rs @@ -24,9 +24,9 @@ proto! oneshot ( pub fn main() { let (c, p) = oneshot::init(); - fail_unless!(!pipes::peek(&p)); + assert!(!pipes::peek(&p)); oneshot::client::signal(c); - fail_unless!(pipes::peek(&p)); + assert!(pipes::peek(&p)); } diff --git a/src/test/run-pass/pipe-select.rs b/src/test/run-pass/pipe-select.rs index 0c80fdb3a3409..221ecbfcf02e5 100644 --- a/src/test/run-pass/pipe-select.rs +++ b/src/test/run-pass/pipe-select.rs @@ -48,7 +48,7 @@ pub fn main() { error!("selecting"); let (i, _, _) = select(~[left, right]); error!("selected"); - fail_unless!(i == 0); + assert!(i == 0); error!("waiting for pipes"); let stream::send(x, _) = recv(p); @@ -60,7 +60,7 @@ pub fn main() { let (i, m, _) = select(~[left, right]); error!("selected %?", i); if m.is_some() { - fail_unless!(i == 1); + assert!(i == 1); } }); diff --git a/src/test/run-pass/placement-new-arena.rs b/src/test/run-pass/placement-new-arena.rs index cbee1801768dc..12c804219328e 100644 --- a/src/test/run-pass/placement-new-arena.rs +++ b/src/test/run-pass/placement-new-arena.rs @@ -17,5 +17,5 @@ pub fn main() { let p = &arena::Arena(); let x = p.alloc(|| 4u); io::print(fmt!("%u", *x)); - fail_unless!(*x == 4u); + assert!(*x == 4u); } diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs index cb92125c5d88b..75f933ac769b0 100644 --- a/src/test/run-pass/private-class-field.rs +++ b/src/test/run-pass/private-class-field.rs @@ -27,5 +27,5 @@ fn cat(in_x : uint, in_y : int) -> cat { pub fn main() { let mut nyan : cat = cat(52u, 99); - fail_unless!((nyan.meow_count() == 52u)); + assert!((nyan.meow_count() == 52u)); } diff --git a/src/test/run-pass/propagate-expected-type-through-block.rs b/src/test/run-pass/propagate-expected-type-through-block.rs index c68771e4a949c..aeeae0da9e34a 100644 --- a/src/test/run-pass/propagate-expected-type-through-block.rs +++ b/src/test/run-pass/propagate-expected-type-through-block.rs @@ -8,5 +8,5 @@ pub fn main() { let y = y.clone(); |x| *x + *y }; - fail_unless!(foo(@22) == 25); + assert!(foo(@22) == 25); } diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs index f9a132f8a2c00..04f86fdad01fd 100644 --- a/src/test/run-pass/rcvr-borrowed-to-region.rs +++ b/src/test/run-pass/rcvr-borrowed-to-region.rs @@ -26,26 +26,26 @@ pub fn main() { /* let x = @mut 6; let y = x.get(); - fail_unless!(y == 6); + assert!(y == 6); */ let x = @6; let y = x.get(); debug!("y=%d", y); - fail_unless!(y == 6); + assert!(y == 6); let mut x = ~6; let y = x.get(); debug!("y=%d", y); - fail_unless!(y == 6); + assert!(y == 6); let x = ~6; let y = x.get(); debug!("y=%d", y); - fail_unless!(y == 6); + assert!(y == 6); let x = &6; let y = x.get(); debug!("y=%d", y); - fail_unless!(y == 6); + assert!(y == 6); } diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs index fc62ea67eab21..483a2ee25e5d5 100644 --- a/src/test/run-pass/rcvr-borrowed-to-slice.rs +++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs @@ -27,15 +27,15 @@ pub fn main() { let x = ~[1, 2, 3]; let y = call_sum(x); debug!("y==%d", y); - fail_unless!(y == 6); + assert!(y == 6); let mut x = ~[1, 2, 3]; let y = x.sum(); debug!("y==%d", y); - fail_unless!(y == 6); + assert!(y == 6); let x = ~[1, 2, 3]; let y = x.sum(); debug!("y==%d", y); - fail_unless!(y == 6); + assert!(y == 6); } diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs index b532763832753..7447073b47cfd 100644 --- a/src/test/run-pass/readalias.rs +++ b/src/test/run-pass/readalias.rs @@ -14,6 +14,6 @@ // -*- rust -*- struct Point {x: int, y: int, z: int} -fn f(p: Point) { fail_unless!((p.z == 12)); } +fn f(p: Point) { assert!((p.z == 12)); } pub fn main() { let x: Point = Point {x: 10, y: 11, z: 12}; f(x); } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index e5a13fe9c540a..5cf978b5b6044 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -55,12 +55,12 @@ pub fn main() { debug!("y = %s", y); // per clang/gcc the alignment of `inner` is 4 on x86. - fail_unless!(rusti::min_align_of::() == m::align()); + assert!(rusti::min_align_of::() == m::align()); // per clang/gcc the size of `outer` should be 12 // because `inner`s alignment was 4. - fail_unless!(sys::size_of::() == m::size()); + assert!(sys::size_of::() == m::size()); - fail_unless!(y == ~"{c8: 22, t: {c64: 44}}"); + assert!(y == ~"{c8: 22, t: {c64: 44}}"); } } diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index e02a1edf8a62d..cd4c864042441 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -69,12 +69,12 @@ pub fn main() { debug!("y = %s", y); // per clang/gcc the alignment of `Inner` is 4 on x86. - fail_unless!(rusti::min_align_of::() == m::m::align()); + assert!(rusti::min_align_of::() == m::m::align()); // per clang/gcc the size of `Outer` should be 12 // because `Inner`s alignment was 4. - fail_unless!(sys::size_of::() == m::m::size()); + assert!(sys::size_of::() == m::m::size()); - fail_unless!(y == ~"{c8: 22, t: {c64: 44}}"); + assert!(y == ~"{c8: 22, t: {c64: 44}}"); } } diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs index a15c8e07a2f4b..c352c06247b03 100644 --- a/src/test/run-pass/rec-extend.rs +++ b/src/test/run-pass/rec-extend.rs @@ -18,10 +18,10 @@ pub fn main() { let origin: Point = Point {x: 0, y: 0}; let right: Point = Point {x: origin.x + 10,.. origin}; let up: Point = Point {y: origin.y + 10,.. origin}; - fail_unless!((origin.x == 0)); - fail_unless!((origin.y == 0)); - fail_unless!((right.x == 10)); - fail_unless!((right.y == 0)); - fail_unless!((up.x == 0)); - fail_unless!((up.y == 10)); + assert!((origin.x == 0)); + assert!((origin.y == 0)); + assert!((right.x == 10)); + assert!((right.y == 0)); + assert!((up.x == 0)); + assert!((up.y == 10)); } diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs index f6bee49347830..46fb619fd8015 100644 --- a/src/test/run-pass/rec-tup.rs +++ b/src/test/run-pass/rec-tup.rs @@ -17,21 +17,21 @@ fn fst(r: rect) -> Point { let (fst, _) = r; return fst; } fn snd(r: rect) -> Point { let (_, snd) = r; return snd; } fn f(r: rect, x1: int, y1: int, x2: int, y2: int) { - fail_unless!((fst(r).x == x1)); - fail_unless!((fst(r).y == y1)); - fail_unless!((snd(r).x == x2)); - fail_unless!((snd(r).y == y2)); + assert!((fst(r).x == x1)); + assert!((fst(r).y == y1)); + assert!((snd(r).x == x2)); + assert!((snd(r).y == y2)); } pub fn main() { let r: rect = (Point {x: 10, y: 20}, Point {x: 11, y: 22}); - fail_unless!((fst(r).x == 10)); - fail_unless!((fst(r).y == 20)); - fail_unless!((snd(r).x == 11)); - fail_unless!((snd(r).y == 22)); + assert!((fst(r).x == 10)); + assert!((fst(r).y == 20)); + assert!((snd(r).x == 11)); + assert!((snd(r).y == 22)); let r2 = r; let x: int = fst(r2).x; - fail_unless!((x == 10)); + assert!((x == 10)); f(r, 10, 20, 11, 22); f(r2, 10, 20, 11, 22); } diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs index 3dd35a3f5196e..9d9322f7f3dd7 100644 --- a/src/test/run-pass/rec.rs +++ b/src/test/run-pass/rec.rs @@ -15,21 +15,21 @@ struct Rect {x: int, y: int, w: int, h: int} fn f(r: Rect, x: int, y: int, w: int, h: int) { - fail_unless!((r.x == x)); - fail_unless!((r.y == y)); - fail_unless!((r.w == w)); - fail_unless!((r.h == h)); + assert!((r.x == x)); + assert!((r.y == y)); + assert!((r.w == w)); + assert!((r.h == h)); } pub fn main() { let r: Rect = Rect {x: 10, y: 20, w: 100, h: 200}; - fail_unless!((r.x == 10)); - fail_unless!((r.y == 20)); - fail_unless!((r.w == 100)); - fail_unless!((r.h == 200)); + assert!((r.x == 10)); + assert!((r.y == 20)); + assert!((r.w == 100)); + assert!((r.h == 200)); let r2: Rect = r; let x: int = r2.x; - fail_unless!((x == 10)); + assert!((x == 10)); f(r, 10, 20, 100, 200); f(r2, 10, 20, 100, 200); } diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs index 40d99fa805ca5..0019f1dc23b3f 100644 --- a/src/test/run-pass/record-pat.rs +++ b/src/test/run-pass/record-pat.rs @@ -20,6 +20,6 @@ fn m(in: t3) -> int { } pub fn main() { - fail_unless!((m(c(T2 {x: a(10), y: 5}, 4u)) == 10)); - fail_unless!((m(c(T2 {x: b(10u), y: 5}, 4u)) == 19)); + assert!((m(c(T2 {x: a(10), y: 5}, 4u)) == 10)); + assert!((m(c(T2 {x: b(10u), y: 5}, 4u)) == 19)); } diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index 8e363c3d5db53..565c06fb8c890 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -651,7 +651,7 @@ pub fn main() { io::println(fmt!("val: %s", *s)); } error!("%?", u.vals.clone()); - fail_unless!(u.vals == ~[ + assert!(u.vals == ~[ ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12" ]); } diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs index 6576a6c3fa975..8a7fef9561441 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -153,6 +153,6 @@ pub fn main() { for (v.types.clone()).each {|s| io::println(fmt!("type: %s", s)); } - fail_unless!(v.types == ["bool", "int", "i8", "i16", + assert!(v.types == ["bool", "int", "i8", "i16", "[", "int", "]"]); } diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs index e7edeca3b9a19..42784200b6639 100644 --- a/src/test/run-pass/region-dependent-addr-of.rs +++ b/src/test/run-pass/region-dependent-addr-of.rs @@ -87,29 +87,29 @@ pub fn main() { v6: Some(C { f: 31 })}}; let p = get_v1(&a); - fail_unless!(*p == a.value.v1); + assert!(*p == a.value.v1); let p = get_v2(&a, 1); - fail_unless!(*p == a.value.v2[1]); + assert!(*p == a.value.v2[1]); let p = get_v3(&a, 1); - fail_unless!(*p == a.value.v3[1]); + assert!(*p == a.value.v3[1]); let p = get_v4(&a, 1); - fail_unless!(*p == a.value.v4.f); + assert!(*p == a.value.v4.f); let p = get_v5(&a, 1); - fail_unless!(*p == a.value.v5.f); + assert!(*p == a.value.v5.f); let p = get_v6_a(&a, 1); - fail_unless!(*p == a.value.v6.get().f); + assert!(*p == a.value.v6.get().f); let p = get_v6_b(&a, 1); - fail_unless!(*p == a.value.v6.get().f); + assert!(*p == a.value.v6.get().f); let p = get_v6_c(&a, 1); - fail_unless!(*p == a.value.v6.get().f); + assert!(*p == a.value.v6.get().f); let p = get_v5_ref(&a, 1); - fail_unless!(*p == a.value.v5.f); + assert!(*p == a.value.v5.f); } diff --git a/src/test/run-pass/region-return-interior-of-option.rs b/src/test/run-pass/region-return-interior-of-option.rs index 5fd3da67a1779..45090e908bbec 100644 --- a/src/test/run-pass/region-return-interior-of-option.rs +++ b/src/test/run-pass/region-return-interior-of-option.rs @@ -20,13 +20,13 @@ pub fn main() { { let y = get(&x); - fail_unless!(*y == 23); + assert!(*y == 23); } x = Some(24); { let y = get(&x); - fail_unless!(*y == 24); + assert!(*y == 24); } } diff --git a/src/test/run-pass/regions-appearance-constraint.rs b/src/test/run-pass/regions-appearance-constraint.rs index aa2e25986973d..cfe721612e1e2 100644 --- a/src/test/run-pass/regions-appearance-constraint.rs +++ b/src/test/run-pass/regions-appearance-constraint.rs @@ -25,7 +25,7 @@ fn testfn(cond: bool) { x = @5; y = @6; - fail_unless!(*a == exp); + assert!(*a == exp); } pub fn main() { diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs index 8ef3eaf41fecd..f12c80c2e8841 100644 --- a/src/test/run-pass/regions-borrow-at.rs +++ b/src/test/run-pass/regions-borrow-at.rs @@ -16,5 +16,5 @@ pub fn main() { let p = @22u; let r = foo(p); debug!("r=%u", r); - fail_unless!(r == 22u); + assert!(r == 22u); } diff --git a/src/test/run-pass/regions-borrow-estr-uniq.rs b/src/test/run-pass/regions-borrow-estr-uniq.rs index 7edc0879101dc..18082e857514f 100644 --- a/src/test/run-pass/regions-borrow-estr-uniq.rs +++ b/src/test/run-pass/regions-borrow-estr-uniq.rs @@ -15,9 +15,9 @@ fn foo(x: &str) -> u8 { pub fn main() { let p = ~"hello"; let r = foo(p); - fail_unless!(r == 'h' as u8); + assert!(r == 'h' as u8); let p = ~"hello"; let r = foo(p); - fail_unless!(r == 'h' as u8); + assert!(r == 'h' as u8); } diff --git a/src/test/run-pass/regions-borrow-evec-at.rs b/src/test/run-pass/regions-borrow-evec-at.rs index b3c62fb0eadd0..3247f9df30d87 100644 --- a/src/test/run-pass/regions-borrow-evec-at.rs +++ b/src/test/run-pass/regions-borrow-evec-at.rs @@ -17,5 +17,5 @@ fn foo(x: &[uint]) -> uint { pub fn main() { let p = @[22u]; let r = foo(p); - fail_unless!(r == 22u); + assert!(r == 22u); } diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs index 010daac8cc133..557b66735c016 100644 --- a/src/test/run-pass/regions-borrow-evec-fixed.rs +++ b/src/test/run-pass/regions-borrow-evec-fixed.rs @@ -16,5 +16,5 @@ fn foo(x: &[int]) -> int { pub fn main() { let p = [1,2,3,4,5]; - fail_unless!(foo(p) == 1); + assert!(foo(p) == 1); } diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs index d55caa9b46ee9..80ea1bb452daa 100644 --- a/src/test/run-pass/regions-borrow-evec-uniq.rs +++ b/src/test/run-pass/regions-borrow-evec-uniq.rs @@ -15,9 +15,9 @@ fn foo(x: &[int]) -> int { pub fn main() { let p = ~[1,2,3,4,5]; let r = foo(p); - fail_unless!(r == 1); + assert!(r == 1); let p = ~[5,4,3,2,1]; let r = foo(p); - fail_unless!(r == 5); + assert!(r == 5); } diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs index a2d06b6e23bf3..e59352667c2a1 100644 --- a/src/test/run-pass/regions-borrow-uniq.rs +++ b/src/test/run-pass/regions-borrow-uniq.rs @@ -15,5 +15,5 @@ fn foo(x: &uint) -> uint { pub fn main() { let p = ~3u; let r = foo(p); - fail_unless!(r == 3u); + assert!(r == 3u); } diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs index 54cfb5f5fcc75..308528ef57200 100644 --- a/src/test/run-pass/regions-copy-closure.rs +++ b/src/test/run-pass/regions-copy-closure.rs @@ -19,7 +19,7 @@ fn box_it<'r>(+x: &'r fn()) -> closure_box<'r> { pub fn main() { let mut i = 3; let cl_box = box_it(|| i += 1); - fail_unless!(i == 3); + assert!(i == 3); (cl_box.cl)(); - fail_unless!(i == 4); + assert!(i == 4); } diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index d9e5831024615..22b98726fb1a9 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -13,5 +13,5 @@ fn bar(x: &uint) -> uint { *x } pub fn main() { let p = @3u; - fail_unless!(bar(foo(p)) == 3); + assert!(bar(foo(p)) == 3); } diff --git a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs index 619a79b1ab556..ee2682ff4ab93 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs @@ -20,7 +20,7 @@ pub fn main() { match i { i => { let y = &x; - fail_unless!(i < *y); + assert!(i < *y); } } let mut y = 4; diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs index 7c970253b98ab..9358ea8a77724 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-view.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs @@ -14,6 +14,6 @@ pub fn main() { let v = ~[1, 2, 3]; let x = view(v); let y = view(x); - fail_unless!((v[0] == x[0]) && (v[0] == y[0])); + assert!((v[0] == x[0]) && (v[0] == y[0])); } diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index a184f47b65f57..08c54c790b1f0 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -14,7 +14,7 @@ pub fn main() { let x = @3; loop { let y = borrow(x); - fail_unless!(*x == *y); + assert!(*x == *y); break; } } diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index a3cb1e32eb5e6..e06a2fea1c194 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -17,6 +17,6 @@ fn x_coord<'r>(p: &'r Point) -> &'r int { pub fn main() { let p = @Point {x: 3, y: 4}; let xc = x_coord(p); - fail_unless!(*xc == 3); + assert!(*xc == 3); } diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs index 9933d55f7476e..2772660ff83ce 100644 --- a/src/test/run-pass/regions-infer-call-2.rs +++ b/src/test/run-pass/regions-infer-call-2.rs @@ -19,5 +19,5 @@ fn has_one<'a>(x: &'a int) -> int { } pub fn main() { - fail_unless!(has_one(&2) == 22); + assert!(has_one(&2) == 22); } diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs index e83f11de31d12..39dec6c81334f 100644 --- a/src/test/run-pass/regions-infer-call.rs +++ b/src/test/run-pass/regions-infer-call.rs @@ -15,5 +15,5 @@ fn has_two<'a,'b>(x: &'a int, y: &'b int) -> int { } pub fn main() { - fail_unless!(has_two(&20, &2) == 22); + assert!(has_two(&20, &2) == 22); } diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs index d45925229fa7c..46581e4f3d075 100644 --- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs +++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs @@ -24,5 +24,5 @@ fn with(bi: &boxed_int) -> int { pub fn main() { let g = 21; let foo = boxed_int { f: &g }; - fail_unless!(with(&foo) == 22); + assert!(with(&foo) == 22); } diff --git a/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs b/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs index cef3e6e824338..346a0fcfe0793 100644 --- a/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs +++ b/src/test/run-pass/regions-parameterization-self-types-issue-5224.rs @@ -34,5 +34,5 @@ fn get_int(g: &G) -> int { pub fn main() { let foo = Foo { field: 22 }; - fail_unless!(get_int(&foo) == 22); + assert!(get_int(&foo) == 22); } diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs index cc5b89405aac9..8a8147e42d959 100644 --- a/src/test/run-pass/regions-params.rs +++ b/src/test/run-pass/regions-params.rs @@ -23,5 +23,5 @@ fn parameterized(x: &uint) -> uint { pub fn main() { let x = 3u; - fail_unless!(parameterized(&x) == 3u); + assert!(parameterized(&x) == 3u); } diff --git a/src/test/run-pass/regions-trait.rs b/src/test/run-pass/regions-trait.rs index 92ef18967b361..f453272057975 100644 --- a/src/test/run-pass/regions-trait.rs +++ b/src/test/run-pass/regions-trait.rs @@ -30,5 +30,5 @@ pub fn main() { let ctxt = Ctxt { v: 22 }; let hc = HasCtxt { c: &ctxt }; - fail_unless!(get_v(@hc as @get_ctxt) == 22); + assert!(get_v(@hc as @get_ctxt) == 22); } diff --git a/src/test/run-pass/resolve-issue-2428.rs b/src/test/run-pass/resolve-issue-2428.rs index 799db4ed2125a..6d00210898bd0 100644 --- a/src/test/run-pass/resolve-issue-2428.rs +++ b/src/test/run-pass/resolve-issue-2428.rs @@ -12,4 +12,4 @@ static foo: int = 4 >> 1; enum bs { thing = foo } -pub fn main() { fail_unless!((thing as int == foo)); } +pub fn main() { assert!((thing as int == foo)); } diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs index 7d9c01cd2e34f..68ec3fc4d42e0 100644 --- a/src/test/run-pass/resource-assign-is-not-copy.rs +++ b/src/test/run-pass/resource-assign-is-not-copy.rs @@ -36,5 +36,5 @@ pub fn main() { let (c, _d) = b; debug!(c); } - fail_unless!(*i == 1); + assert!(*i == 1); } diff --git a/src/test/run-pass/resource-destruct.rs b/src/test/run-pass/resource-destruct.rs index cc9a27fd9e4d1..1fcf677a0b3dd 100644 --- a/src/test/run-pass/resource-destruct.rs +++ b/src/test/run-pass/resource-destruct.rs @@ -33,7 +33,7 @@ fn shrinky_pointer(i: @@mut int) -> shrinky_pointer { pub fn main() { let my_total = @@mut 10; - { let pt = shrinky_pointer(my_total); fail_unless!((pt.look_at() == 10)); } + { let pt = shrinky_pointer(my_total); assert!((pt.look_at() == 10)); } error!("my_total = %d", **my_total); - fail_unless!((**my_total == 9)); + assert!((**my_total == 9)); } diff --git a/src/test/run-pass/resource-generic.rs b/src/test/run-pass/resource-generic.rs index 4ce6a37956c52..8a1835d6585fa 100644 --- a/src/test/run-pass/resource-generic.rs +++ b/src/test/run-pass/resource-generic.rs @@ -36,5 +36,5 @@ pub fn main() { fn dec_box(i: @mut int) { *i -= 1; } { let _i = finish(Arg{val: box, fin: dec_box}); } - fail_unless!((*box == 9)); + assert!((*box == 9)); } diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs index 9eb680ed7cc03..d74ec61d3c074 100644 --- a/src/test/run-pass/resource-in-struct.rs +++ b/src/test/run-pass/resource-in-struct.rs @@ -41,5 +41,5 @@ pub fn main() { let c = @mut true; sink(none); sink(some(close_res(c))); - fail_unless!((!*c)); + assert!((!*c)); } diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs index 6fe5831644fdc..ab61cee422300 100644 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ b/src/test/run-pass/ret-break-cont-in-block.rs @@ -33,11 +33,11 @@ fn bail_deep(x: ~[~[bool]]) { let mut seen = false; for iter(x.clone()) |x| { for iter(x.clone()) |x| { - fail_unless!(!seen); + assert!(!seen); if *x { seen = true; return; } } } - fail_unless!(!seen); + assert!(!seen); } fn ret_deep() -> ~str { @@ -55,17 +55,17 @@ pub fn main() { last = *e; if *e == 5 { break; } if *e % 2 == 1 { loop; } - fail_unless!(*e % 2 == 0); + assert!(*e % 2 == 0); }; - fail_unless!(last == 5); + assert!(last == 5); - fail_unless!(find_pos(1, ~[0, 1, 2, 3]) == Some(1u)); - fail_unless!(find_pos(1, ~[0, 4, 2, 3]) == None); - fail_unless!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == Some(3u)); + assert!(find_pos(1, ~[0, 1, 2, 3]) == Some(1u)); + assert!(find_pos(1, ~[0, 4, 2, 3]) == None); + assert!(find_pos(~"hi", ~[~"foo", ~"bar", ~"baz", ~"hi"]) == Some(3u)); bail_deep(~[~[false, false], ~[true, true], ~[false, true]]); bail_deep(~[~[true]]); bail_deep(~[~[false, false, false]]); - fail_unless!(ret_deep() == ~"hi"); + assert!(ret_deep() == ~"hi"); } diff --git a/src/test/run-pass/rt-sched-1.rs b/src/test/run-pass/rt-sched-1.rs index cb0a531929a1d..8bf5627b4cd49 100644 --- a/src/test/run-pass/rt-sched-1.rs +++ b/src/test/run-pass/rt-sched-1.rs @@ -38,13 +38,13 @@ pub fn main() { let new_sched_id = rustrt::rust_new_sched(num_threads); error!("new_sched_id %?", new_sched_id); let new_task_id = rustrt::rust_new_task_in_sched(new_sched_id); - fail_unless!(!new_task_id.is_null()); + assert!(!new_task_id.is_null()); let f: ~fn() = || { unsafe { let child_sched_id = rustrt::rust_get_sched_id(); error!("child_sched_id %?", child_sched_id); - fail_unless!(child_sched_id != parent_sched_id); - fail_unless!(child_sched_id == new_sched_id); + assert!(child_sched_id != parent_sched_id); + assert!(child_sched_id == new_sched_id); ch.send(()); } }; diff --git a/src/test/run-pass/self-shadowing-import.rs b/src/test/run-pass/self-shadowing-import.rs index a5b2d07bdc612..b1d36422487d4 100644 --- a/src/test/run-pass/self-shadowing-import.rs +++ b/src/test/run-pass/self-shadowing-import.rs @@ -20,7 +20,7 @@ mod a { mod c { use a::b::a; - pub fn bar() { fail_unless!((a::foo() == 1)); } + pub fn bar() { assert!((a::foo() == 1)); } } pub fn main() { c::bar(); } diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index 6322d24ffd913..2351540baa93f 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -21,13 +21,13 @@ fn make_generic_record(a: A, b: B) -> Pair { fn test05_start(f: &~fn(v: float, v: ~str) -> Pair) { let p = (*f)(22.22f, ~"Hi"); debug!(copy p); - fail_unless!(p.a == 22.22f); - fail_unless!(p.b == ~"Hi"); + assert!(p.a == 22.22f); + assert!(p.b == ~"Hi"); let q = (*f)(44.44f, ~"Ho"); debug!(copy q); - fail_unless!(q.a == 44.44f); - fail_unless!(q.b == ~"Ho"); + assert!(q.a == 44.44f); + assert!(q.b == ~"Ho"); } fn spawn(f: extern fn(&~fn(A,B)->Pair)) { diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs index 0d9d01f9e700f..8ccc6bb5efb08 100644 --- a/src/test/run-pass/sendfn-is-a-block.rs +++ b/src/test/run-pass/sendfn-is-a-block.rs @@ -16,5 +16,5 @@ fn test(f: &fn(uint) -> uint) -> uint { pub fn main() { let y = test(|x| 4u * x); - fail_unless!(y == 88u); + assert!(y == 88u); } diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs index a4d88e7f25b34..a91a6a9282006 100644 --- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs +++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs @@ -18,7 +18,7 @@ fn test05() { let three = ~3; let fn_to_send: ~fn(int) = |n| { error!(*three + n); // will copy x into the closure - fail_unless!((*three == 3)); + assert!((*three == 3)); }; task::spawn(|| { test05_start(fn_to_send); diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 22df0553718ce..5fb5297360081 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -11,16 +11,16 @@ pub fn main() { - fail_unless!((~"hello" < ~"hellr")); - fail_unless!((~"hello " > ~"hello")); - fail_unless!((~"hello" != ~"there")); - fail_unless!((~[1, 2, 3, 4] > ~[1, 2, 3])); - fail_unless!((~[1, 2, 3] < ~[1, 2, 3, 4])); - fail_unless!((~[1, 2, 4, 4] > ~[1, 2, 3, 4])); - fail_unless!((~[1, 2, 3, 4] < ~[1, 2, 4, 4])); - fail_unless!((~[1, 2, 3] <= ~[1, 2, 3])); - fail_unless!((~[1, 2, 3] <= ~[1, 2, 3, 3])); - fail_unless!((~[1, 2, 3, 4] > ~[1, 2, 3])); - fail_unless!((~[1, 2, 3] == ~[1, 2, 3])); - fail_unless!((~[1, 2, 3] != ~[1, 1, 3])); + assert!((~"hello" < ~"hellr")); + assert!((~"hello " > ~"hello")); + assert!((~"hello" != ~"there")); + assert!((~[1, 2, 3, 4] > ~[1, 2, 3])); + assert!((~[1, 2, 3] < ~[1, 2, 3, 4])); + assert!((~[1, 2, 4, 4] > ~[1, 2, 3, 4])); + assert!((~[1, 2, 3, 4] < ~[1, 2, 4, 4])); + assert!((~[1, 2, 3] <= ~[1, 2, 3])); + assert!((~[1, 2, 3] <= ~[1, 2, 3, 3])); + assert!((~[1, 2, 3, 4] > ~[1, 2, 3])); + assert!((~[1, 2, 3] == ~[1, 2, 3])); + assert!((~[1, 2, 3] != ~[1, 1, 3])); } diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs index 716138a30ed36..99553cfcf79b4 100644 --- a/src/test/run-pass/shadow.rs +++ b/src/test/run-pass/shadow.rs @@ -28,4 +28,4 @@ fn foo(c: ~[int]) { enum t { none, some(T), } -pub fn main() { let x = 10; let x = x + 20; fail_unless!((x == 30)); foo(~[]); } +pub fn main() { let x = 10; let x = x + 20; assert!((x == 30)); foo(~[]); } diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs index cea32fc745eca..d839825a773c2 100644 --- a/src/test/run-pass/shift.rs +++ b/src/test/run-pass/shift.rs @@ -18,64 +18,64 @@ pub fn main() { } fn test_misc() { - fail_unless!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64 == 32); + assert!(1 << 1i8 << 1u8 << 1i16 << 1 as char << 1u64 == 32); } fn test_expr() { let v10 = 10 as uint; let v4 = 4 as u8; let v2 = 2 as u8; - fail_unless!((v10 >> v2 == v2 as uint)); - fail_unless!((v10 << v4 == 160 as uint)); + assert!((v10 >> v2 == v2 as uint)); + assert!((v10 << v4 == 160 as uint)); let v10 = 10 as u8; let v4 = 4 as uint; let v2 = 2 as uint; - fail_unless!((v10 >> v2 == v2 as u8)); - fail_unless!((v10 << v4 == 160 as u8)); + assert!((v10 >> v2 == v2 as u8)); + assert!((v10 << v4 == 160 as u8)); let v10 = 10 as int; let v4 = 4 as i8; let v2 = 2 as i8; - fail_unless!((v10 >> v2 == v2 as int)); - fail_unless!((v10 << v4 == 160 as int)); + assert!((v10 >> v2 == v2 as int)); + assert!((v10 << v4 == 160 as int)); let v10 = 10 as i8; let v4 = 4 as int; let v2 = 2 as int; - fail_unless!((v10 >> v2 == v2 as i8)); - fail_unless!((v10 << v4 == 160 as i8)); + assert!((v10 >> v2 == v2 as i8)); + assert!((v10 << v4 == 160 as i8)); let v10 = 10 as uint; let v4 = 4 as int; let v2 = 2 as int; - fail_unless!((v10 >> v2 == v2 as uint)); - fail_unless!((v10 << v4 == 160 as uint)); + assert!((v10 >> v2 == v2 as uint)); + assert!((v10 << v4 == 160 as uint)); } fn test_const() { static r1_1: uint = 10u >> 2u8; static r2_1: uint = 10u << 4u8; - fail_unless!(r1_1 == 2 as uint); - fail_unless!(r2_1 == 160 as uint); + assert!(r1_1 == 2 as uint); + assert!(r2_1 == 160 as uint); static r1_2: u8 = 10u8 >> 2u; static r2_2: u8 = 10u8 << 4u; - fail_unless!(r1_2 == 2 as u8); - fail_unless!(r2_2 == 160 as u8); + assert!(r1_2 == 2 as u8); + assert!(r2_2 == 160 as u8); static r1_3: int = 10 >> 2i8; static r2_3: int = 10 << 4i8; - fail_unless!(r1_3 == 2 as int); - fail_unless!(r2_3 == 160 as int); + assert!(r1_3 == 2 as int); + assert!(r2_3 == 160 as int); static r1_4: i8 = 10i8 >> 2; static r2_4: i8 = 10i8 << 4; - fail_unless!(r1_4 == 2 as i8); - fail_unless!(r2_4 == 160 as i8); + assert!(r1_4 == 2 as i8); + assert!(r2_4 == 160 as i8); static r1_5: uint = 10u >> 2i8; static r2_5: uint = 10u << 4i8; - fail_unless!(r1_5 == 2 as uint); - fail_unless!(r2_5 == 160 as uint); + assert!(r1_5 == 2 as uint); + assert!(r2_5 == 160 as uint); } diff --git a/src/test/run-pass/signed-shift-const-eval.rs b/src/test/run-pass/signed-shift-const-eval.rs index e7e954bd787a1..0d3ecae01fb92 100644 --- a/src/test/run-pass/signed-shift-const-eval.rs +++ b/src/test/run-pass/signed-shift-const-eval.rs @@ -10,5 +10,5 @@ enum test { thing = -5 >> 1u } pub fn main() { - fail_unless!((thing as int == -3)); + assert!((thing as int == -3)); } diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index a9daf15e433e9..7bc55d647df5a 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; fn iotask(cx: &ctx, ip: ~str) { - fail_unless!((ip == ~"localhost")); + assert!((ip == ~"localhost")); } pub fn main() { diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs index 4da560b8b92ed..db4ca7b3ed863 100644 --- a/src/test/run-pass/spawn.rs +++ b/src/test/run-pass/spawn.rs @@ -17,7 +17,7 @@ pub fn main() { task::spawn(|| child(10) ); } -fn child(&&i: int) { error!(i); fail_unless!((i == 10)); } +fn child(&&i: int) { error!(i); assert!((i == 10)); } // Local Variables: // mode: rust; diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs index 6bd3af73dd0cd..f9350746349b3 100644 --- a/src/test/run-pass/spawn2.rs +++ b/src/test/run-pass/spawn2.rs @@ -22,15 +22,15 @@ fn child(&&args: (int, int, int, int, int, int, int, int, int)) { error!(i7); error!(i8); error!(i9); - fail_unless!((i1 == 10)); - fail_unless!((i2 == 20)); - fail_unless!((i3 == 30)); - fail_unless!((i4 == 40)); - fail_unless!((i5 == 50)); - fail_unless!((i6 == 60)); - fail_unless!((i7 == 70)); - fail_unless!((i8 == 80)); - fail_unless!((i9 == 90)); + assert!((i1 == 10)); + assert!((i2 == 20)); + assert!((i3 == 30)); + assert!((i4 == 40)); + assert!((i5 == 50)); + assert!((i6 == 60)); + assert!((i7 == 70)); + assert!((i8 == 80)); + assert!((i9 == 90)); } // Local Variables: diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs index 1b623fa64264f..a2e43f14898f5 100644 --- a/src/test/run-pass/stable-addr-of.rs +++ b/src/test/run-pass/stable-addr-of.rs @@ -12,5 +12,5 @@ pub fn main() { let foo = 1; - fail_unless!(ptr::addr_of(&foo) == ptr::addr_of(&foo)); + assert!(ptr::addr_of(&foo) == ptr::addr_of(&foo)); } diff --git a/src/test/run-pass/stat.rs b/src/test/run-pass/stat.rs index 6b3a37a9d7951..0967eaf061509 100644 --- a/src/test/run-pass/stat.rs +++ b/src/test/run-pass/stat.rs @@ -29,8 +29,8 @@ pub fn main() { } } - fail_unless!(path.exists()); - fail_unless!(path.get_size() == Some(1000)); + assert!(path.exists()); + assert!(path.get_size() == Some(1000)); os::remove_dir(&dir); } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index 560406c9c4048..3f4a956b3a424 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -54,13 +54,13 @@ impl vec_utils for ~[T] { } pub fn main() { - fail_unless!(10u.plus() == 30); - fail_unless!((~"hi").plus() == 200); + assert!(10u.plus() == 30); + assert!((~"hi").plus() == 200); - fail_unless!((~[1]).length_().str() == ~"1"); - fail_unless!((~[3, 4]).map_(|a| *a + 4 )[0] == 7); - fail_unless!((~[3, 4]).map_::(|a| *a as uint + 4u )[0] == 7u); + assert!((~[1]).length_().str() == ~"1"); + assert!((~[3, 4]).map_(|a| *a + 4 )[0] == 7); + assert!((~[3, 4]).map_::(|a| *a as uint + 4u )[0] == 7u); let mut x = 0u; 10u.multi(|_n| x += 2u ); - fail_unless!(x == 20u); + assert!(x == 20u); } diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs index 1b5cb86360b20..e8bb9c485ead2 100644 --- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs +++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs @@ -31,5 +31,5 @@ impl Deserializer for FromThinAir { pub fn main() { let d = FromThinAir { dummy: () }; let i: int = Deserializable::deserialize(&d); - fail_unless!(i == 22); + assert!(i == 22); } diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index 624a38b789b1c..388a7100daf44 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -77,15 +77,15 @@ fn seq_range>(lo: uint, hi: uint) -> BT { pub fn main() { let v: @[int] = seq_range(0, 10); - fail_unless!(v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + assert!(v == @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); let v: @[int] = map(&[1,2,3], |x| 1+x); - fail_unless!(v == @[2, 3, 4]); + assert!(v == @[2, 3, 4]); let v: ~[int] = map(&[1,2,3], |x| 1+x); - fail_unless!(v == ~[2, 3, 4]); + assert!(v == ~[2, 3, 4]); - fail_unless!(bool_like::select(true, 9, 14) == 9); - fail_unless!(!andand(true, false)); - fail_unless!(andand(7, 12) == 12); - fail_unless!(andand(0, 12) == 0); + assert!(bool_like::select(true, 9, 14) == 9); + assert!(!andand(true, false)); + assert!(andand(7, 12) == 12); + assert!(andand(0, 12) == 0); } diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs index f768edf7b9b82..aa4f65669ad90 100644 --- a/src/test/run-pass/static-method-xcrate.rs +++ b/src/test/run-pass/static-method-xcrate.rs @@ -17,7 +17,7 @@ use readMaybeRenamed = static_methods_crate::read::readMaybe; pub fn main() { let result: int = read(~"5"); - fail_unless!(result == 5); - fail_unless!(readMaybeRenamed(~"false") == Some(false)); - fail_unless!(readMaybeRenamed(~"foo") == None::); + assert!(result == 5); + assert!(readMaybeRenamed(~"false") == Some(false)); + assert!(readMaybeRenamed(~"foo") == None::); } diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs index 24bcfcef1e745..d171434aa482d 100644 --- a/src/test/run-pass/static-methods-in-traits.rs +++ b/src/test/run-pass/static-methods-in-traits.rs @@ -29,7 +29,7 @@ mod a { pub fn main() { let x: int = a::Foo::foo(); let y: uint = a::Foo::foo(); - fail_unless!(x == 3); - fail_unless!(y == 5); + assert!(x == 3); + assert!(y == 5); } diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index d1592c46dc993..4332a184edade 100644 --- a/src/test/run-pass/str-append.rs +++ b/src/test/run-pass/str-append.rs @@ -17,7 +17,7 @@ fn test1() { let mut s: ~str = ~"hello"; s += ~"world"; debug!(s.clone()); - fail_unless!((s[9] == 'd' as u8)); + assert!((s[9] == 'd' as u8)); } fn test2() { @@ -28,8 +28,8 @@ fn test2() { let b: ~str = ~"ABC" + ff + ~"ABC"; debug!(a.clone()); debug!(b.clone()); - fail_unless!((a == ~"abcABCabc")); - fail_unless!((b == ~"ABCabcABC")); + assert!((a == ~"abcABCabc")); + assert!((b == ~"ABCabcABC")); } pub fn main() { test1(); test2(); } diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs index 107998d3def2f..0d43329baae47 100644 --- a/src/test/run-pass/str-concat.rs +++ b/src/test/run-pass/str-concat.rs @@ -17,5 +17,5 @@ pub fn main() { let b: ~str = ~"world"; let s: ~str = a + b; debug!(s.clone()); - fail_unless!((s[9] == 'd' as u8)); + assert!((s[9] == 'd' as u8)); } diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs index 72d198cc63d84..fe9721a92e033 100644 --- a/src/test/run-pass/str-growth.rs +++ b/src/test/run-pass/str-growth.rs @@ -13,12 +13,12 @@ pub fn main() { let mut s = ~"a"; s += ~"b"; - fail_unless!((s[0] == 'a' as u8)); - fail_unless!((s[1] == 'b' as u8)); + assert!((s[0] == 'a' as u8)); + assert!((s[1] == 'b' as u8)); s += ~"c"; s += ~"d"; - fail_unless!((s[0] == 'a' as u8)); - fail_unless!((s[1] == 'b' as u8)); - fail_unless!((s[2] == 'c' as u8)); - fail_unless!((s[3] == 'd' as u8)); + assert!((s[0] == 'a' as u8)); + assert!((s[1] == 'b' as u8)); + assert!((s[2] == 'c' as u8)); + assert!((s[3] == 'd' as u8)); } diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index a2146d8770a34..24d2438e86857 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -14,5 +14,5 @@ pub fn main() { let s = ~"hello"; let c: u8 = s[4]; debug!(c); - fail_unless!((c == 0x6f as u8)); + assert!((c == 0x6f as u8)); } diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs index 254bffecf6166..ae400acdb8feb 100644 --- a/src/test/run-pass/str-multiline.rs +++ b/src/test/run-pass/str-multiline.rs @@ -21,6 +21,6 @@ is a test"; is \ another \ test"; - fail_unless!((a == ~"this is a test")); - fail_unless!((b == ~"this is another test")); + assert!((a == ~"this is a test")); + assert!((b == ~"this is another test")); } diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index a1243d33062d4..c19a2afbd417f 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -17,7 +17,7 @@ pub fn main() { let mut expected_len = 1u; while i > 0 { error!(str::len(a)); - fail_unless!((str::len(a) == expected_len)); + assert!((str::len(a) == expected_len)); a = a + a; // FIXME(#3387)---can't write a += a i -= 1; expected_len *= 2u; diff --git a/src/test/run-pass/struct-deref.rs b/src/test/run-pass/struct-deref.rs index f560c72eec312..f71bc06a1cf8d 100644 --- a/src/test/run-pass/struct-deref.rs +++ b/src/test/run-pass/struct-deref.rs @@ -12,6 +12,6 @@ struct Foo(int); pub fn main() { let x: Foo = Foo(2); - fail_unless!(*x == 2); + assert!(*x == 2); } diff --git a/src/test/run-pass/struct-destructuring-cross-crate.rs b/src/test/run-pass/struct-destructuring-cross-crate.rs index a32c6204a9947..55d25845971aa 100644 --- a/src/test/run-pass/struct-destructuring-cross-crate.rs +++ b/src/test/run-pass/struct-destructuring-cross-crate.rs @@ -16,6 +16,6 @@ extern mod struct_destructuring_cross_crate; pub fn main() { let x = struct_destructuring_cross_crate::S { x: 1, y: 2 }; let struct_destructuring_cross_crate::S { x: a, y: b } = x; - fail_unless!(a == 1); - fail_unless!(b == 2); + assert!(a == 1); + assert!(b == 2); } diff --git a/src/test/run-pass/struct-field-assignability.rs b/src/test/run-pass/struct-field-assignability.rs index f877a766ead6f..1e13c7b86bf8c 100644 --- a/src/test/run-pass/struct-field-assignability.rs +++ b/src/test/run-pass/struct-field-assignability.rs @@ -4,6 +4,6 @@ struct Foo<'self> { pub fn main() { let f = Foo { x: @3 }; - fail_unless!(*f.x == 3); + assert!(*f.x == 3); } diff --git a/src/test/run-pass/struct-like-variant-match.rs b/src/test/run-pass/struct-like-variant-match.rs index 0658b72af6be6..3158d2836ddde 100644 --- a/src/test/run-pass/struct-like-variant-match.rs +++ b/src/test/run-pass/struct-like-variant-match.rs @@ -22,12 +22,12 @@ enum Foo { fn f(x: &Foo) { match *x { Baz { x: x, y: y } => { - fail_unless!(x == 1.0); - fail_unless!(y == 2.0); + assert!(x == 1.0); + assert!(y == 2.0); } Bar { y: y, x: x } => { - fail_unless!(x == 1); - fail_unless!(y == 2); + assert!(x == 1); + assert!(y == 2); } } } diff --git a/src/test/run-pass/struct-return.rs b/src/test/run-pass/struct-return.rs index dbee72262285f..f702ca5144ea8 100644 --- a/src/test/run-pass/struct-return.rs +++ b/src/test/run-pass/struct-return.rs @@ -32,10 +32,10 @@ fn test1() { error!("b: %x", qq.b as uint); error!("c: %x", qq.c as uint); error!("d: %x", qq.d as uint); - fail_unless!(qq.a == q.c + 1u64); - fail_unless!(qq.b == q.d - 1u64); - fail_unless!(qq.c == q.a + 1u64); - fail_unless!(qq.d == q.b - 1u64); + assert!(qq.a == q.c + 1u64); + assert!(qq.b == q.d - 1u64); + assert!(qq.c == q.a + 1u64); + assert!(qq.d == q.b - 1u64); } } @@ -49,9 +49,9 @@ fn test2() { error!("a: %f", ff.a as float); error!("b: %u", ff.b as uint); error!("c: %f", ff.c as float); - fail_unless!(ff.a == f.c + 1.0f64); - fail_unless!(ff.b == 0xff_u8); - fail_unless!(ff.c == f.a - 1.0f64); + assert!(ff.a == f.c + 1.0f64); + assert!(ff.b == 0xff_u8); + assert!(ff.c == f.a - 1.0f64); } } diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index d987203344723..4a8d155c73926 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -22,15 +22,15 @@ impl cmp::Eq for foo { pub fn main() { let a = (1, 2, 3); let b = (1, 2, 3); - fail_unless!((a == b)); - fail_unless!((a != (1, 2, 4))); - fail_unless!((a < (1, 2, 4))); - fail_unless!((a <= (1, 2, 4))); - fail_unless!(((1, 2, 4) > a)); - fail_unless!(((1, 2, 4) >= a)); + assert!((a == b)); + assert!((a != (1, 2, 4))); + assert!((a < (1, 2, 4))); + assert!((a <= (1, 2, 4))); + assert!(((1, 2, 4) > a)); + assert!(((1, 2, 4) >= a)); let x = large; let y = small; - fail_unless!((x != y)); - fail_unless!((x == large)); - fail_unless!((x != small)); + assert!((x != y)); + assert!((x == large)); + assert!((x != small)); } diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs index ff114e8084a20..feb7a88dc3480 100644 --- a/src/test/run-pass/swap-1.rs +++ b/src/test/run-pass/swap-1.rs @@ -10,5 +10,5 @@ pub fn main() { let mut x = 3; let mut y = 7; - x <-> y; fail_unless!((x == 7)); fail_unless!((y == 3)); + x <-> y; assert!((x == 7)); assert!((y == 3)); } diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index 7f63e87235ffd..24794b0359168 100644 --- a/src/test/run-pass/swap-2.rs +++ b/src/test/run-pass/swap-2.rs @@ -13,10 +13,10 @@ fn swap(v: &mut [T], i: int, j: int) { v[i] <-> v[j]; } pub fn main() { let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6]; swap(a, 2, 4); - fail_unless!((a[2] == 4)); - fail_unless!((a[4] == 2)); + assert!((a[2] == 4)); + assert!((a[4] == 2)); let mut n = 42; n <-> a[0]; - fail_unless!((a[0] == 42)); - fail_unless!((n == 0)); + assert!((a[0] == 42)); + assert!((n == 0)); } diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index 3af58274bfb3c..a61feadfc9464 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -13,7 +13,7 @@ extern mod std; fn test(actual: ~str, expected: ~str) { debug!(actual.clone()); debug!(expected.clone()); - fail_unless!((actual == expected)); + assert!((actual == expected)); } pub fn main() { @@ -250,13 +250,13 @@ fn part6() { fn percent() { let s = fmt!("ab%%cd"); - fail_unless!((s == ~"ab%cd")); + assert!((s == ~"ab%cd")); } fn more_floats() { - fail_unless!(~"3.1416" == fmt!("%.4f", 3.14159)); - fail_unless!(~"3" == fmt!("%.0f", 3.14159)); - fail_unless!(~"99" == fmt!("%.0f", 98.5)); - fail_unless!(~"7.0000" == fmt!("%.4f", 6.999999999)); - fail_unless!(~"3.141590000" == fmt!("%.9f", 3.14159)); + assert!(~"3.1416" == fmt!("%.4f", 3.14159)); + assert!(~"3" == fmt!("%.0f", 3.14159)); + assert!(~"99" == fmt!("%.0f", 98.5)); + assert!(~"7.0000" == fmt!("%.4f", 6.999999999)); + assert!(~"3.141590000" == fmt!("%.9f", 3.14159)); } diff --git a/src/test/run-pass/syntax-extension-minor.rs b/src/test/run-pass/syntax-extension-minor.rs index 419380fba2297..ac0b63e98ca61 100644 --- a/src/test/run-pass/syntax-extension-minor.rs +++ b/src/test/run-pass/syntax-extension-minor.rs @@ -11,8 +11,8 @@ pub fn main() { let asdf_fdsa = ~"<.<"; - fail_unless!((concat_idents!(asd, f_f, dsa) == ~"<.<")); + assert!((concat_idents!(asd, f_f, dsa) == ~"<.<")); - fail_unless!(stringify!(use_mention_distinction) == + assert!(stringify!(use_mention_distinction) == ~"use_mention_distinction"); } diff --git a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment index 4ff0fc7a9f2e1..d5cfb94fd0b22 100644 --- a/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment +++ b/src/test/run-pass/syntax-extension-source-utils-files/includeme.fragment @@ -1,7 +1,7 @@ /* this is for run-pass/syntax-extension-source-utils.rs */ { - fail_unless!(file!().ends_with("includeme.fragment")); - fail_unless!(line!() == 5u); + assert!(file!().ends_with("includeme.fragment")); + assert!(line!() == 5u); fmt!("victory robot %u", line!()) } diff --git a/src/test/run-pass/syntax-extension-source-utils.rs b/src/test/run-pass/syntax-extension-source-utils.rs index 64055f5a88bba..7b52f52137ec0 100644 --- a/src/test/run-pass/syntax-extension-source-utils.rs +++ b/src/test/run-pass/syntax-extension-source-utils.rs @@ -20,20 +20,20 @@ pub mod m1 { macro_rules! indirect_line( () => ( line!() ) ) pub fn main() { - fail_unless!((line!() == 23)); - //fail_unless!((col!() == 11)); - fail_unless!((indirect_line!() == 25)); - fail_unless!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs"))); - fail_unless!((stringify!((2*3) + 5).to_owned() == ~"( 2 * 3 ) + 5")); - fail_unless!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned() + assert!((line!() == 23)); + //assert!((col!() == 11)); + assert!((indirect_line!() == 25)); + assert!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs"))); + assert!((stringify!((2*3) + 5).to_owned() == ~"( 2 * 3 ) + 5")); + assert!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned() == ~"victory robot 6"); - fail_unless!( + assert!( include_str!("syntax-extension-source-utils-files/includeme.fragment").to_owned() .starts_with(~"/* this is for ")); - fail_unless!( + assert!( include_bin!("syntax-extension-source-utils-files/includeme.fragment") [1] == (42 as u8)); // '*' // The Windows tests are wrapped in an extra module for some reason - fail_unless!((m1::m2::where_am_i().ends_with(~"m1::m2"))); + assert!((m1::m2::where_am_i().ends_with(~"m1::m2"))); } diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs index 23b9d5d4a3fbc..1798bb688bd27 100644 --- a/src/test/run-pass/tag-align-dyn-u64.rs +++ b/src/test/run-pass/tag-align-dyn-u64.rs @@ -30,5 +30,5 @@ fn is_8_byte_aligned(&&u: a_tag) -> bool { pub fn main() { let x = mk_rec(); - fail_unless!(is_8_byte_aligned(x.t)); + assert!(is_8_byte_aligned(x.t)); } diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs index 4d7c669ba7dec..80e300596b957 100644 --- a/src/test/run-pass/tag-align-dyn-variants.rs +++ b/src/test/run-pass/tag-align-dyn-variants.rs @@ -40,32 +40,32 @@ fn variant_data_is_aligned(amnt: uint, &&u: a_tag) -> bool { pub fn main() { let x = mk_rec(22u64, 23u64); - fail_unless!(is_aligned(8u, x.tA)); - fail_unless!(variant_data_is_aligned(8u, x.tA)); - fail_unless!(is_aligned(8u, x.tB)); - fail_unless!(variant_data_is_aligned(8u, x.tB)); + assert!(is_aligned(8u, x.tA)); + assert!(variant_data_is_aligned(8u, x.tA)); + assert!(is_aligned(8u, x.tB)); + assert!(variant_data_is_aligned(8u, x.tB)); let x = mk_rec(22u64, 23u32); - fail_unless!(is_aligned(8u, x.tA)); - fail_unless!(variant_data_is_aligned(8u, x.tA)); - fail_unless!(is_aligned(8u, x.tB)); - fail_unless!(variant_data_is_aligned(4u, x.tB)); + assert!(is_aligned(8u, x.tA)); + assert!(variant_data_is_aligned(8u, x.tA)); + assert!(is_aligned(8u, x.tB)); + assert!(variant_data_is_aligned(4u, x.tB)); let x = mk_rec(22u32, 23u64); - fail_unless!(is_aligned(8u, x.tA)); - fail_unless!(variant_data_is_aligned(4u, x.tA)); - fail_unless!(is_aligned(8u, x.tB)); - fail_unless!(variant_data_is_aligned(8u, x.tB)); + assert!(is_aligned(8u, x.tA)); + assert!(variant_data_is_aligned(4u, x.tA)); + assert!(is_aligned(8u, x.tB)); + assert!(variant_data_is_aligned(8u, x.tB)); let x = mk_rec(22u32, 23u32); - fail_unless!(is_aligned(4u, x.tA)); - fail_unless!(variant_data_is_aligned(4u, x.tA)); - fail_unless!(is_aligned(4u, x.tB)); - fail_unless!(variant_data_is_aligned(4u, x.tB)); + assert!(is_aligned(4u, x.tA)); + assert!(variant_data_is_aligned(4u, x.tA)); + assert!(is_aligned(4u, x.tB)); + assert!(variant_data_is_aligned(4u, x.tB)); let x = mk_rec(22f64, 23f64); - fail_unless!(is_aligned(8u, x.tA)); - fail_unless!(variant_data_is_aligned(8u, x.tA)); - fail_unless!(is_aligned(8u, x.tB)); - fail_unless!(variant_data_is_aligned(8u, x.tB)); + assert!(is_aligned(8u, x.tA)); + assert!(variant_data_is_aligned(8u, x.tA)); + assert!(is_aligned(8u, x.tB)); + assert!(variant_data_is_aligned(8u, x.tB)); } diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs index cb2f9522df054..052bacad7ce19 100644 --- a/src/test/run-pass/tag-align-shape.rs +++ b/src/test/run-pass/tag-align-shape.rs @@ -25,5 +25,5 @@ pub fn main() { let x = {c8: 22u8, t: a_tag(44u64)}; let y = fmt!("%?", x); debug!("y = %s", y); - fail_unless!(y == "(22, a_tag(44))"); + assert!(y == "(22, a_tag(44))"); } diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs index a4cbffbc120b7..21c51220be878 100644 --- a/src/test/run-pass/tag-align-u64.rs +++ b/src/test/run-pass/tag-align-u64.rs @@ -30,5 +30,5 @@ fn is_8_byte_aligned(&&u: a_tag) -> bool { pub fn main() { let x = mk_rec(); - fail_unless!(is_8_byte_aligned(x.t)); + assert!(is_8_byte_aligned(x.t)); } diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs index d8f469d2ff5d2..50ab17fdeeae9 100644 --- a/src/test/run-pass/tag-disr-val-shape.rs +++ b/src/test/run-pass/tag-disr-val-shape.rs @@ -19,8 +19,8 @@ enum color { pub fn main() { let act = fmt!("%?", red); io::println(act); - fail_unless!(~"red" == act); - fail_unless!(~"green" == fmt!("%?", green)); - fail_unless!(~"white" == fmt!("%?", white)); + assert!(~"red" == act); + assert!(~"green" == fmt!("%?", green)); + assert!(~"white" == fmt!("%?", white)); } diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index 63300342bd33c..34ce56250fce1 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -38,11 +38,11 @@ pub fn main() { } fn test_color(color: color, val: int, name: ~str) { - //fail_unless!(unsafe::reinterpret_cast(color) == val); - fail_unless!(color as int == val); - fail_unless!(color as float == val as float); - fail_unless!(get_color_alt(color) == name); - fail_unless!(get_color_if(color) == name); + //assert!(unsafe::reinterpret_cast(color) == val); + assert!(color as int == val); + assert!(color as float == val as float); + assert!(get_color_alt(color) == name); + assert!(get_color_if(color) == name); } fn get_color_alt(color: color) -> ~str { diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index 4e126379410be..626e0938aedca 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -34,6 +34,6 @@ impl cmp::Eq for colour { fn ne(&self, other: &colour) -> bool { !(*self).eq(other) } } -fn f() { let x = red(1, 2); let y = green; fail_unless!((x != y)); } +fn f() { let x = red(1, 2); let y = green; assert!((x != y)); } pub fn main() { f(); } diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs index 0f3131e39679d..b32f1f82aa7fa 100644 --- a/src/test/run-pass/tail-cps.rs +++ b/src/test/run-pass/tail-cps.rs @@ -12,7 +12,7 @@ // -*- rust -*- -fn checktrue(rs: bool) -> bool { fail_unless!((rs)); return true; } +fn checktrue(rs: bool) -> bool { assert!((rs)); return true; } pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); } diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs index a7af09101f6b3..847e848f0d8d8 100644 --- a/src/test/run-pass/tail-direct.rs +++ b/src/test/run-pass/tail-direct.rs @@ -12,7 +12,7 @@ // -*- rust -*- -pub fn main() { fail_unless!((even(42))); fail_unless!((odd(45))); } +pub fn main() { assert!((even(42))); assert!((odd(45))); } fn even(n: int) -> bool { if n == 0 { return true; } else { return odd(n - 1); } } diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index 6a93df0139537..ffcba42ff518b 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -36,5 +36,5 @@ fn test05() { error!(value); value = po.recv(); error!(value); - fail_unless!((value == 30)); + assert!((value == 30)); } diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs index 3fd55a7310edc..fa3ead8dfe65c 100644 --- a/src/test/run-pass/task-comm-10.rs +++ b/src/test/run-pass/task-comm-10.rs @@ -19,10 +19,10 @@ fn start(c: &comm::Chan>) { let mut a; let mut b; a = p.recv(); - fail_unless!(a == ~"A"); + assert!(a == ~"A"); error!(a); b = p.recv(); - fail_unless!(b == ~"B"); + assert!(b == ~"B"); error!(b); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 89dad2d462cca..237c721129fe5 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -19,9 +19,9 @@ fn test_rec() { ch.send(r0); let mut r1: R; r1 = po.recv(); - fail_unless!((r1.val0 == 0)); - fail_unless!((r1.val1 == 1u8)); - fail_unless!((r1.val2 == '2')); + assert!((r1.val0 == 0)); + assert!((r1.val1 == 1u8)); + assert!((r1.val2 == '2')); } fn test_vec() { @@ -29,9 +29,9 @@ fn test_vec() { let v0: ~[int] = ~[0, 1, 2]; ch.send(v0); let v1 = po.recv(); - fail_unless!((v1[0] == 0)); - fail_unless!((v1[1] == 1)); - fail_unless!((v1[2] == 2)); + assert!((v1[0] == 0)); + assert!((v1[1] == 1)); + assert!((v1[2] == 2)); } fn test_str() { @@ -39,10 +39,10 @@ fn test_str() { let s0 = ~"test"; ch.send(s0); let s1 = po.recv(); - fail_unless!((s1[0] == 't' as u8)); - fail_unless!((s1[1] == 'e' as u8)); - fail_unless!((s1[2] == 's' as u8)); - fail_unless!((s1[3] == 't' as u8)); + assert!((s1[0] == 't' as u8)); + assert!((s1[1] == 'e' as u8)); + assert!((s1[2] == 's' as u8)); + assert!((s1[3] == 't' as u8)); } enum t { @@ -85,11 +85,11 @@ fn test_tag() { ch.send(tag3(10, 11u8, 'A')); let mut t1: t; t1 = po.recv(); - fail_unless!((t1 == tag1)); + assert!((t1 == tag1)); t1 = po.recv(); - fail_unless!((t1 == tag2(10))); + assert!((t1 == tag2(10))); t1 = po.recv(); - fail_unless!((t1 == tag3(10, 11u8, 'A'))); + assert!((t1 == tag3(10, 11u8, 'A'))); } fn test_chan() { @@ -102,7 +102,7 @@ fn test_chan() { ch1.send(10); let mut i: int; i = po0.recv(); - fail_unless!((i == 10)); + assert!((i == 10)); } pub fn main() { diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index 8c8f38f5e12e7..9d5cb75804408 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -67,5 +67,5 @@ fn test00() { error!(sum); // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * // number_of_messages)); - fail_unless!((sum == 480)); + assert!((sum == 480)); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index 11191ba965824..3b606642571c8 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -46,5 +46,5 @@ fn test00() { r = p.recv(); sum += r; debug!(r); - fail_unless!((sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8)); + assert!((sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8)); } diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs index 50c032c075402..7522a092872ad 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -21,5 +21,5 @@ fn test00() { while i < number_of_messages { c.send(i + 0); i += 1; } i = 0; while i < number_of_messages { sum += p.recv(); i += 1; } - fail_unless!((sum == number_of_messages * (number_of_messages - 1) / 2)); + assert!((sum == number_of_messages * (number_of_messages - 1) / 2)); } diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs index 69c5872328924..af004e0f34d44 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -41,7 +41,7 @@ fn test00() { sum += r; i += 1; } - fail_unless!((sum == 1998000)); + assert!((sum == 1998000)); // assert (sum == 4 * ((number_of_messages * // (number_of_messages - 1)) / 2)); diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index 88f41655c5228..980ded6aecc0d 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -56,5 +56,5 @@ fn test00() { i += 1; } - fail_unless!((sum == number_of_messages * 4 * (number_of_messages * 4 - 1) / 2)); + assert!((sum == number_of_messages * 4 * (number_of_messages * 4 - 1) / 2)); } diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index 767203a1f630d..1661792c6ac36 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -41,5 +41,5 @@ fn test00() { result.unwrap().recv(); - fail_unless!((sum == number_of_messages * (number_of_messages - 1) / 2)); + assert!((sum == number_of_messages * (number_of_messages - 1) / 2)); } diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index 4c63e24d5bc99..bae3cbbf58729 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -19,5 +19,5 @@ pub fn main() { let (po, ch) = comm::stream(); ch.send(()); let n: () = po.recv(); - fail_unless!((n == ())); + assert!((n == ())); } diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs index 7456c6efbd416..b3f5bad56ef06 100644 --- a/src/test/run-pass/task-spawn-move-and-copy.rs +++ b/src/test/run-pass/task-spawn-move-and-copy.rs @@ -22,5 +22,5 @@ pub fn main() { }); let x_in_child = p.recv(); - fail_unless!(x_in_parent == x_in_child); + assert!(x_in_parent == x_in_child); } diff --git a/src/test/run-pass/test-ignore-cfg.rs b/src/test/run-pass/test-ignore-cfg.rs index ae99aee05d752..304c9e5ccb9c3 100644 --- a/src/test/run-pass/test-ignore-cfg.rs +++ b/src/test/run-pass/test-ignore-cfg.rs @@ -28,11 +28,11 @@ fn checktests() { // Pull the tests out of the secreturn test module let tests = __test::tests; - fail_unless!(vec::any( + assert!(vec::any( tests, |t| t.desc.name.to_str() == ~"shouldignore" && t.desc.ignore)); - fail_unless!(vec::any( + assert!(vec::any( tests, |t| t.desc.name.to_str() == ~"shouldnotignore" && !t.desc.ignore)); } diff --git a/src/test/run-pass/trait-bounds.rs b/src/test/run-pass/trait-bounds.rs index 6dcd2a41e0764..3bdd9aa508803 100644 --- a/src/test/run-pass/trait-bounds.rs +++ b/src/test/run-pass/trait-bounds.rs @@ -31,5 +31,5 @@ pub fn main() { let factory = (); let connection = factory.create(); let result = connection.read(); - fail_unless!(result == 43); + assert!(result == 43); } diff --git a/src/test/run-pass/trait-cast.rs b/src/test/run-pass/trait-cast.rs index 4cee3c636c572..303eaa13af852 100644 --- a/src/test/run-pass/trait-cast.rs +++ b/src/test/run-pass/trait-cast.rs @@ -55,7 +55,7 @@ pub fn main() { right: Some(t1), val: 2 as to_str }); let expected = ~"[2, some([1, none, none]), some([1, none, none])]"; - fail_unless!(t2.to_str() == expected); - fail_unless!(foo(t2 as to_str) == expected); + assert!(t2.to_str() == expected); + assert!(foo(t2 as to_str) == expected); t1.left = Some(t2); // create cycle } diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs index 5670ae39accbb..a489f2b405ffc 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>(i: V, j: T, k: U) -> (T, U) { } pub fn main () { - fail_unless!(f(0, 1, 2) == (1, 2)); + assert!(f(0, 1, 2) == (1, 2)); } diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs index ce72c7e9a44b3..4203f73236e13 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>(i: V, j: T) -> T { } pub fn main () { - fail_unless!(f(0, 2) == 2); + assert!(f(0, 2) == 2); } diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs index 3c1e6a59d0387..11830e7e7d248 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(i: V, j: T, k: T) -> (T, T) { } pub fn main () { - fail_unless!(f(0, 1, 2) == (1, 2)); - fail_unless!(f(0, 1u8, 2u8) == (1u8, 2u8)); + assert!(f(0, 1, 2) == (1, 2)); + assert!(f(0, 1u8, 2u8) == (1u8, 2u8)); } diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs index 9ac66bfb737f2..285d31152e2ab 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>(i: V, j: uint) -> uint { } pub fn main () { - fail_unless!(f::(0, 2u) == 2u); - fail_unless!(f::(0, 2u) == 2u); + assert!(f::(0, 2u) == 2u); + assert!(f::(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 627bc96e6ae99..756af0d63fdef 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(i: T) { - fail_unless!(i.g() == 10); + assert!(i.g() == 10); } pub fn main () { diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index c11ece6281347..eacd51266adc2 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -42,8 +42,8 @@ fn bar>(x: T) -> ~[~str] { } pub fn main() { - fail_unless!(foo(~[1]) == ~[~"hi"]); - fail_unless!(bar::(~[4, 5]) == ~[~"4", ~"5"]); - fail_unless!(bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]); - fail_unless!(bar::<(), ~[()]>(~[()]) == ~[~"()"]); + assert!(foo(~[1]) == ~[~"hi"]); + assert!(bar::(~[4, 5]) == ~[~"4", ~"5"]); + assert!(bar::<~str, ~[~str]>(~[~"x", ~"y"]) == ~[~"x", ~"y"]); + assert!(bar::<(), ~[()]>(~[()]) == ~[~"()"]); } diff --git a/src/test/run-pass/trait-inheritance-auto-xc-2.rs b/src/test/run-pass/trait-inheritance-auto-xc-2.rs index 15611d19979b6..446dd4b3d8ee1 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 Quux for T { } fn f(a: &T) { - fail_unless!(a.f() == 10); - fail_unless!(a.g() == 20); - fail_unless!(a.h() == 30); + assert!(a.f() == 10); + assert!(a.g() == 20); + assert!(a.h() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-auto-xc.rs b/src/test/run-pass/trait-inheritance-auto-xc.rs index ccb55f1d16404..03287809a9be1 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(a: &T) { - fail_unless!(a.f() == 10); - fail_unless!(a.g() == 20); - fail_unless!(a.h() == 30); + assert!(a.f() == 10); + assert!(a.g() == 20); + assert!(a.h() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-auto.rs b/src/test/run-pass/trait-inheritance-auto.rs index 51a3168f6e811..b74064591d3bc 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(a: &T) { - fail_unless!(a.f() == 10); - fail_unless!(a.g() == 20); - fail_unless!(a.h() == 30); + assert!(a.f() == 10); + assert!(a.g() == 20); + assert!(a.h() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs index dcc1deed84617..26b96f933269b 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs @@ -23,6 +23,6 @@ fn gg(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - fail_unless!(gg(a) == 10); + assert!(gg(a) == 10); } diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs index ad23cab016e73..5e612bbca6487 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs @@ -26,6 +26,6 @@ fn gg(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - fail_unless!(gg(a) == 10); + assert!(gg(a) == 10); } diff --git a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs index 39565382118f9..6efd854e01b42 100644 --- a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs +++ b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs @@ -35,7 +35,7 @@ pub fn main() { let a = &A { x: 3 }; let afoo = a as &Foo; let abar = a as &Bar; - fail_unless!(afoo.f() == 10); - fail_unless!(abar.g() == 20); + assert!(afoo.f() == 10); + assert!(abar.g() == 20); } diff --git a/src/test/run-pass/trait-inheritance-cast.rs b/src/test/run-pass/trait-inheritance-cast.rs index d066f49c73225..023827977976e 100644 --- a/src/test/run-pass/trait-inheritance-cast.rs +++ b/src/test/run-pass/trait-inheritance-cast.rs @@ -36,8 +36,8 @@ pub fn main() { let a = &A { x: 3 }; let afoo = a as &Foo; let abar = a as &Bar; - fail_unless!(afoo.f() == 10); - fail_unless!(abar.g() == 20); - fail_unless!(abar.f() == 10); + assert!(afoo.f() == 10); + assert!(abar.g() == 20); + assert!(abar.f() == 10); } diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs index a5f163a9cfa3f..3c1bf2035aa71 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs @@ -25,6 +25,6 @@ impl Bar for aux::A { pub fn main() { let a = &aux::A { x: 3 }; - fail_unless!(a.g() == 10); + assert!(a.g() == 10); } diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call.rs b/src/test/run-pass/trait-inheritance-cross-trait-call.rs index 2cde60ecf58f2..997f13d0e5e35 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call.rs @@ -22,6 +22,6 @@ impl Bar for A { pub fn main() { let a = &A { x: 3 }; - fail_unless!(a.g() == 10); + assert!(a.g() == 10); } diff --git a/src/test/run-pass/trait-inheritance-diamond.rs b/src/test/run-pass/trait-inheritance-diamond.rs index 2bebf1c9932fa..abfbec6d35863 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(x: &T) { - fail_unless!(x.a() == 10); - fail_unless!(x.b() == 20); - fail_unless!(x.c() == 30); - fail_unless!(x.d() == 40); + assert!(x.a() == 10); + assert!(x.b() == 20); + assert!(x.c() == 30); + assert!(x.d() == 40); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs index 5c84e2af4b73d..5bd8f7f25ea09 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(x: &T) { - fail_unless!(x.a() == 10); - fail_unless!(x.b() == 20); - fail_unless!(x.c() == 30); + assert!(x.a() == 10); + assert!(x.b() == 20); + assert!(x.c() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-multiple-params.rs b/src/test/run-pass/trait-inheritance-multiple-params.rs index 57a5f2bc0e17d..e01860ba50336 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: &X, y: &Y, z: &Z) { - fail_unless!(x.a() == 10); - fail_unless!(y.a() == 10); - fail_unless!(y.b() == 20); - fail_unless!(z.a() == 10); - fail_unless!(z.c() == 30); + assert!(x.a() == 10); + assert!(y.a() == 10); + assert!(y.b() == 20); + assert!(z.a() == 10); + assert!(z.c() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs index 283ed8ae2c188..711571e8c64f5 100644 --- a/src/test/run-pass/trait-inheritance-overloading-simple.rs +++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs @@ -29,7 +29,7 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y, z) = (mi(3), mi(5), mi(3)); - fail_unless!(x != y); - fail_unless!(x == z); + assert!(x != y); + assert!(x == z); } diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs index d4d16f2b43ebd..9f745db76386c 100644 --- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs +++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs @@ -23,8 +23,8 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let (a, b, c) = f(x, y); - fail_unless!(a == mi(8)); - fail_unless!(b == mi(-2)); - fail_unless!(c == mi(15)); + assert!(a == mi(8)); + assert!(b == mi(-2)); + assert!(c == mi(15)); } diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index d4f8d50b92b64..5b68aff269e3c 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -42,8 +42,8 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let (a, b, c) = f(x, y); - fail_unless!(a == mi(8)); - fail_unless!(b == mi(-2)); - fail_unless!(c == mi(15)); + assert!(a == mi(8)); + assert!(b == mi(-2)); + assert!(c == mi(15)); } diff --git a/src/test/run-pass/trait-inheritance-simple.rs b/src/test/run-pass/trait-inheritance-simple.rs index 9ca3ccaa22cd4..779dfb65944c9 100644 --- a/src/test/run-pass/trait-inheritance-simple.rs +++ b/src/test/run-pass/trait-inheritance-simple.rs @@ -26,7 +26,7 @@ fn gg(a: &T) -> int { pub fn main() { let a = &A { x: 3 }; - fail_unless!(ff(a) == 10); - fail_unless!(gg(a) == 20); + assert!(ff(a) == 10); + assert!(gg(a) == 20); } diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs index f3adea18ecdc1..3b87387d4d6f1 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 { MyNum::from_int(1) } pub fn main() { let v: S = greater_than_one(); - fail_unless!(v.v == 1); + assert!(v.v == 1); } diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs index 45369d4ec19d5..2718949db070a 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 { MyNum::from_int(1) } pub fn main() { let v: S = greater_than_one(); - fail_unless!(v.v == 1); + assert!(v.v == 1); } diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs index 9d0e5fa1f13d4..22efdabec83ab 100644 --- a/src/test/run-pass/trait-inheritance-subst.rs +++ b/src/test/run-pass/trait-inheritance-subst.rs @@ -31,6 +31,6 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let z = f(x, y); - fail_unless!(z.val == 8) + assert!(z.val == 8) } diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs index 20b7d529fae20..4f3b808f8ebc0 100644 --- a/src/test/run-pass/trait-inheritance-subst2.rs +++ b/src/test/run-pass/trait-inheritance-subst2.rs @@ -41,6 +41,6 @@ fn mi(v: int) -> MyInt { MyInt { val: v } } pub fn main() { let (x, y) = (mi(3), mi(5)); let z = f(x, y); - fail_unless!(z.val == 13); + assert!(z.val == 13); } diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs index c70c2ecf9768a..81f119612d994 100644 --- a/src/test/run-pass/trait-inheritance-visibility.rs +++ b/src/test/run-pass/trait-inheritance-visibility.rs @@ -20,7 +20,7 @@ impl 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(x: &T) { - fail_unless!(x.f() == 10); + assert!(x.f() == 10); } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs index d18452f11fa41..5d6913d4146b9 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(a: &T) { - fail_unless!(a.f() == 10); - fail_unless!(a.g() == 20); - fail_unless!(a.h() == 30); + assert!(a.f() == 10); + assert!(a.g() == 20); + assert!(a.h() == 30); } pub fn main() { diff --git a/src/test/run-pass/trait-region-pointer-simple.rs b/src/test/run-pass/trait-region-pointer-simple.rs index 1ce2cddc29b05..285b0e65daf67 100644 --- a/src/test/run-pass/trait-region-pointer-simple.rs +++ b/src/test/run-pass/trait-region-pointer-simple.rs @@ -26,6 +26,6 @@ impl Foo for A { pub fn main() { let a = A { x: 3 }; let b = (&a) as &Foo; - fail_unless!(b.f() == 3); + assert!(b.f() == 3); } diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs index 40850186e2854..ca22b5942dbc7 100644 --- a/src/test/run-pass/trait-to-str.rs +++ b/src/test/run-pass/trait-to-str.rs @@ -31,16 +31,16 @@ impl to_str for ~[T] { } pub fn main() { - fail_unless!(1.to_str() == ~"1"); - fail_unless!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]"); + assert!(1.to_str() == ~"1"); + assert!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]"); fn indirect(x: T) -> ~str { x.to_str() + ~"!" } - fail_unless!(indirect(~[10, 20]) == ~"[10, 20]!"); + assert!(indirect(~[10, 20]) == ~"[10, 20]!"); fn indirect2(x: T) -> ~str { indirect(x) } - fail_unless!(indirect2(~[1]) == ~"[1]!"); + assert!(indirect2(~[1]) == ~"[1]!"); } diff --git a/src/test/run-pass/traits-default-method-macro.rs b/src/test/run-pass/traits-default-method-macro.rs index 21e05aba27b5a..7f106f71f8ed0 100644 --- a/src/test/run-pass/traits-default-method-macro.rs +++ b/src/test/run-pass/traits-default-method-macro.rs @@ -25,5 +25,5 @@ impl Foo for Baz { pub fn main() { let q = Quux; - fail_unless!(q.bar() == ~"test"); + assert!(q.bar() == ~"test"); } diff --git a/src/test/run-pass/traits-default-method-self.rs b/src/test/run-pass/traits-default-method-self.rs index 3531b12d1f9d9..a377c86068cd7 100644 --- a/src/test/run-pass/traits-default-method-self.rs +++ b/src/test/run-pass/traits-default-method-self.rs @@ -25,5 +25,5 @@ impl Cat for int { } pub fn main() { - fail_unless!(5.meow()); + assert!(5.meow()); } diff --git a/src/test/run-pass/traits-default-method-trivial.rs b/src/test/run-pass/traits-default-method-trivial.rs index 8edb83ce60ec4..998d8f8946f1f 100644 --- a/src/test/run-pass/traits-default-method-trivial.rs +++ b/src/test/run-pass/traits-default-method-trivial.rs @@ -26,5 +26,5 @@ impl Cat for int { } pub fn main() { - fail_unless!(5.meow()); + assert!(5.meow()); } diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs index 6bcaca9a08cbb..c1a34a326a6e5 100644 --- a/src/test/run-pass/tup.rs +++ b/src/test/run-pass/tup.rs @@ -13,15 +13,15 @@ type point = (int, int); fn f(p: point, x: int, y: int) { let (a, b) = p; - fail_unless!((a == x)); - fail_unless!((b == y)); + assert!((a == x)); + assert!((b == y)); } pub fn main() { let p: point = (10, 20); let (a, b) = p; - fail_unless!((a == 10)); - fail_unless!((b == 20)); + assert!((a == 10)); + assert!((b == 20)); let p2: point = p; f(p, 10, 20); f(p2, 10, 20); diff --git a/src/test/run-pass/tuple-struct-destructuring.rs b/src/test/run-pass/tuple-struct-destructuring.rs index 82fa411b231b5..7e6b9570defae 100644 --- a/src/test/run-pass/tuple-struct-destructuring.rs +++ b/src/test/run-pass/tuple-struct-destructuring.rs @@ -14,7 +14,7 @@ pub fn main() { let x = Foo(1, 2); let Foo(y, z) = x; io::println(fmt!("%d %d", y, z)); - fail_unless!(y == 1); - fail_unless!(z == 2); + assert!(y == 1); + assert!(z == 2); } diff --git a/src/test/run-pass/tuple-struct-matching.rs b/src/test/run-pass/tuple-struct-matching.rs index cd867adebc192..405616f9b1fef 100644 --- a/src/test/run-pass/tuple-struct-matching.rs +++ b/src/test/run-pass/tuple-struct-matching.rs @@ -14,8 +14,8 @@ pub fn main() { let x = Foo(1, 2); match x { Foo(a, b) => { - fail_unless!(a == 1); - fail_unless!(b == 2); + assert!(a == 1); + assert!(b == 2); io::println(fmt!("%d %d", a, b)); } } diff --git a/src/test/run-pass/type-namespace.rs b/src/test/run-pass/type-namespace.rs index 2fb8f34120c00..e9b0324456a2f 100644 --- a/src/test/run-pass/type-namespace.rs +++ b/src/test/run-pass/type-namespace.rs @@ -12,4 +12,4 @@ struct A { a: int } fn a(a: A) -> int { return a.a; } -pub fn main() { let x: A = A {a: 1}; fail_unless!((a(x) == 1)); } +pub fn main() { let x: A = A {a: 1}; assert!((a(x) == 1)); } diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs index 86c10e0a597a3..bc2ca20d642d9 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -13,19 +13,19 @@ use sys::rustrt::size_of; extern mod std; pub fn main() { - fail_unless!((size_of::() == 1 as uint)); - fail_unless!((size_of::() == 4 as uint)); - fail_unless!((size_of::() == 4 as uint)); - fail_unless!((size_of::() == 1 as uint)); - fail_unless!((size_of::() == 4 as uint)); - fail_unless!((size_of::<{a: u8, b: i8}>() == 2 as uint)); - fail_unless!((size_of::<{a: u8, b: i8, c: u8}>() == 3 as uint)); + assert!((size_of::() == 1 as uint)); + assert!((size_of::() == 4 as uint)); + assert!((size_of::() == 4 as uint)); + assert!((size_of::() == 1 as uint)); + assert!((size_of::() == 4 as uint)); + assert!((size_of::<{a: u8, b: i8}>() == 2 as uint)); + assert!((size_of::<{a: u8, b: i8, c: u8}>() == 3 as uint)); // Alignment causes padding before the char and the u32. - fail_unless!(size_of::<{a: u8, b: i8, c: {u: char, v: u8}, d: u32}>() == + assert!(size_of::<{a: u8, b: i8, c: {u: char, v: u8}, d: u32}>() == 16 as uint); - fail_unless!((size_of::() == size_of::())); - fail_unless!((size_of::<{a: int, b: ()}>() == size_of::())); - fail_unless!((size_of::<{a: int, b: (), c: ()}>() == size_of::())); - fail_unless!((size_of::() == size_of::<{x: int}>())); + assert!((size_of::() == size_of::())); + assert!((size_of::<{a: int, b: ()}>() == size_of::())); + assert!((size_of::<{a: int, b: (), c: ()}>() == size_of::())); + assert!((size_of::() == size_of::<{x: int}>())); } diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs index 7303f5ecbdf6c..9c5f8c3218a93 100644 --- a/src/test/run-pass/typeclasses-eq-example-static.rs +++ b/src/test/run-pass/typeclasses-eq-example-static.rs @@ -47,18 +47,18 @@ impl Equal for ColorTree { } pub fn main() { - fail_unless!(Equal::isEq(cyan, cyan)); - fail_unless!(Equal::isEq(magenta, magenta)); - fail_unless!(!Equal::isEq(cyan, yellow)); - fail_unless!(!Equal::isEq(magenta, cyan)); + assert!(Equal::isEq(cyan, cyan)); + assert!(Equal::isEq(magenta, magenta)); + assert!(!Equal::isEq(cyan, yellow)); + assert!(!Equal::isEq(magenta, cyan)); - fail_unless!(Equal::isEq(leaf(cyan), leaf(cyan))); - fail_unless!(!Equal::isEq(leaf(cyan), leaf(yellow))); + assert!(Equal::isEq(leaf(cyan), leaf(cyan))); + assert!(!Equal::isEq(leaf(cyan), leaf(yellow))); - fail_unless!(Equal::isEq(branch(@leaf(magenta), @leaf(cyan)), + assert!(Equal::isEq(branch(@leaf(magenta), @leaf(cyan)), branch(@leaf(magenta), @leaf(cyan)))); - fail_unless!(!Equal::isEq(branch(@leaf(magenta), @leaf(cyan)), + assert!(!Equal::isEq(branch(@leaf(magenta), @leaf(cyan)), branch(@leaf(magenta), @leaf(magenta)))); error!("Assertions all succeeded!"); diff --git a/src/test/run-pass/typeclasses-eq-example.rs b/src/test/run-pass/typeclasses-eq-example.rs index a18965e9abc39..51c19cef50afd 100644 --- a/src/test/run-pass/typeclasses-eq-example.rs +++ b/src/test/run-pass/typeclasses-eq-example.rs @@ -46,18 +46,18 @@ impl Equal for ColorTree { } pub fn main() { - fail_unless!(cyan.isEq(cyan)); - fail_unless!(magenta.isEq(magenta)); - fail_unless!(!cyan.isEq(yellow)); - fail_unless!(!magenta.isEq(cyan)); + assert!(cyan.isEq(cyan)); + assert!(magenta.isEq(magenta)); + assert!(!cyan.isEq(yellow)); + assert!(!magenta.isEq(cyan)); - fail_unless!(leaf(cyan).isEq(leaf(cyan))); - fail_unless!(!leaf(cyan).isEq(leaf(yellow))); + assert!(leaf(cyan).isEq(leaf(cyan))); + assert!(!leaf(cyan).isEq(leaf(yellow))); - fail_unless!(branch(@leaf(magenta), @leaf(cyan)) + assert!(branch(@leaf(magenta), @leaf(cyan)) .isEq(branch(@leaf(magenta), @leaf(cyan)))); - fail_unless!(!branch(@leaf(magenta), @leaf(cyan)) + assert!(!branch(@leaf(magenta), @leaf(cyan)) .isEq(branch(@leaf(magenta), @leaf(magenta)))); error!("Assertions all succeeded!"); diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs index 9b8e84da6e0fd..b4ca326fb5707 100644 --- a/src/test/run-pass/typestate-multi-decl.rs +++ b/src/test/run-pass/typestate-multi-decl.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn main() { let x = 10, y = 20; let z = x + y; fail_unless!((z == 30)); } +pub fn main() { let x = 10, y = 20; let z = x + y; assert!((z == 30)); } diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs index 6f05ee5669d78..2b68e89ed26dd 100644 --- a/src/test/run-pass/u32-decr.rs +++ b/src/test/run-pass/u32-decr.rs @@ -15,5 +15,5 @@ pub fn main() { let mut word: u32 = 200000u32; word = word - 1u32; - fail_unless!((word == 199999u32)); + assert!((word == 199999u32)); } diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs index 83e8fb1ffa27e..e864cd0ad4ab4 100644 --- a/src/test/run-pass/u8-incr-decr.rs +++ b/src/test/run-pass/u8-incr-decr.rs @@ -24,5 +24,5 @@ pub fn main() { y = y - 9u8; // 0x9 - fail_unless!((x == y)); + assert!((x == y)); } diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs index 2617437d17c47..c9d31fb72b7c5 100644 --- a/src/test/run-pass/u8-incr.rs +++ b/src/test/run-pass/u8-incr.rs @@ -17,7 +17,7 @@ pub fn main() { let y: u8 = 12u8; x = x + 1u8; x = x - 1u8; - fail_unless!((x == y)); + assert!((x == y)); // x = 14u8; // x = x + 1u8; diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs index 8ecff0719a29c..d05cb76e11335 100644 --- a/src/test/run-pass/unique-assign-copy.rs +++ b/src/test/run-pass/unique-assign-copy.rs @@ -15,6 +15,6 @@ pub fn main() { j = i.clone(); *i = 2; *j = 3; - fail_unless!(*i == 2); - fail_unless!(*j == 3); + assert!(*i == 2); + assert!(*j == 3); } diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs index fec3f7b626a02..0faa6b1b555f6 100644 --- a/src/test/run-pass/unique-assign-drop.rs +++ b/src/test/run-pass/unique-assign-drop.rs @@ -13,5 +13,5 @@ pub fn main() { let mut j = ~2; // Should drop the previous value of j j = i; - fail_unless!(*j == 1); + assert!(*j == 1); } diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 4254c12bac377..75753b31ed7e2 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: T) -> T { pub fn main() { let t = f(~100); - fail_unless!(t == ~100); + assert!(t == ~100); let t = f(~@~[100]); - fail_unless!(t == ~@~[100]); + assert!(t == ~@~[100]); } diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs index 4f283d11eea59..6fc16cae76f1d 100644 --- a/src/test/run-pass/unique-assign.rs +++ b/src/test/run-pass/unique-assign.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i; i = ~1; - fail_unless!(*i == 1); + assert!(*i == 1); } diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs index 7326c642cf071..07105a53caf27 100644 --- a/src/test/run-pass/unique-autoderef-field.rs +++ b/src/test/run-pass/unique-autoderef-field.rs @@ -14,5 +14,5 @@ pub fn main() { let i = ~J { j: 100 }; - fail_unless!(i.j == 100); + assert!(i.j == 100); } diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index a96f7d5c16720..324efe5abe5c8 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~~[100]; - fail_unless!(i[0] == 100); + assert!(i[0] == 100); } diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs index 237ade196f035..b50d315483596 100644 --- a/src/test/run-pass/unique-cmp.rs +++ b/src/test/run-pass/unique-cmp.rs @@ -10,9 +10,9 @@ pub fn main() { let i = ~100; - fail_unless!(i == ~100); - fail_unless!(i < ~101); - fail_unless!(i <= ~100); - fail_unless!(i > ~99); - fail_unless!(i >= ~99); + assert!(i == ~100); + assert!(i < ~101); + assert!(i <= ~100); + assert!(i > ~99); + assert!(i >= ~99); } diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs index 42921f24c75da..c8ed7b10a1ffa 100644 --- a/src/test/run-pass/unique-containing-tag.rs +++ b/src/test/run-pass/unique-containing-tag.rs @@ -15,14 +15,14 @@ pub fn main() { /*alt *x { t1(a) { - fail_unless!(a == 10); + assert!(a == 10); } _ { fail!(); } }*/ /*alt x { ~t1(a) { - fail_unless!(a == 10); + assert!(a == 10); } _ { fail!(); } }*/ diff --git a/src/test/run-pass/unique-copy-box.rs b/src/test/run-pass/unique-copy-box.rs index 22e05213e5d94..b483881f1a63c 100644 --- a/src/test/run-pass/unique-copy-box.rs +++ b/src/test/run-pass/unique-copy-box.rs @@ -16,6 +16,6 @@ pub fn main() { let j = copy i; let rc2 = sys::refcount(*i); error!("rc1: %u rc2: %u", rc1, rc2); - fail_unless!(rc1 + 1u == rc2); + assert!(rc1 + 1u == rc2); } } diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs index 177b3ed5c246c..670bc35d85748 100644 --- a/src/test/run-pass/unique-decl-init-copy.rs +++ b/src/test/run-pass/unique-decl-init-copy.rs @@ -14,6 +14,6 @@ pub fn main() { let mut j = i.clone(); *i = 2; *j = 3; - fail_unless!(*i == 2); - fail_unless!(*j == 3); + assert!(*i == 2); + assert!(*j == 3); } diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs index 809ca5bae0d4c..f5f1829cae047 100644 --- a/src/test/run-pass/unique-decl-init.rs +++ b/src/test/run-pass/unique-decl-init.rs @@ -11,5 +11,5 @@ pub fn main() { let i = ~1; let j = i; - fail_unless!(*j == 1); + assert!(*j == 1); } diff --git a/src/test/run-pass/unique-decl-move-temp.rs b/src/test/run-pass/unique-decl-move-temp.rs index 1632a537174c5..b9f122acbcd7f 100644 --- a/src/test/run-pass/unique-decl-move-temp.rs +++ b/src/test/run-pass/unique-decl-move-temp.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~100; - fail_unless!(*i == 100); + assert!(*i == 100); } diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs index 402d05fbcef84..81c59bae35708 100644 --- a/src/test/run-pass/unique-decl-move.rs +++ b/src/test/run-pass/unique-decl-move.rs @@ -11,5 +11,5 @@ pub fn main() { let i = ~100; let j = i; - fail_unless!(*j == 100); + assert!(*j == 100); } diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs index 1632a537174c5..b9f122acbcd7f 100644 --- a/src/test/run-pass/unique-deref.rs +++ b/src/test/run-pass/unique-deref.rs @@ -10,5 +10,5 @@ pub fn main() { let i = ~100; - fail_unless!(*i == 100); + assert!(*i == 100); } diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs index c3047d5da0531..64e01f8647465 100644 --- a/src/test/run-pass/unique-destructure.rs +++ b/src/test/run-pass/unique-destructure.rs @@ -12,5 +12,5 @@ struct Foo { a: int, b: int } pub fn main() { let ~Foo{a, b} = ~Foo{a: 100, b: 200}; - fail_unless!(a + b == 300); + assert!(a + b == 300); } diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs index 5a318d04e55c1..bbb33560e32dd 100644 --- a/src/test/run-pass/unique-fn-arg-move.rs +++ b/src/test/run-pass/unique-fn-arg-move.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(+i: ~int) { - fail_unless!(*i == 100); + assert!(*i == 100); } pub fn main() { diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs index 09be9e178ce3c..56ec9663ec626 100644 --- a/src/test/run-pass/unique-fn-arg-mut.rs +++ b/src/test/run-pass/unique-fn-arg-mut.rs @@ -15,5 +15,5 @@ fn f(i: &mut ~int) { pub fn main() { let mut i = ~100; f(&mut i); - fail_unless!(*i == 200); + assert!(*i == 200); } diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs index 030e11e46f66f..931c5acbe1d76 100644 --- a/src/test/run-pass/unique-fn-arg.rs +++ b/src/test/run-pass/unique-fn-arg.rs @@ -9,7 +9,7 @@ // except according to those terms. fn f(i: ~int) { - fail_unless!(*i == 100); + assert!(*i == 100); } pub fn main() { diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs index d645c3c21a617..0ef9d12f75b0d 100644 --- a/src/test/run-pass/unique-fn-ret.rs +++ b/src/test/run-pass/unique-fn-ret.rs @@ -13,5 +13,5 @@ fn f() -> ~int { } pub fn main() { - fail_unless!(f() == ~100); + assert!(f() == ~100); } diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs index e46a79d364fe2..0e7d38494615c 100644 --- a/src/test/run-pass/unique-in-tag.rs +++ b/src/test/run-pass/unique-in-tag.rs @@ -12,7 +12,7 @@ fn test1() { enum bar { u(~int), w(int), } let x = u(~10); - fail_unless!(match x { + assert!(match x { u(a) => { error!(a); *a diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs index 1033fa1c22c79..e72262795796c 100644 --- a/src/test/run-pass/unique-in-vec-copy.rs +++ b/src/test/run-pass/unique-in-vec-copy.rs @@ -12,12 +12,12 @@ pub fn main() { let mut a = ~[~10]; let b = a.clone(); - fail_unless!(*a[0] == 10); - fail_unless!(*b[0] == 10); + assert!(*a[0] == 10); + assert!(*b[0] == 10); // This should only modify the value in a, not b *a[0] = 20; - fail_unless!(*a[0] == 20); - fail_unless!(*b[0] == 10); + assert!(*a[0] == 20); + assert!(*b[0] == 10); } diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs index 62e9e03d3a10f..51fceae39b405 100644 --- a/src/test/run-pass/unique-in-vec.rs +++ b/src/test/run-pass/unique-in-vec.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn main() { - fail_unless!((~[~100])[0] == ~100); + assert!((~[~100])[0] == ~100); } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index 9844a55c960bd..da48f2ff51ba8 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -13,11 +13,11 @@ use core::cmp::Eq; fn sendable() { fn f(i: T, j: T) { - fail_unless!(i == j); + assert!(i == j); } fn g(i: T, j: T) { - fail_unless!(i != j); + assert!(i != j); } let i = ~100; @@ -31,11 +31,11 @@ fn sendable() { fn copyable() { fn f(i: T, j: T) { - fail_unless!(i == j); + assert!(i == j); } fn g(i: T, j: T) { - fail_unless!(i != j); + assert!(i != j); } let i = ~100; @@ -49,11 +49,11 @@ fn copyable() { fn noncopyable() { fn f(i: T, j: T) { - fail_unless!(i == j); + assert!(i == j); } fn g(i: T, j: T) { - fail_unless!(i != j); + assert!(i != j); } let i = ~100; diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs index ac64b388a05c7..5ddc85ea5faa6 100644 --- a/src/test/run-pass/unique-move-drop.rs +++ b/src/test/run-pass/unique-move-drop.rs @@ -12,5 +12,5 @@ pub fn main() { let i = ~100; let j = ~200; let j = i; - fail_unless!(*j == 100); + assert!(*j == 100); } diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs index 2f8b0a84b04b7..343b0d431428b 100644 --- a/src/test/run-pass/unique-move-temp.rs +++ b/src/test/run-pass/unique-move-temp.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i; i = ~100; - fail_unless!(*i == 100); + assert!(*i == 100); } diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs index 3dc80e26b1cfe..3331350facdcb 100644 --- a/src/test/run-pass/unique-move.rs +++ b/src/test/run-pass/unique-move.rs @@ -12,5 +12,5 @@ pub fn main() { let i = ~100; let mut j; j = i; - fail_unless!(*j == 100); + assert!(*j == 100); } diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs index 4e7c751b8834c..e4a1b4a548b4b 100644 --- a/src/test/run-pass/unique-mutable.rs +++ b/src/test/run-pass/unique-mutable.rs @@ -11,5 +11,5 @@ pub fn main() { let mut i = ~0; *i = 1; - fail_unless!(*i == 1); + assert!(*i == 1); } diff --git a/src/test/run-pass/unique-object.rs b/src/test/run-pass/unique-object.rs index f2aab3bbb51df..1cf4cf09b81cd 100644 --- a/src/test/run-pass/unique-object.rs +++ b/src/test/run-pass/unique-object.rs @@ -25,6 +25,6 @@ impl Foo for Bar { pub fn main() { let x = ~Bar { x: 10 }; let y = x as ~Foo; - fail_unless!(y.f() == 10); + assert!(y.f() == 10); } diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs index ef9ed082c00ec..49a873e793a8d 100644 --- a/src/test/run-pass/unique-pat-2.rs +++ b/src/test/run-pass/unique-pat-2.rs @@ -14,7 +14,7 @@ struct Foo {a: int, b: uint} enum bar { u(~Foo), w(int), } pub fn main() { - fail_unless!(match u(~Foo{a: 10, b: 40u}) { + assert!(match u(~Foo{a: 10, b: 40u}) { u(~Foo{a: a, b: b}) => { a + (b as int) } _ => { 66 } } == 50); diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs index 14fc1cca4e5d4..78551b701f29b 100644 --- a/src/test/run-pass/unique-pat-3.rs +++ b/src/test/run-pass/unique-pat-3.rs @@ -12,7 +12,7 @@ enum bar { u(~int), w(int), } pub fn main() { - fail_unless!(match u(~10) { + assert!(match u(~10) { u(a) => { error!(a); *a diff --git a/src/test/run-pass/unique-pinned-nocopy-2.rs b/src/test/run-pass/unique-pinned-nocopy-2.rs index ff22c18b02c74..d3cdc9a878875 100644 --- a/src/test/run-pass/unique-pinned-nocopy-2.rs +++ b/src/test/run-pass/unique-pinned-nocopy-2.rs @@ -32,5 +32,5 @@ pub fn main() { { let j = ~r(i); } - fail_unless!(*i == 1); + assert!(*i == 1); } diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs index b1b833f916332..0564c2ebddd12 100644 --- a/src/test/run-pass/unique-rec.rs +++ b/src/test/run-pass/unique-rec.rs @@ -13,5 +13,5 @@ struct X { x: int } pub fn main() { let x = ~X {x: 1}; let bar = x; - fail_unless!(bar.x == 1); + assert!(bar.x == 1); } diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index d7c70b550805a..b655f86bdbb11 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -31,5 +31,5 @@ pub fn main() { actual += *j; } - fail_unless!(expected == actual); + assert!(expected == actual); } diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index 3b2569c271218..c9d3a9519209d 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -14,5 +14,5 @@ pub fn main() { let (p, c) = stream(); c.send(~100); let v = p.recv(); - fail_unless!(v == ~100); + assert!(v == ~100); } diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs index fd869d2e04367..6cd7b358c55e7 100644 --- a/src/test/run-pass/unique-swap.rs +++ b/src/test/run-pass/unique-swap.rs @@ -12,6 +12,6 @@ pub fn main() { let mut i = ~100; let mut j = ~200; i <-> j; - fail_unless!(i == ~200); - fail_unless!(j == ~100); + assert!(i == ~200); + assert!(j == ~100); } diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs index 1468b47706ddc..05c9cd8a57400 100644 --- a/src/test/run-pass/unsafe-pointer-assignability.rs +++ b/src/test/run-pass/unsafe-pointer-assignability.rs @@ -10,7 +10,7 @@ fn f(x: *int) { unsafe { - fail_unless!(*x == 3); + assert!(*x == 3); } } diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs index 80672f78514ef..f76868b28bef4 100644 --- a/src/test/run-pass/unwind-resource.rs +++ b/src/test/run-pass/unwind-resource.rs @@ -42,5 +42,5 @@ pub fn main() { let c = SharedChan(c); task::spawn_unlinked(|| f(c.clone()) ); error!("hiiiiiiiii"); - fail_unless!(p.recv()); + assert!(p.recv()); } diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index a78461ff4eee8..51fc42491e059 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -15,14 +15,14 @@ pub fn main() { let y_diaeresis: char = 'ÿ'; // 0xff let pi: char = 'Π'; // 0x3a0 - fail_unless!((yen as int == 0xa5)); - fail_unless!((c_cedilla as int == 0xe7)); - fail_unless!((thorn as int == 0xfe)); - fail_unless!((y_diaeresis as int == 0xff)); - fail_unless!((pi as int == 0x3a0)); + assert!((yen as int == 0xa5)); + assert!((c_cedilla as int == 0xe7)); + assert!((thorn as int == 0xfe)); + assert!((y_diaeresis as int == 0xff)); + assert!((pi as int == 0x3a0)); - fail_unless!((pi as int == '\u03a0' as int)); - fail_unless!(('\x0a' as int == '\n' as int)); + assert!((pi as int == '\u03a0' as int)); + assert!(('\x0a' as int == '\n' as int)); let bhutan: ~str = ~"འབྲུག་ཡུལ།"; let japan: ~str = ~"日本"; @@ -37,7 +37,7 @@ pub fn main() { let austria_e: ~str = ~"\u00d6sterreich"; let oo: char = 'Ö'; - fail_unless!((oo as int == 0xd6)); + assert!((oo as int == 0xd6)); fn check_str_eq(a: ~str, b: ~str) { let mut i: int = 0; @@ -46,7 +46,7 @@ pub fn main() { debug!(ab); let bb: u8 = b[i]; debug!(bb); - fail_unless!((ab == bb)); + assert!((ab == bb)); i += 1; } } diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index 247fd2d712a16..714fd6e3ac5ab 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -15,25 +15,25 @@ pub fn main() { let chs: ~[char] = ~['e', 'é', '€', 0x10000 as char]; let s: ~str = str::from_chars(chs); - fail_unless!((str::len(s) == 10u)); - fail_unless!((str::char_len(s) == 4u)); - fail_unless!((vec::len(str::to_chars(s)) == 4u)); - fail_unless!((str::from_chars(str::to_chars(s)) == s)); - fail_unless!((str::char_at(s, 0u) == 'e')); - fail_unless!((str::char_at(s, 1u) == 'é')); + assert!((str::len(s) == 10u)); + assert!((str::char_len(s) == 4u)); + assert!((vec::len(str::to_chars(s)) == 4u)); + assert!((str::from_chars(str::to_chars(s)) == s)); + assert!((str::char_at(s, 0u) == 'e')); + assert!((str::char_at(s, 1u) == 'é')); - fail_unless!((str::is_utf8(str::to_bytes(s)))); - fail_unless!((!str::is_utf8(~[0x80_u8]))); - fail_unless!((!str::is_utf8(~[0xc0_u8]))); - fail_unless!((!str::is_utf8(~[0xc0_u8, 0x10_u8]))); + assert!((str::is_utf8(str::to_bytes(s)))); + assert!((!str::is_utf8(~[0x80_u8]))); + assert!((!str::is_utf8(~[0xc0_u8]))); + assert!((!str::is_utf8(~[0xc0_u8, 0x10_u8]))); let mut stack = ~"a×c€"; - fail_unless!((str::pop_char(&mut stack) == '€')); - fail_unless!((str::pop_char(&mut stack) == 'c')); + assert!((str::pop_char(&mut stack) == '€')); + assert!((str::pop_char(&mut stack) == 'c')); str::push_char(&mut stack, 'u'); - fail_unless!((stack == ~"a×u")); - fail_unless!((str::shift_char(&mut stack) == 'a')); - fail_unless!((str::shift_char(&mut stack) == '×')); + assert!((stack == ~"a×u")); + assert!((str::shift_char(&mut stack) == 'a')); + assert!((str::shift_char(&mut stack) == '×')); str::unshift_char(&mut stack, 'ß'); - fail_unless!((stack == ~"ßu")); + assert!((stack == ~"ßu")); } diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs index 58fd9216b158a..25d2d91d565df 100644 --- a/src/test/run-pass/utf8_idents.rs +++ b/src/test/run-pass/utf8_idents.rs @@ -12,8 +12,8 @@ pub fn main() { let ε = 0.00001; let Π = 3.14; let लंच = Π * Π + 1.54; - fail_unless!(float::abs((लंच - 1.54) - (Π * Π)) < ε); - fail_unless!(საჭმელად_გემრიელი_სადილი() == 0); + assert!(float::abs((लंच - 1.54) - (Π * Π)) < ε); + assert!(საჭმელად_გემრიელი_სადილი() == 0); } fn საჭმელად_გემრიელი_სადილი() -> int { @@ -37,9 +37,9 @@ fn საჭმელად_გემრიელი_სადილი() -> int // Lunchy arithmetic, mm. - fail_unless!(hádegismatur * ручек * обед == 1000); - fail_unless!(10 == ארוחת_צהריי); - fail_unless!(ランチ + 午餐 + μεσημεριανό == 30); - fail_unless!(ăn_trưa + อาหารกลางวัน == 20); + assert!(hádegismatur * ручек * обед == 1000); + assert!(10 == ארוחת_צהריי); + assert!(ランチ + 午餐 + μεσημεριανό == 30); + assert!(ăn_trưa + อาหารกลางวัน == 20); return (абед + լանչ) >> غداء; } diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs index 7023c50d0bd7e..0045b356d652e 100644 --- a/src/test/run-pass/vec-concat.rs +++ b/src/test/run-pass/vec-concat.rs @@ -14,7 +14,7 @@ pub fn main() { let b: ~[int] = ~[6, 7, 8, 9, 0]; let v: ~[int] = a + b; debug!(v[9]); - fail_unless!((v[0] == 1)); - fail_unless!((v[7] == 8)); - fail_unless!((v[9] == 0)); + assert!((v[0] == 1)); + assert!((v[7] == 8)); + assert!((v[9] == 0)); } diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index 84049c9a7566d..e1e268e63deb5 100644 --- a/src/test/run-pass/vec-growth.rs +++ b/src/test/run-pass/vec-growth.rs @@ -16,9 +16,9 @@ pub fn main() { v += ~[3]; v += ~[4]; v += ~[5]; - fail_unless!((v[0] == 1)); - fail_unless!((v[1] == 2)); - fail_unless!((v[2] == 3)); - fail_unless!((v[3] == 4)); - fail_unless!((v[4] == 5)); + assert!((v[0] == 1)); + assert!((v[1] == 2)); + assert!((v[2] == 3)); + assert!((v[3] == 4)); + assert!((v[4] == 5)); } diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs index 615d77f18e9bc..012b8b83637aa 100644 --- a/src/test/run-pass/vec-matching-autoslice.rs +++ b/src/test/run-pass/vec-matching-autoslice.rs @@ -3,7 +3,7 @@ pub fn main() { match x { [2, .._] => ::core::util::unreachable(), [1, ..tail] => { - fail_unless!(tail == [2, 3]); + assert!(tail == [2, 3]); } [_] => ::core::util::unreachable(), [] => ::core::util::unreachable() @@ -13,9 +13,9 @@ pub fn main() { match y { ([_, _, _], 0.5) => ::core::util::unreachable(), ([(1, a), (b, false), ..tail], _) => { - fail_unless!(a == true); - fail_unless!(b == 2); - fail_unless!(tail.is_empty()); + assert!(a == true); + assert!(b == 2); + assert!(tail.is_empty()); } ([..tail], _) => ::core::util::unreachable() } diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs index dfd4f025c139f..e6b7bffc1583d 100644 --- a/src/test/run-pass/vec-matching-fold.rs +++ b/src/test/run-pass/vec-matching-fold.rs @@ -26,8 +26,8 @@ pub fn main() { let x = [1, 2, 3, 4, 5]; let product = foldl(x, 1, |a, b| a * *b); - fail_unless!(product == 120); + assert!(product == 120); let sum = foldr(x, 0, |a, b| *a + b); - fail_unless!(sum == 15); + assert!(sum == 15); } diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs index 1402dd18fc72d..e9cf400334cbe 100644 --- a/src/test/run-pass/vec-matching.rs +++ b/src/test/run-pass/vec-matching.rs @@ -6,7 +6,7 @@ fn a() { [_, .._, _, _] => ::core::util::unreachable(), [_, _] => ::core::util::unreachable(), [a] => { - fail_unless!(a == 1); + assert!(a == 1); } [] => ::core::util::unreachable() } @@ -16,33 +16,33 @@ fn b() { let x = [1, 2, 3]; match x { [a, b, ..c] => { - fail_unless!(a == 1); - fail_unless!(b == 2); - fail_unless!(c == &[3]); + assert!(a == 1); + assert!(b == 2); + assert!(c == &[3]); } _ => fail!() } match x { [..a, b, c] => { - fail_unless!(a == &[1]); - fail_unless!(b == 2); - fail_unless!(c == 3); + assert!(a == &[1]); + assert!(b == 2); + assert!(c == 3); } _ => fail!() } match x { [a, ..b, c] => { - fail_unless!(a == 1); - fail_unless!(b == &[2]); - fail_unless!(c == 3); + assert!(a == 1); + assert!(b == &[2]); + assert!(c == 3); } _ => fail!() } match x { [a, b, c] => { - fail_unless!(a == 1); - fail_unless!(b == 2); - fail_unless!(c == 3); + assert!(a == 1); + assert!(b == 2); + assert!(c == 3); } _ => fail!() } diff --git a/src/test/run-pass/vec-position.rs b/src/test/run-pass/vec-position.rs index a1dddf330253f..aaf232f204654 100644 --- a/src/test/run-pass/vec-position.rs +++ b/src/test/run-pass/vec-position.rs @@ -10,7 +10,7 @@ pub fn main() { let mut v = ~[1, 2, 3]; - fail_unless!(v.position(|x| *x == 1) == Some(0)); - fail_unless!(v.position(|x| *x == 3) == Some(2)); - fail_unless!(v.position(|x| *x == 17) == None); + assert!(v.position(|x| *x == 1) == Some(0)); + assert!(v.position(|x| *x == 3) == Some(2)); + assert!(v.position(|x| *x == 17) == None); } diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs index 00b55aa9a01f6..acd9cf6f01bda 100644 --- a/src/test/run-pass/vec-self-append.rs +++ b/src/test/run-pass/vec-self-append.rs @@ -14,17 +14,17 @@ fn test_heap_to_heap() { // a spills onto the heap let mut a = ~[0, 1, 2, 3, 4]; a = a + a; // FIXME(#3387)---can't write a += a - fail_unless!((vec::len(a) == 10u)); - fail_unless!((a[0] == 0)); - fail_unless!((a[1] == 1)); - fail_unless!((a[2] == 2)); - fail_unless!((a[3] == 3)); - fail_unless!((a[4] == 4)); - fail_unless!((a[5] == 0)); - fail_unless!((a[6] == 1)); - fail_unless!((a[7] == 2)); - fail_unless!((a[8] == 3)); - fail_unless!((a[9] == 4)); + assert!((vec::len(a) == 10u)); + assert!((a[0] == 0)); + assert!((a[1] == 1)); + assert!((a[2] == 2)); + assert!((a[3] == 3)); + assert!((a[4] == 4)); + assert!((a[5] == 0)); + assert!((a[6] == 1)); + assert!((a[7] == 2)); + assert!((a[8] == 3)); + assert!((a[9] == 4)); } fn test_stack_to_heap() { @@ -32,13 +32,13 @@ fn test_stack_to_heap() { let mut a = ~[0, 1, 2]; // a spills to the heap a = a + a; // FIXME(#3387)---can't write a += a - fail_unless!((vec::len(a) == 6u)); - fail_unless!((a[0] == 0)); - fail_unless!((a[1] == 1)); - fail_unless!((a[2] == 2)); - fail_unless!((a[3] == 0)); - fail_unless!((a[4] == 1)); - fail_unless!((a[5] == 2)); + assert!((vec::len(a) == 6u)); + assert!((a[0] == 0)); + assert!((a[1] == 1)); + assert!((a[2] == 2)); + assert!((a[3] == 0)); + assert!((a[4] == 1)); + assert!((a[5] == 2)); } fn test_loop() { @@ -48,7 +48,7 @@ fn test_loop() { let mut expected_len = 1u; while i > 0 { error!(vec::len(a)); - fail_unless!((vec::len(a) == expected_len)); + assert!((vec::len(a) == expected_len)); a = a + a; // FIXME(#3387)---can't write a += a i -= 1; expected_len *= 2u; diff --git a/src/test/run-pass/vec-slice-drop.rs b/src/test/run-pass/vec-slice-drop.rs index 2a7c9610ad42e..cc0649790fd87 100644 --- a/src/test/run-pass/vec-slice-drop.rs +++ b/src/test/run-pass/vec-slice-drop.rs @@ -32,7 +32,7 @@ pub fn main() { let x = @mut 0; { let l = &[foo(x)]; - fail_unless!(*l[0].x == 0); + assert!(*l[0].x == 0); } - fail_unless!(*x == 1); + assert!(*x == 1); } diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index cbf5edd1718dd..8e653d21ec664 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -11,6 +11,6 @@ pub fn main() { let v = ~[1,2,3,4,5]; let v2 = vec::slice(v, 1, 3); - fail_unless!((v2[0] == 2)); - fail_unless!((v2[1] == 3)); + assert!((v2[0] == 2)); + assert!((v2[1] == 3)); } diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs index 6fbae42435e93..fd65f150e4c91 100644 --- a/src/test/run-pass/vec-tail-matching.rs +++ b/src/test/run-pass/vec-tail-matching.rs @@ -10,18 +10,18 @@ pub fn main() { ]; match x { [first, ..tail] => { - fail_unless!(first.string == ~"foo"); - fail_unless!(tail.len() == 2); - fail_unless!(tail[0].string == ~"bar"); - fail_unless!(tail[1].string == ~"baz"); + assert!(first.string == ~"foo"); + assert!(tail.len() == 2); + assert!(tail[0].string == ~"bar"); + assert!(tail[1].string == ~"baz"); match tail { [Foo { _ }, _, Foo { _ }, ..tail] => { ::core::util::unreachable(); } [Foo { string: a }, Foo { string: b }] => { - fail_unless!(a == ~"bar"); - fail_unless!(b == ~"baz"); + assert!(a == ~"bar"); + assert!(b == ~"baz"); } _ => { ::core::util::unreachable(); diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index b7130bfc71950..1767dd3ee5b39 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -9,16 +9,16 @@ // except according to those terms. pub fn main() { - fail_unless!((~[0, 1]).to_str() == ~"[0, 1]"); - fail_unless!((&[1, 2]).to_str() == ~"[1, 2]"); - fail_unless!((@[2, 3]).to_str() == ~"[2, 3]"); + assert!((~[0, 1]).to_str() == ~"[0, 1]"); + assert!((&[1, 2]).to_str() == ~"[1, 2]"); + assert!((@[2, 3]).to_str() == ~"[2, 3]"); let foo = ~[3, 4]; let bar = &[4, 5]; let baz = @[5, 6]; - fail_unless!(foo.to_str() == ~"[3, 4]"); - fail_unless!(bar.to_str() == ~"[4, 5]"); - fail_unless!(baz.to_str() == ~"[5, 6]"); + assert!(foo.to_str() == ~"[3, 4]"); + assert!(bar.to_str() == ~"[4, 5]"); + assert!(baz.to_str() == ~"[5, 6]"); } diff --git a/src/test/run-pass/vec-trailing-comma.rs b/src/test/run-pass/vec-trailing-comma.rs index 2891479272089..686fc655bdb76 100644 --- a/src/test/run-pass/vec-trailing-comma.rs +++ b/src/test/run-pass/vec-trailing-comma.rs @@ -13,8 +13,8 @@ pub fn main() { let v1: ~[int] = ~[10, 20, 30,]; let v2: ~[int] = ~[10, 20, 30]; - fail_unless!((v1[2] == v2[2])); + assert!((v1[2] == v2[2])); let v3: ~[int] = ~[10,]; let v4: ~[int] = ~[10]; - fail_unless!((v3[0] == v4[0])); + assert!((v3[0] == v4[0])); } diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs index 07365f346a736..d021588814780 100644 --- a/src/test/run-pass/vec.rs +++ b/src/test/run-pass/vec.rs @@ -14,12 +14,12 @@ // -*- rust -*- pub fn main() { let v: ~[int] = ~[10, 20]; - fail_unless!((v[0] == 10)); - fail_unless!((v[1] == 20)); + assert!((v[0] == 10)); + assert!((v[1] == 20)); let mut x: int = 0; - fail_unless!((v[x] == 10)); - fail_unless!((v[x + 1] == 20)); + assert!((v[x] == 10)); + assert!((v[x + 1] == 20)); x = x + 1; - fail_unless!((v[x] == 20)); - fail_unless!((v[x - 1] == 10)); + assert!((v[x] == 20)); + assert!((v[x - 1] == 10)); } diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index 0af35a6c619e5..ed0032b93eafe 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -22,7 +22,7 @@ fn what() { let i = @mut false; let dont = {||the(i)}; dont(); - fail_unless!((*i)); + assert!((*i)); } fn zombiejesus() { @@ -57,8 +57,8 @@ fn notsure() { fn canttouchthis() -> uint { fn p() -> bool { true } - let _a = (fail_unless!((true)) == (fail_unless!(p()))); - let _c = (fail_unless!((p())) == ()); + let _a = (assert!((true)) == (assert!(p()))); + let _c = (assert!((p())) == ()); let _b: bool = (debug!("%d", 0) == (return 0u)); } diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs index 5a67f98423d9c..37528a7cfaece 100644 --- a/src/test/run-pass/while-cont.rs +++ b/src/test/run-pass/while-cont.rs @@ -12,7 +12,7 @@ pub fn main() { let mut i = 1; while i > 0 { - fail_unless!((i > 0)); + assert!((i > 0)); debug!(i); i -= 1; loop; diff --git a/src/test/run-pass/while-loop-constraints-2.rs b/src/test/run-pass/while-loop-constraints-2.rs index 13376eddc41e8..7b5cd095849e6 100644 --- a/src/test/run-pass/while-loop-constraints-2.rs +++ b/src/test/run-pass/while-loop-constraints-2.rs @@ -18,5 +18,5 @@ pub fn main() { while false { x = y; y = z; } debug!(y); } - fail_unless!((y == 42 && z == 50)); + assert!((y == 42 && z == 50)); } diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs index 0644c55f8c803..417c0cdd9157f 100644 --- a/src/test/run-pass/while-with-break.rs +++ b/src/test/run-pass/while-with-break.rs @@ -15,5 +15,5 @@ pub fn main() { break; } } - fail_unless!((i == 95)); + assert!((i == 95)); } diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index cfc94b67b570f..f22f90380c6c4 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -19,5 +19,5 @@ fn f(p: &mut Point) { p.z = 13; } pub fn main() { let mut x: Point = Point {x: 10, y: 11, z: 12}; f(&mut x); - fail_unless!((x.z == 13)); + assert!((x.z == 13)); } diff --git a/src/test/run-pass/x86stdcall.rs b/src/test/run-pass/x86stdcall.rs index b1421dce0ae83..c7c47753b8a82 100644 --- a/src/test/run-pass/x86stdcall.rs +++ b/src/test/run-pass/x86stdcall.rs @@ -25,7 +25,7 @@ pub fn main() { kernel32::SetLastError(expected); let actual = kernel32::GetLastError(); log(error, actual); - fail_unless!((expected == actual)); + assert!((expected == actual)); } } diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs index 672505f631518..9145abbf5cb9e 100644 --- a/src/test/run-pass/x86stdcall2.rs +++ b/src/test/run-pass/x86stdcall2.rs @@ -32,9 +32,9 @@ mod kernel32 { pub fn main() { let heap = unsafe { kernel32::GetProcessHeap() }; let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) }; - fail_unless!(mem != 0u); + assert!(mem != 0u); let res = unsafe { kernel32::HeapFree(heap, 0u32, mem) }; - fail_unless!(res != 0u8); + assert!(res != 0u8); } #[cfg(target_os = "macos")] diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs index 1876e976c5063..50c3e78006111 100644 --- a/src/test/run-pass/zip-same-length.rs +++ b/src/test/run-pass/zip-same-length.rs @@ -12,7 +12,7 @@ // succeed at runtime fn enum_chars(start: u8, end: u8) -> ~[char] { - fail_unless!(start < end); + assert!(start < end); let mut i = start; let mut r = ~[]; while i <= end { r.push(i as char); i += 1u as u8; } @@ -20,7 +20,7 @@ fn enum_chars(start: u8, end: u8) -> ~[char] { } fn enum_uints(start: uint, end: uint) -> ~[uint] { - fail_unless!(start < end); + assert!(start < end); let mut i = start; let mut r = ~[]; while i <= end { r.push(i); i += 1u; } @@ -34,6 +34,6 @@ pub fn main() { let ps = vec::zip(chars, ints); - fail_unless!((ps.head() == &('a', 1u))); - fail_unless!((ps.last() == &(j as char, 10u))); + assert!((ps.head() == &('a', 1u))); + assert!((ps.last() == &(j as char, 10u))); }