about summary refs log tree commit diff
path: root/src/libstd/time.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/time.rs')
-rw-r--r--src/libstd/time.rs368
1 files changed, 184 insertions, 184 deletions
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 525f9284cc3..d008ad15006 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -56,7 +56,7 @@ pub struct Timespec { sec: i64, nsec: i32 }
  */
 pub impl Timespec {
     static pure fn new(sec: i64, nsec: i32) -> Timespec {
-        assert nsec >= 0 && nsec < NSEC_PER_SEC;
+        fail_unless!(nsec >= 0 && nsec < NSEC_PER_SEC);
         Timespec { sec: sec, nsec: nsec }
     }
 }
@@ -910,17 +910,17 @@ mod tests {
         let tv1 = get_time();
         debug!("tv1=%? sec + %? nsec", tv1.sec as uint, tv1.nsec as uint);
 
-        assert tv1.sec > some_recent_date;
-        assert tv1.nsec < 1000000000i32;
+        fail_unless!(tv1.sec > some_recent_date);
+        fail_unless!(tv1.nsec < 1000000000i32);
 
         let tv2 = get_time();
         debug!("tv2=%? sec + %? nsec", tv2.sec as uint, tv2.nsec as uint);
 
-        assert tv2.sec >= tv1.sec;
-        assert tv2.sec < some_future_date;
-        assert tv2.nsec < 1000000000i32;
+        fail_unless!(tv2.sec >= tv1.sec);
+        fail_unless!(tv2.sec < some_future_date);
+        fail_unless!(tv2.nsec < 1000000000i32);
         if tv2.sec == tv1.sec {
-            assert tv2.nsec >= tv1.nsec;
+            fail_unless!(tv2.nsec >= tv1.nsec);
         }
     }
 
@@ -929,16 +929,16 @@ mod tests {
         let ns1 = precise_time_ns();
 
         debug!("s0=%s sec", float::to_str_digits(s0, 9u));
-        assert s0 > 0.;
+        fail_unless!(s0 > 0.);
         let ns0 = (s0 * 1000000000.) as u64;
         debug!("ns0=%? ns", ns0);
 
         debug!("ns1=%? ns", ns0);
-        assert ns1 >= ns0;
+        fail_unless!(ns1 >= ns0);
 
         let ns2 = precise_time_ns();
         debug!("ns2=%? ns", ns0);
-        assert ns2 >= ns1;
+        fail_unless!(ns2 >= ns1);
     }
 
     pub fn test_at_utc() {
@@ -948,18 +948,18 @@ mod tests {
         let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
-        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;
+        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);
     }
 
     pub fn test_at() {
@@ -971,23 +971,23 @@ mod tests {
 
         error!("time_at: %?", local);
 
-        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;
+        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);
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.
         let zone = &local.tm_zone;
-        assert *zone == ~"PST" || *zone == ~"Pacific Standard Time";
+        fail_unless!(*zone == ~"PST" || *zone == ~"Pacific Standard Time");
 
-        assert local.tm_nsec == 54321_i32;
+        fail_unless!(local.tm_nsec == 54321_i32);
     }
 
     pub fn test_to_timespec() {
@@ -997,8 +997,8 @@ mod tests {
         let time = ::time::Timespec::new(1234567890, 54321);
         let utc = at_utc(time);
 
-        assert utc.to_timespec() == time;
-        assert utc.to_local().to_timespec() == time;
+        fail_unless!(utc.to_timespec() == time);
+        fail_unless!(utc.to_local().to_timespec() == time);
     }
 
     pub fn test_conversions() {
@@ -1009,12 +1009,12 @@ mod tests {
         let utc = at_utc(time);
         let local = at(time);
 
-        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;
+        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);
     }
 
     pub fn test_strptime() {
@@ -1023,41 +1023,41 @@ mod tests {
 
         match strptime(~"", ~"") {
           Ok(ref tm) => {
-            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;
+            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);
           }
           Err(_) => ()
         }
 
         let format = ~"%a %b %e %T %Y";
-        assert strptime(~"", format) == Err(~"Invalid time");
-        assert strptime(~"Fri Feb 13 15:31:30", format)
-            == Err(~"Invalid time");
+        fail_unless!(strptime(~"", format) == Err(~"Invalid time"));
+        fail_unless!(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) => {
-            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;
+            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);
           }
         }
 
@@ -1077,7 +1077,7 @@ mod tests {
             ~"Friday",
             ~"Saturday"
         ]) |day| {
-            assert test(*day, ~"%A");
+            fail_unless!(test(*day, ~"%A"));
         }
 
         for vec::each([
@@ -1089,7 +1089,7 @@ mod tests {
             ~"Fri",
             ~"Sat"
         ]) |day| {
-            assert test(*day, ~"%a");
+            fail_unless!(test(*day, ~"%a"));
         }
 
         for vec::each([
@@ -1106,7 +1106,7 @@ mod tests {
             ~"November",
             ~"December"
         ]) |day| {
-            assert test(*day, ~"%B");
+            fail_unless!(test(*day, ~"%B"));
         }
 
         for vec::each([
@@ -1123,52 +1123,52 @@ mod tests {
             ~"Nov",
             ~"Dec"
         ]) |day| {
-            assert test(*day, ~"%b");
+            fail_unless!(test(*day, ~"%b"));
         }
 
-        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";
-        assert result::unwrap(strptime(~"PST", ~"%Z")).tm_zone == ~"";
-        assert result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff == 0;
-        assert result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff == 0;
-        assert test(~"%", ~"%%");
+        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 == ~"UTC");
+        fail_unless!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone == ~"");
+        fail_unless!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff == 0);
+        fail_unless!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff == 0);
+        fail_unless!(test(~"%", ~"%%"));
     }
 
     pub fn test_ctime() {
@@ -1181,8 +1181,8 @@ mod tests {
 
         error!("test_ctime: %? %?", utc.ctime(), local.ctime());
 
-        assert utc.ctime()   == ~"Fri Feb 13 23:31:30 2009";
-        assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";
+        fail_unless!(utc.ctime()   == ~"Fri Feb 13 23:31:30 2009");
+        fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
     }
 
     pub fn test_strftime() {
@@ -1193,69 +1193,69 @@ mod tests {
         let utc = at_utc(time);
         let local = at(time);
 
-        assert local.strftime(~"") == ~"";
-        assert local.strftime(~"%A") == ~"Friday";
-        assert local.strftime(~"%a") == ~"Fri";
-        assert local.strftime(~"%B") == ~"February";
-        assert local.strftime(~"%b") == ~"Feb";
-        assert local.strftime(~"%C") == ~"20";
-        assert local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009";
-        assert local.strftime(~"%D") == ~"02/13/09";
-        assert local.strftime(~"%d") == ~"13";
-        assert local.strftime(~"%e") == ~"13";
-        assert local.strftime(~"%F") == ~"2009-02-13";
-        // assert 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";
+        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");
         // handle "%X"
         // handle "%x"
-        assert local.strftime(~"%Y") == ~"2009";
-        assert local.strftime(~"%y") == ~"09";
+        fail_unless!(local.strftime(~"%Y") == ~"2009");
+        fail_unless!(local.strftime(~"%y") == ~"09");
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.
         let zone = local.strftime(~"%Z");
-        assert zone == ~"PST" || zone == ~"Pacific Standard Time";
+        fail_unless!(zone == ~"PST" || zone == ~"Pacific Standard Time");
 
-        assert local.strftime(~"%z") == ~"-0800";
-        assert local.strftime(~"%%") == ~"%";
+        fail_unless!(local.strftime(~"%z") == ~"-0800");
+        fail_unless!(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 ";
-        assert rfc822 == prefix + ~"PST" ||
-               rfc822 == prefix + ~"Pacific Standard Time";
+        fail_unless!(rfc822 == prefix + ~"PST" ||
+                     rfc822 == prefix + ~"Pacific Standard Time");
 
-        assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";
-        assert local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800";
-        assert local.rfc3339() == ~"2009-02-13T15:31:30-08:00";
+        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 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";
+        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");
     }
 
     pub fn test_timespec_eq_ord() {
@@ -1267,28 +1267,28 @@ mod tests {
         let d = &Timespec::new(2, 1);
         let e = &Timespec::new(2, 1);
 
-        assert eq(d, e);
-        assert ne(c, e);
+        fail_unless!(eq(d, e));
+        fail_unless!(ne(c, e));
 
-        assert lt(a, b);
-        assert lt(b, c);
-        assert lt(c, d);
+        fail_unless!(lt(a, b));
+        fail_unless!(lt(b, c));
+        fail_unless!(lt(c, d));
 
-        assert le(a, b);
-        assert le(b, c);
-        assert le(c, d);
-        assert le(d, e);
-        assert le(e, 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 ge(b, a);
-        assert ge(c, b);
-        assert ge(d, c);
-        assert ge(e, d);
-        assert ge(d, e);
+        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 gt(b, a);
-        assert gt(c, b);
-        assert gt(d, c);
+        fail_unless!(gt(b, a));
+        fail_unless!(gt(c, b));
+        fail_unless!(gt(d, c));
     }
 
     #[test]